Einstellungen beim LoRa-Modul RYLR998 (REYAX) auslesen

[Heinrichs]

In meinem Beitrag LORAWAN MIT ESP32 UND RYLR998 habe ich das LoRa-Modul RYLR998 der Firma REYAX sowie einige Grundlagen von LoRa ausführlich dargestellt. Hier möchte ich ein kleines Micropython-Programm (für den TTGO) vorstellen, mit dem man die aktuellen Einstellungen des LoRa-Moduls (im Thonny-Terminal) auflisten lassen kann.

Code: Alles auswählen

# Anzeige der Einstellungen des LoRa-Moduls

#####################################################################################
#                            Import und Instanziierungen                            #
#####################################################################################

from time import sleep
from machine import UART
uart1 = UART(1, baudrate = 57600, tx = 12, rx = 13)

from lora import send_command, read_response, response_to_list, lora_init, send_message

####################################################################################
#                 Anzeige aller Einstellungen des LORA-Modul                       #
####################################################################################

lora_address = lora_init(uart1) # Rückgabewert ist '???', wenn keinen Antwort vom LoRa-Modul 
if lora_address == '???':
    print('Keine Verbindung zum LORA-Modul!')
    print('RESET-Knopf am TTGO betätigen!')
    sys.exit() # Programm beenden, wenn keine Antwort vom LoRa-Modul
    
print('Einstellungen des angeschlossenen LoRa-Moduls')
print()


# Adresse
send_command(uart1, 'AT+ADDRESS?')
print('Adresse: ', read_response(uart1))
print()

# Netzwerk-ID
send_command(uart1, 'AT+NETWORKID?')
print('NETWORKID (Default: 18): ', read_response(uart1))
print()

# Netzwerk-ID
send_command(uart1, 'AT+BAND?')
print('Frequenz (868500000): ', read_response(uart1))
print()

# Parameter
send_command(uart1, 'AT+PARAMETER?')
print('Parameter (Default: 9,7,1,12): ', read_response(uart1))
print()

# Baudrate
send_command(uart1, 'AT+IPR?')
print('Baudrate (Default: 57600): ', read_response(uart1))
print()

# Sendeleistung
send_command(uart1, 'AT+CRFOP?')
print('Sendeleistung (Default; Max in EU: 14): ', read_response(uart1))
print()

# UID (Unique Identifyer)
send_command(uart1, 'AT+UID?')
print('UID: ', read_response(uart1))
print()

# Version (Versionsnummer)
send_command(uart1, 'AT+VER?')
print('Version: ', read_response(uart1))
print()

# Passwort (CPIN)
send_command(uart1, 'AT+CPIN?')
print('Passwort (CPIN): ', read_response(uart1))
print()

Das Programm benutzt das folgende Modul lora.py; dieses muss in den Flash-Speicher des TTGO geladen werden.

Code: Alles auswählen

# lora.py

# benötigt sleep-Funktion
from time import sleep

#################################################################################
#                 Funktionen zur Kommunikation mit dem LORA-Modul               #
#################################################################################

def send_command(uart, cmd):       # cmd ist vom Typ String 
    c = bytes(cmd, 'UTF-8') + b'\r\n'       # c ist vom Typ Byte-String (Bytes)
    # anzahl_der_gesendeten_bytes = uart.write(c)
    # print(anzahl_der_gesendeten_bytes, 'Bytes gesendet:', c)

def read_response(uart):
    # print('auf Nachricht warten...')
    while not uart.any(): # warten, bis (mindestens) ein Byte im Lesepuffer ist
        sleep(0.1)
    return uart.readline()

def response_to_list(r): # Liste von Zeichenketten
    r = str(r, 'UTF=8')
    r = r.split(',')
    r0 = r[0].split('=') # Adresse isolieren
    r[0] = r0[1]
    r4 = r[4].split('\r') # CR-LF abtrennen
    r[4] = r4[0]
    return r

def lora_init(uart):    
    # Prüfe nach, ob LoRa-Modul antwortet...
    lora_address = '???'
    send_command(uart, 'AT')
    r = read_response(uart)
    print(r)
    if r == b'+OK\r\n': # Wenn nicht r=OK, dann...
        # LoRa-Adresse ermitteln und anzeigen    
        send_command(uart, 'AT+ADDRESS?')
        lora_address = read_response(uart) # Rückgabewert ist vom Typ Bytes
        lora_address = str(lora_address, 'UTF=8') # umwandeln in Typ String
        lora_address = lora_address[9:]
        print('Eigene LORA-Adresse:', lora_address)
    
        send_command(uart, 'AT+CRFOP=14') # Sendeleistung begrenzen
        r = read_response(uart)
        print(r)        
        '''
        send_command(uart, 'AT+BAND=868500000') # Falls Frequenz nicht im Flash gespeichert
        print(read_response(uart))
        '''
        print()
    return lora_address 
 
def send_message(uart, addr, msg): # addr: Adresse; msg: Botschaft
    payload_length = len(msg)
    cmd = 'AT+SEND='+str(addr)+','+str(payload_length)+','+msg
    # print('send_message:', cmd)
    send_command(uart, cmd)

Die auskommenierten print-Kommandos protokollieren einzelne Phasen des Datenzugriffs.