Companion-Protokoll

[Pakettyp (1 Byte)] [Daten (variable Länge)]

Byte 0: 0x01
Bytes 1-7: Reserviert (wird derzeit von der Firmware ignoriert)
Bytes 8+: Anwendungsname (UTF-8, optional)

01 00 00 00 00 00 00 00 6d 63 63 6c 69

Byte 0: 0x16
Byte 1: 0x03

16 03

Byte 0: 0x1F
Byte 1: Kanalindex (0-7)

1F 01

Byte 0: 0x20
Byte 1: Kanalindex (0-7)
Bytes 2-33: Kanalname (32 Bytes, UTF-8, mit Nullen aufgefüllt)
Bytes 34-49: Geheimnis (16 Bytes)

20 01 53 4D 53 00 00 ... (Name auf 32 Bytes aufgefüllt)
    [16 Bytes Geheimnis]

Byte 0: 0x03
Byte 1: 0x00
Byte 2: Kanalindex (0-7)
Bytes 3-6: Zeitstempel (32-Bit Little-Endian Unix-Zeitstempel, Sekunden)
Bytes 7+: Nachrichtentext (UTF-8, variable Länge)

03 00 01 D2 02 96 49 48 65 6C 6C 6F

Byte 0:                         0x3E
Byte 1:                         Kanalindex (0-7)
Byte 2:                         Pfadlänge (0xFF = Flood, ansonsten tatsächliche Pfadlänge)
Bytes 3 .. 2+path_len:          Pfad (entfällt, wenn path_len == 0xFF)
Nächste 2 Bytes (Little-Endian): Datentyp (`data_type`, uint16)
Verbleibende Bytes:             Binäre Nutzdaten (variable Länge)

3E 01 FF FF FF A1 B2 C3

Byte 0:                 0x1B (Pakettyp)
Byte 1:                 SNR (signed int8, skaliert ×4 — dividieren Sie durch 4.0, um dB zu erhalten)
Bytes 2-3:              Reserviert (Clients MÜSSEN ignorieren)
Byte 4:                 Kanalindex (0-7)
Byte 5:                 Pfadlänge (tatsächliche Pfadlänge bei Flood, ansonsten 0xFF für direkt)
Bytes 6-7:              Datentyp (uint16 Little-Endian)
Byte 8:                 Datenlänge
Bytes 9 .. 8+data_len:  Nutzdaten

def parse_channel_data_recv(data):
    if len(data) < 9:
        return None
    snr_byte = data[1]
    snr = (snr_byte if snr_byte < 128 else snr_byte - 256) / 4.0
    channel_idx = data[4]
    path_len = data[5]
    data_type = int.from_bytes(data[6:8], 'little')
    data_len = data[8]
    if 9 + data_len > len(data):
        return None
    payload = data[9:9 + data_len]
    return {
        'snr': snr,
        'channel_idx': channel_idx,
        'path_len': path_len,
        'data_type': data_type,
        'payload': bytes(payload),
    }

Byte 0: 0x0A

0A

Byte 0: 0x14

14

Byte 0: 0x07 (Pakettyp)
Bytes 1-6: Präfix des öffentlichen Schlüssels (6 Bytes, hexadezimal)
Byte 7: Pfadlänge
Byte 8: Texttyp
Bytes 9-12: Zeitstempel (32-Bit Little-Endian)
Bytes 13-16: Signatur (4 Bytes, nur wenn txt_type == 2)
Bytes 17+: Nachrichtentext (UTF-8)

Byte 0: 0x10 (Pakettyp)
Byte 1: SNR (vorzeichenbehaftetes Byte, multipliziert mit 4)
Bytes 2-3: Reserviert
Bytes 4-9: Präfix des öffentlichen Schlüssels (6 Bytes, hexadezimal)
Byte 10: Pfadlänge
Byte 11: Texttyp
Bytes 12-15: Zeitstempel (32-Bit Little-Endian)
Bytes 16-19: Signatur (4 Bytes, nur wenn txt_type == 2)
Bytes 20+: Nachrichtentext (UTF-8)

def parse_contact_message(data):
    packet_type = data[0]
    offset = 1
    
    # Auf V3-Format prüfen
    if packet_type == 0x10:  # V3
        snr_byte = data[offset]
        snr = ((snr_byte if snr_byte < 128 else snr_byte - 256) / 4.0)
        offset += 3  # SNR + reserviert überspringen
    
    pubkey_prefix = data[offset:offset+6].hex()
    offset += 6
    
    path_len = data[offset]
    txt_type = data[offset + 1]
    offset += 2
    
    timestamp = int.from_bytes(data[offset:offset+4], 'little')
    offset += 4
    
    # Wenn txt_type == 2, 4-Byte-Signatur überspringen
    if txt_type == 2:
        offset += 4
    
    message = data[offset:].decode('utf-8')
    
    return {
        'pubkey_prefix': pubkey_prefix,
        'path_len': path_len,
        'txt_type': txt_type,
        'timestamp': timestamp,
        'message': message,
        'snr': snr if packet_type == 0x10 else None
    }

Byte 0: 0x08 (Pakettyp)
Byte 1: Kanalindex (0-7)
Byte 2: Pfadlänge
Byte 3: Texttyp
Bytes 4-7: Zeitstempel (32-Bit Little-Endian)
Bytes 8+: Nachrichtentext (UTF-8)

Byte 0: 0x11 (Pakettyp)
Byte 1: SNR (vorzeichenbehaftetes Byte, multipliziert mit 4)
Bytes 2-3: Reserviert
Byte 4: Kanalindex (0-7)
Byte 5: Pfadlänge
Byte 6: Texttyp
Bytes 7-10: Zeitstempel (32-Bit Little-Endian)
Bytes 11+: Nachrichtentext (UTF-8)

def parse_channel_message(data):
    packet_type = data[0]
    offset = 1
    
    # Auf V3-Format prüfen
    if packet_type == 0x11:  # V3
        snr_byte = data[offset]
        snr = ((snr_byte if snr_byte < 128 else snr_byte - 256) / 4.0)
        offset += 3  # SNR + reserviert überspringen
    
    channel_idx = data[offset]
    path_len = data[offset + 1]
    txt_type = data[offset + 2]
    timestamp = int.from_bytes(data[offset+3:offset+7], 'little')
    message = data[offset+7:].decode('utf-8')
    
    return {
        'channel_idx': channel_idx,
        'timestamp': timestamp,
        'message': message,
        'snr': snr if packet_type == 0x11 else None
    }

Byte 0: 0x00
Bytes 1-4: Optionaler Wert (32-Bit Little-Endian Ganzzahl)

Byte 0: 0x01
Byte 1: Fehlercode (optional)

Byte 0: 0x12
Byte 1: Kanalindex
Bytes 2-33: Kanalname (32 Bytes, Null-terminiert)
Bytes 34-49: Geheimnis (16 Bytes)

Byte 0: 0x0D
Byte 1: Firmware-Version (uint8)
Bytes 2+: Variable Länge basierend auf der Firmware-Version

Für Firmware-Version >= 3:
Byte 2: Max. Kontakte Roh (uint8, tatsächlich = Wert * 2)
Byte 3: Max. Kanäle (uint8)
Bytes 4-7: BLE PIN (32-Bit Little-Endian)
Bytes 8-19: Firmware-Build (12 Bytes, UTF-8, Null-gefüllt)
Bytes 20-59: Modell (40 Bytes, UTF-8, Null-gefüllt)
Bytes 60-79: Version (20 Bytes, UTF-8, Null-gefüllt)
Byte 80: Client Repeat aktiviert/bevorzugt (Firmware v9+)
Byte 81: Pfad-Hash-Modus (Firmware v10+)

def parse_device_info(data):
    if len(data) < 2:
        return None
    
    fw_ver = data[1]
    info = {'fw_ver': fw_ver}
    
    if fw_ver >= 3 and len(data) >= 80:
        info['max_contacts'] = data[2] * 2
        info['max_channels'] = data[3]
        info['ble_pin'] = int.from_bytes(data[4:8], 'little')
        info['fw_build'] = data[8:20].decode('utf-8').rstrip('\x00').strip()
        info['model'] = data[20:60].decode('utf-8').rstrip('\x00').strip()
        info['ver'] = data[60:80].decode('utf-8').rstrip('\x00').strip()
    
    return info

Byte 0: 0x0C
Bytes 1-2: Batteriespannung (16-Bit Little-Endian, Millivolt)
Bytes 3-6: Genutzter Speicher (32-Bit Little-Endian, KB)
Bytes 7-10: Gesamtspeicher (32-Bit Little-Endian, KB)

def parse_battery(data):
    if len(data) < 3:
        return None
    
    mv = int.from_bytes(data[1:3], 'little')
    info = {'battery_mv': mv}
    
    if len(data) >= 11:
        info['used_kb'] = int.from_bytes(data[3:7], 'little')
        info['total_kb'] = int.from_bytes(data[7:11], 'little')
    
    return info

Byte 0: 0x05
Byte 1: Werbetyp
Byte 2: TX-Leistung
Byte 3: Max. TX-Leistung
Bytes 4-35: Öffentlicher Schlüssel (32 Bytes, hexadezimal)
Bytes 36-39: Werbelängengrad (32-Bit Little-Endian, geteilt durch 1e6)
Bytes 40-43: Werbebreitengrad (32-Bit Little-Endian, geteilt durch 1e6)
Byte 44: Multi-ACKs
Byte 45: Werbe-Positionsrichtlinie
Byte 46: Telemetrie-Modus (Bitfeld)
Byte 47: Manuelle Kontakte hinzufügen (boolean)
Bytes 48-51: Funkfrequenz (32-Bit Little-Endian, geteilt durch 1000.0)
Bytes 52-55: Funkbandbreite (32-Bit Little-Endian, geteilt durch 1000.0)
Byte 56: Funk-Spreizfaktor
Byte 57: Funk-Codiereffizienz
Bytes 58+: Gerätename (UTF-8, variable Länge, kein Null-Terminator erforderlich)

def parse_self_info(data):
    if len(data) < 36:
        return None
    
    offset = 1
    info = {
        'adv_type': data[offset],
        'tx_power': data[offset + 1],
        'max_tx_power': data[offset + 2],
        'public_key': data[offset + 3:offset + 35].hex()
    }
    offset += 35
    
    lat = int.from_bytes(data[offset:offset+4], 'little') / 1e6
    lon = int.from_bytes(data[offset+4:offset+8], 'little') / 1e6
    info['adv_lat'] = lat
    info['adv_lon'] = lon
    offset += 8
    
    info['multi_acks'] = data[offset]
    info['adv_loc_policy'] = data[offset + 1]
    telemetry_mode = data[offset + 2]
    info['telemetry_mode_env'] = (telemetry_mode >> 4) & 0b11
    info['telemetry_mode_loc'] = (telemetry_mode >> 2) & 0b11
    info['telemetry_mode_base'] = telemetry_mode & 0b11
    info['manual_add_contacts'] = data[offset + 3] > 0
    offset += 4
    
    freq = int.from_bytes(data[offset:offset+4], 'little') / 1000.0
    bw = int.from_bytes(data[offset+4:offset+8], 'little') / 1000.0
    info['radio_freq'] = freq
    info['radio_bw'] = bw
    info['radio_sf'] = data[offset + 8]
    info['radio_cr'] = data[offset + 9]
    offset += 10
    
    if offset < len(data):
        name_bytes = data[offset:]
        info['name'] = name_bytes.decode('utf-8').rstrip('\x00').strip()
    
    return info

Byte 0: 0x06
Byte 1: Route-Flag (0 = direkt, 1 = Flood)
Bytes 2-5: Tag / Erwartete ACK (4 Bytes, Little-Endian)
Bytes 6-9: Vorgeschlagenes Timeout (32-Bit Little-Endian, Millisekunden)

Byte 0: 0x82
Bytes 1-6: ACK-Code (6 Bytes, hexadezimal)

# 1. Nach MeshCore-Geräten suchen
device = scan_for_device("MeshCore")

# 2. Mit BLE GATT verbinden
gatt = connect_to_device(device)

# 3. Dienste und Merkmale entdecken
service = discover_service(gatt, "6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
rx_char = discover_characteristic(service, "6E400002-B5A3-F393-E0A9-E50E24DCCA9E")
tx_char = discover_characteristic(service, "6E400003-B5A3-F393-E0A9-E50E24DCCA9E")

# 4. Benachrichtigungen auf TX-Merkmal aktivieren
enable_notifications(tx_char, on_notification_received)

# 5. AppStart-Befehl senden
send_command(rx_char, build_app_start())
wait_for_response(PACKET_SELF_INFO)

# 1. 16-Byte-Geheimnis generieren
secret_16_bytes = generate_secret(16)  # CSPRNG verwenden (kryptografisch sicherer Zufallszahlengenerator)
secret_hex = secret_16_bytes.hex()

# 2. SET_CHANNEL-Befehl erstellen
channel_name = "YourChannelName"
channel_index = 1  # 1-7 für private Kanäle verwenden
command = build_set_channel(channel_index, channel_name, secret_16_bytes)

# 3. Befehl senden
send_command(rx_char, command)
response = wait_for_response(PACKET_OK)

# 4. Geheimnis lokal speichern
store_channel_secret(channel_index, secret_hex)

# 1. Kanalnachrichtenbefehl erstellen
channel_index = 1
message = "Hallo, MeshCore!"
timestamp = int(time.time())
command = build_channel_message(channel_index, message, timestamp)

# 2. Befehl senden
send_command(rx_char, command)
response = wait_for_response(PACKET_MSG_SENT)

def on_notification_received(data):
    packet_type = data[0]
    
    if packet_type == PACKET_CHANNEL_MSG_RECV or packet_type == PACKET_CHANNEL_MSG_RECV_V3:
        message = parse_channel_message(data)
        handle_channel_message(message)
    elif packet_type == PACKET_MESSAGES_WAITING:
        # Nachrichten abfragen
        send_command(rx_char, build_get_message())