Configuration & Features

Examples for reading and writing reader configuration on rf IDEAS devices.

Get/Set Beeper Volume

C++

// After Init()
auto* reader = dynamic_cast<Reader*>(
    AbstractReader::GetInstance(handle)
);

// Get current volume
RikProtocol::BeepVolume volume;
reader->GetBeeperVolume(volume);
std::cout << "Volume: " << static_cast<int>(volume) << std::endl;

// Set volume
reader->SetBeeperVolume(RikProtocol::BEEP_VOLUME_HIGH);

C#

using var app = new Reader(readerDef);
app.Init();

// Get current volume
var volume = app.GetBeeperVolume();
Console.WriteLine($"Volume: {volume}");

// Set volume
app.SetBeeperVolume(BeepVolume.High);

Python

with rik.Reader(reader_def) as app:
    app.init()

    # Get current volume
    volume = app.get_beeper_volume()
    print(f"Volume: {volume}")

    # Set volume
    app.set_beeper_volume(BeepVolume.BEEP_VOLUME_HIGH)

Enable/Disable Keystroking

When keystroking is enabled, the reader emulates an HID keyboard and "types" card ID data as keystrokes to the host computer. Disable keystroking when using the SDK to read card data programmatically.

C++

auto* reader = dynamic_cast<Reader*>(
    AbstractReader::GetInstance(handle)
);

// Disable keystroking (e.g. for SDK-only mode)
reader->EnableKeystroking(false);

// Re-enable keystroking
reader->EnableKeystroking(true);

C#

using var app = new Reader(readerDef);
app.Init();

// Disable keystroking
app.EnableKeystroking(false);

// Re-enable keystroking
app.EnableKeystroking(true);

Python

with rik.Reader(reader_def) as app:
    app.init()

    # Disable keystroking
    app.enable_keystroking(False)

    # Re-enable keystroking
    app.enable_keystroking(True)

Transparent Mode

Transparent mode creates a passthrough mode through which direct communication with a LEGIC chip is made possible, bypassing the rf IDEAS firmware interface. This is intended for users who need to communicate directly with the chip. Transparent mode requires a reader with the READER_CAPABILITY_TRANSPARENT_MODE capability.

Get Transparent Mode Status

Query the current transparent mode state and readiness status. TransparentModeState indicates whether transparent mode is enabled or disabled. TransparentModeStatus indicates whether the reader is ready for transparent communication.

C++

auto* reader = dynamic_cast<Reader*>(
    AbstractReader::GetInstance(handle)
);

// Get the current transparent mode state and status
RikProtocol::TransparentModeState state;
RikProtocol::TransparentModeStatus status;
reader->GetTransparentModeStatus(state, status);

std::cout << "State: " << static_cast<int>(state) << std::endl;
std::cout << "Status: " << static_cast<int>(status) << std::endl;

C#

using var app = new Reader(readerDef);
app.Init();

// Get the current transparent mode state and status
app.GetTransparentModeStatus(out TransparentModeState state, out TransparentModeStatus status);
Console.WriteLine($"State: {state}");
Console.WriteLine($"Status: {status}");

Python

from reader_integration_kit.enum import TransparentModeState, TransparentModeStatus

with rik.Reader(reader_def) as app:
    app.init()

    # Get the current transparent mode state and status
    state, status = app.get_transparent_mode_status()
    print(f"State: {state}")
    print(f"Status: {status}")

Enable/Disable Transparent Mode

Enable or disable transparent mode on a connected reader. The writeToFlash parameter controls whether the setting persists across reader power cycles.

C++

auto* reader = dynamic_cast<Reader*>(
    AbstractReader::GetInstance(handle)
);

// Enable transparent mode (persist across power cycles)
reader->EnableTransparentMode(true, true);

// Disable transparent mode (persist across power cycles)
reader->EnableTransparentMode(false, true);

C#

using var app = new Reader(readerDef);
app.Init();

// Enable transparent mode (persist across power cycles)
app.EnableTransparentMode(true, true);

// Disable transparent mode (persist across power cycles)
app.EnableTransparentMode(false, true);

Python

with rik.Reader(reader_def) as app:
    app.init()

    # Enable transparent mode (persist across power cycles)
    app.enable_transparent_mode(True, True)

    # Disable transparent mode (persist across power cycles)
    app.enable_transparent_mode(False, True)

Get/Set LED Configuration

C++

auto* reader = dynamic_cast<Reader*>(
    AbstractReader::GetInstance(handle)
);

// Read LED config from slot 0
LedConfiguration ledConfig;
reader->GetLedConfiguration(0, ledConfig);

// Modify and write back
reader->SetLedConfiguration(0, ledConfig);

C#

using var app = new Reader(readerDef);
app.Init();

// Read LED config from slot 0
var ledConfig = app.GetLedConfiguration(0);
Console.WriteLine($"Color: {ledConfig.Color}");
Console.WriteLine($"Software Control: {ledConfig.SoftwareControlEnabled}");

// Write LED config
app.SetLedConfiguration(0, ledConfig);

Python

with rik.Reader(reader_def) as app:
    app.init()

    # Read LED config from slot 0
    led_config = app.get_led_configuration(0)

    # Write LED config
    app.set_led_configuration(0, led_config)

Get/Set Reader Configuration

Read and write the full reader configuration (ReaderConfiguration + ExtendedConfiguration).

C++

auto* reader = dynamic_cast<Reader*>(
    AbstractReader::GetInstance(handle)
);

// Read configuration from slot 0
RikCommon::ReaderConfiguration config;
RikProtocol::ExtendedConfiguration extConfig;
reader->GetReaderConfiguration(0, config, extConfig);

// Modify and write back
RikProtocol::HashData hashData;
reader->SetReaderConfiguration(0, config, extConfig, hashData);

C#

using var app = new Reader(readerDef);
app.Init();

// Read configuration from slot 0
var (config, extConfig) = app.GetReaderConfiguration(0);

// Modify and write back
app.SetReaderConfiguration(0, config, extConfig, new HashData());

Python

from reader_integration_kit.structures import HashData

with rik.Reader(reader_def) as app:
    app.init()

    # Read configuration from slot 0
    config, ext_config = app.get_reader_configuration(0)

    # Modify and write back
    hash_data = HashData()
    app.set_reader_configuration(0, config, ext_config, hash_data)

Get/Set Module State

Control reader module power (e.g. radio on/off).

C++

auto* reader = dynamic_cast<Reader*>(
    AbstractReader::GetInstance(handle)
);

// Get current state of the low-frequency radio
RikProtocol::ReaderModuleState state;
reader->GetModuleState(RikProtocol::ReaderModuleId::LowFrequencyRadio, state);

// Power off the low-frequency radio
reader->SetModuleState(
    RikProtocol::ReaderModuleId::LowFrequencyRadio,
    RikProtocol::ReaderModuleState::PowerOff
);

// Power it back on
reader->SetModuleState(
    RikProtocol::ReaderModuleId::LowFrequencyRadio,
    RikProtocol::ReaderModuleState::PowerOnNormal
);

C#

using var app = new Reader(readerDef);
app.Init();

// Get current state of the low-frequency radio
var state = app.GetModuleState(ReaderModuleId.LowFrequencyRadio);
Console.WriteLine($"State: {state}");

// Power off the low-frequency radio
app.SetModuleState(ReaderModuleId.LowFrequencyRadio, ReaderModuleState.PowerOff);

// Power it back on
app.SetModuleState(ReaderModuleId.LowFrequencyRadio, ReaderModuleState.PowerOnNormal);

Python

from reader_integration_kit.enum import ReaderModuleId, ReaderModuleState

with rik.Reader(reader_def) as app:
    app.init()

    # Get current state of the low-frequency radio
    state = app.get_module_state(ReaderModuleId.LOW_FREQUENCY_RADIO)
    print(f"State: {state}")

    # Power off the low-frequency radio
    app.set_module_state(
        ReaderModuleId.LOW_FREQUENCY_RADIO,
        ReaderModuleState.POWER_OFF
    )

    # Power it back on
    app.set_module_state(
        ReaderModuleId.LOW_FREQUENCY_RADIO,
        ReaderModuleState.POWER_ON_NORMAL
    )

Get/Set LUID

C++

auto* reader = dynamic_cast<Reader*>(
    AbstractReader::GetInstance(handle)
);

// Get LUID
RikProtocol::LuidResponseInformation luidInfo;
reader->GetLuid(luidInfo);
std::cout << "LUID: " << luidInfo.Luid << std::endl;

// Set LUID
reader->SetLuid(42);

C#

using var app = new Reader(readerDef);
app.Init();

// Get LUID
var luidInfo = app.GetLuid();
Console.WriteLine($"LUID: {luidInfo.Luid}");

// Set LUID
app.SetLuid(42);

Python

with rik.Reader(reader_def) as app:
    app.init()

    # Get LUID
    luid_info = app.get_luid()
    print(f"LUID: {luid_info.Luid}")

    # Set LUID
    app.set_luid(42)

Get Supported Card Types

C++

auto* reader = dynamic_cast<Reader*>(
    AbstractReader::GetInstance(handle)
);

std::vector<RikCommon::CardType> cardTypes;
reader->GetSupportedCardTypes(cardTypes);

for (const auto& ct : cardTypes) {
    std::cout << "Card Type: " << ct.Name << std::endl;
}

C#

using var app = new Reader(readerDef);
app.Init();

var cardTypes = app.GetSupportedCardTypes();
foreach (var ct in cardTypes)
{
    Console.WriteLine($"Card Type: {ct.Name}");
}

Python

with rik.Reader(reader_def) as app:
    app.init()

    card_types = app.get_supported_card_types()
    for ct in card_types:
        print(f"Card Type: {ct}")

Read/Write BLE Configuration

C++

auto* reader = dynamic_cast<Reader*>(
    AbstractReader::GetInstance(handle)
);

// Read BLE configuration to file
reader->ReadBleConfigurationFromReader(
    RikCommon::BleDataType::Data, "ble_backup.hwg+");

// Write BLE configuration from file
reader->WriteBleConfigurationToReader(
    RikCommon::BleDataType::Data, "ble_config.hwg+");

C#

using var app = new Reader(readerDef);
app.Init();

// Read BLE configuration to file
app.ReadBleConfigurationFromReader(BleDataType.Data, "ble_backup.hwg+");

// Write BLE configuration from file
app.WriteBleConfigurationToReader(BleDataType.Data, "ble_config.hwg+");

Python

from reader_integration_kit.enum import BleDataType

with rik.Reader(reader_def) as app:
    app.init()

    # Read BLE configuration to file
    app.read_ble_configuration_from_reader(BleDataType.DATA, "ble_backup.hwg+")

    # Write BLE configuration from file
    app.write_ble_configuration_to_reader(BleDataType.DATA, "ble_config.hwg+")

note

BLE configuration operations require a reader with Bluetooth capability. Check the reader's capability profile before calling these methods.

Reset to Factory / User Defaults

C++

auto* reader = dynamic_cast<Reader*>(
    AbstractReader::GetInstance(handle)
);

// Reset to factory defaults
reader->ResetReaderConfiguration(CheckpointType::FactoryDefaults);

// Or reset to user defaults
reader->ResetReaderConfiguration(CheckpointType::UserDefaults);

// Save current config as user defaults
reader->WriteUserDefaultsToReader();

C#

using var app = new Reader(readerDef);
app.Init();

// Reset to factory defaults
app.ResetReaderConfiguration(CheckpointType.FactoryDefaults);

// Or reset to user defaults
app.ResetReaderConfiguration(CheckpointType.UserDefaults);

Python

from reader_integration_kit.enum import CheckpointType

with rik.Reader(reader_def) as app:
    app.init()

    # Reset to factory defaults
    app.reset_reader_configuration(CheckpointType.FACTORY_DEFAULTS)

    # Or reset to user defaults
    app.reset_reader_configuration(CheckpointType.USER_DEFAULTS)

warning

Resetting to factory defaults erases all custom configuration. Consider backing up the configuration with ReadHwgFileFromReader first.