PepperC1 Client

from pepper_c1 import PepperC1, UARTTransport

# as context manager (recommended)
with PepperC1(UARTTransport('COM3')) as reader:
    print(reader.get_version())

# manual lifecycle
reader = PepperC1(UARTTransport('COM3'), response_timeout=5.0)
try:
    print(reader.get_version())
finally:
    reader.close()

from pepper_c1.commands import Command

# direct use of a command not wrapped by a convenience method
version_raw = reader.send_command(Command.MFU_GET_VERSION)
sig = reader.send_command(Command.MFU_READ_SIG)

print(reader.get_version())  # e.g. "1.0.3"

count = reader.get_tag_count()
if count == 0:
    print("No tag in field")

uid_info = reader.get_uid(0)
type_byte = uid_info[0]
uid = uid_info[2:]
print(f"Type: 0x{type_byte:02X}, UID: {uid.hex()}")

reader.activate_tag(0)
# now MIFARE operations target this tag

reader.set_polling(True, interval_ms=250)
# ... do other work; async events accumulate in reader.async_events
reader.set_polling(False)

reader.set_active_antenna(1)   # switch to antenna 1
reader.set_active_antenna(4)   # switch to antenna 4

# cycle through all antennas
for ant in range(1, 9):
    reader.set_active_antenna(ant)
    count = reader.get_tag_count()
    if count:
        print(f"antenna {ant}: tag found")

from pepper_c1.commands import KEY_TYPE_MIFARE, KEY_TYPE_AES128, KEY_TYPE_DES

# MIFARE Classic: factory default key FFFFFFFFFFFF for both A and B
reader.set_key(0, KEY_TYPE_MIFARE, bytes([0xFF] * 12))

# DESFire: DES all-zeros (factory default PICC master key)
reader.set_key(0, KEY_TYPE_DES, bytes(16))

# DESFire: AES-128 all-zeros
reader.set_key(1, KEY_TYPE_AES128, bytes(16))

data = reader.mf_read_block(5)                    # 16 bytes
two_blocks = reader.mf_read_block(4, count=2)    # 32 bytes

reader.mf_write_block(5, b'\x00' * 16)  # clear block 5

val = reader.mf_read_value(6)
print(f"Value: {val}")

reader.mf_write_value(6, 1000)  # set value block to 1000

reader.mf_increment(6, 50)
val = reader.mf_read_value(6)  # 1050

page_data = reader.mfu_read_page(4)       # 4 bytes
eight_bytes = reader.mfu_read_page(4, count=2)

reader.mfu_write_page(4, b'\xDE\xAD\xBE\xEF')

val = reader.mfu_read_counter(0)
print(f"Counter 0: {val}")

reader.mfu_increment_counter(0, 1)

pack = reader.mfu_passwd_auth(b'\xFF\xFF\xFF\xFF')
print(f"PACK: {pack.hex()}")

reader.mfdf_select_app(b'\x00\x00\x00')   # PICC master
reader.mfdf_select_app(bytes([0xAA, 0x55, 0xAA]))  # custom app

aids = reader.mfdf_get_app_ids()
for aid in aids:
    print(aid.hex())

reader.mfdf_select_app(b'\x00\x00\x00')
reader.mfdf_auth(0, key_slot=0)   # DES key 0 from reader slot 0

reader.mfdf_auth_aes(1, key_slot=1)  # AES key 1 from reader slot 1

# Create app with 4 AES-128 keys (0x84 = 0x8«AES» | 4«keys»)
reader.mfdf_create_app(bytes([0xAA, 0x55, 0xAA]), key_settings=0xED, num_keys=0x84)

reader.mfdf_create_data_file(0x01, access_rights=0xEEEE, size=32, backup=True)

reader.mfdf_write_data(0x01, offset=0, data=b"Hello, DESFire!")
reader.mfdf_commit_transaction()

data = reader.mfdf_read_data(0x01, offset=0, length=15)
print(data.rstrip(b'\x00'))

reader.mfdf_create_value_file(0x02, access_rights=0xEEEE,
    lower_limit=-100, upper_limit=100,
    init_value=-5, limited_credit=True)

val = reader.mfdf_get_value(0x02)  # e.g. -5

reader.mfdf_credit(0x02, 10)
reader.mfdf_commit_transaction()

reader.mfdf_debit(0x02, 25)
reader.mfdf_commit_transaction()

record = b"\x01\x00" + b"My record data".ljust(32, b'\x00')
reader.mfdf_write_record(0x03, record)
reader.mfdf_commit_transaction()

# Read the newest record
raw = reader.mfdf_read_record(0x03, offset=0, record_size=34)
first_record = raw[:34]

data = reader.icode_read_block(5)   # 4 bytes

reader.icode_write_block(5, b'\x01\x02\x03\x04')

info = reader.icode_get_system_information()
print(info.hex(' '))