'===============================================================================
' RFM69 Sende/Empfänger für den UART to ETH
'===============================================================================
'Ursprung ist die Transceiver-Version
'-------------------------------------------------------------------------------
'name : SS_to_ETH_mit RFM69_V0.4.bas
'copyright : (c) jep
'Datum : 29.12.2023
'micro : ATMega 328PB-PU
'-------------------------------------------------------------------------------
'
'Change log:
'V0.1: Initialversion; Erkennung Sequenz-Ende ging so nicht (siehe unten)
'V0.2: siehe unten
'V0.3: Empfang und Senden mit CRC überprüfen bevor weitergeleitet wird
'V0.4; zusätzlicher Reset des UART to ETH nach dem Start des Programs
'*******************************************************************************
'V0.1
'Problem ist auf der seriellen Empfangs-Schnittstelle. Da die Übertragung binär
'erfolgt kann kein Ende oder Start-Zeichen verwendet werden.
'Zur Erkennung des Anfangs einer seriellen Sequenz muss deshalb die Pause
'zwischen den Sequenzen ausgewertet werden. Die Übertragung erfolgt mit
'115200 Baud; d.h. pro Byte ~70us.
'Annahme: wenn 150us kein Zeichen eintrifft beginnt mit dem nächsten Byte eine
'neue Sequenz wobei dieses erste Byte die folgende Anzahl Bytes enthält. Damit
'kann doppelt geprüft werden.
'V0.2:
'Die Daten ab ETH kommen direkt hintereinander; danach erfolgt eine "Pause".
'Folgt innerhalb 1 ms kein weiteres Byte so wird der Bytezähler wieder auf 0
'gestellt.
'Somit wird der Bytecounter zuerst auf 0 gestellt; das erste Datum ist dann die
'Länge der folgenden Daten. Ist diese Länge erreicht so werden die Daten
'umkopiert, Daten_ab_ETH auf 1 gesetzt und der Bytecounter wieder auf 0.
'*******************************************************************************
$regfile = "m328pbdef.dat"
$crystal = 16000000
$hwstack = 80
$swstack = 64
$framesize = 128
$baud = 38400
Declare Sub Rfm69_senden()
Declare Sub Rfm69_init()
Declare Sub Write_reg(byval Addr As Byte , Byval Value As Byte)
Declare Sub Avoid_deadlock()
Declare Sub Set_mode(byval new_mode as Byte)
Declare Sub Receive_begin()
Declare Function Read_reg(byval Addr as Byte) as Byte
Declare Function Read_rssi(byval Force_trigger As Byte)as Integer
Config Base = 0 'nötig da HW-mässig
' 'ab Bit 0 gearbeitet wird
$include "Rfm69_registers.inc"
'========================== Portkonfiguration ==================================
'============================> PORT B
Config Portb.0 = Output 'LED grün
Portb.0 = 1 'aus
Ledg Alias Portb.0 '
Config Portb.1 = Output 'LED rot
Portb.1 = 1 'aus
Ledr Alias Portb.1
Config Portb.2 = Output 'CS für RFM
Portb.2 = 1
CS_RFM Alias Portb.2 : CS_RFM = 1
Config Portb.3 = Output 'MOSI out / RFM_SDI in
Portb.3 = 0
MOSI Alias Portb.3
Config PINb.4 = Input 'MISO
Portb.4 = 1 'Pullup
MISO alias Pinb.4
Config Portb.5 = Output 'SCK Clock
Portb.5 = 1
SCK Alias Portb.5 : SCK = 0
'Portb.6 = 1 'Oszi
'Portb.7 = 0 'Oszi
'===========================> PORT C
Config Pinc.0 = Input 'Senden Tx
Portc.0 = 1 'Pullup
Tx_out alias Pinc.0 'Tx_out: 0=ON; 1=OFF
Config Pinc.1 = Input 'Transfer zu ETH
Portc.1 = 1 'Pullup
Trans_out alias Pinc.1 'Transfer: 0=ON; 1=OFF
Config Pinc.2 = Input 'Debuggen ETH --> Tx
Portc.2 = 1 'Pullup
Debuggen_ETx alias Pinc.2 'Debuggen_
Config Pinc.3 = Input 'Debuggen Rx --> ETH
Portc.3 = 1 'Pullup
Debuggen_RxE alias Pinc.3 'Debuggen: 0=ON; 1=OFF
Config Portc.4 = Output 'TWI SDA
Portc.4 = 1
Config Portc.5 = Output 'TWI SDL
Portc.5 = 1
Config PINc.6 = Input 'Reset des Controllers
Portc.6 = 1
Config Pinc.7 = Input 'nicht verwendet
Portc.7 = 1
'===========================> PORT D
'PIND.0 = RX0 'Daten in
'PORTD.1 = TX0 'Daten out
'PIND.2 = INT0 'Interrupt 0
'PIND.3 = INT1 'Interrupt 1
Config Portd.4 = Output 'CFG0 Konfiguration UART to ETH
Portd.4 = 1
Config PINd.5 = Input 'CS des LCD (wenn verwendet)
Portd.5 = 1
Config PINd.6 = Input 'A0 des LCD (wenn verwendet)
Portd.6 = 1
Config Portd.7 = Output 'RST1 des UART to ETH
Portd.7 = 1
Rst1 alias Portd.7
'*************************************************************
'* SPI CONFIGURATION *
'*************************************************************
'RFM69 SPI up to 10MHz. For PCB traces clockrate can be 4 but for "long" wires better use 16
Config Spi = Hard , Interrupt = Off , Data_order = Msb , Master = Yes , Polarity = Low , Phase = 0 , Clockrate = 16 , Noss = 1
'SPSR.0 = 1 'Double Speed
Spiinit
'*************************************************************
'* 16 MHz Oszi Timerinterupt für 1 msec einstellen *
'*************************************************************
Config Timer0 = Timer , Prescale = 64 'https://www.rmc-sachsen.de/?nav=bascom-timer-berechnung
Const Timer0_Preload = 6 'gilt für 16 MHz
On Timer0 Seriell_End 'beim Interrupt zur seriell_End springen
Disable Timer0
'============== Hier werden die zu sendenten Bytes abgelegt ====================
' 0 1 2 3 4 5 6 17 18 19 20
'+----+----+----+----+----+----+----+----+----+----+----+----+
'Dummy| Sendebytes |
'+----+----+----+----+----+----+----+----+----+----+----+----+
' |LENs|DABs|SABs|CDBs| Ds1| Ds2| ...| Dsx| Dsy|CRC2|CRC1|
' +----+----+----+----+----+----+----+----+----+----+----+
'
Const max_Sendebytes = 32 + 7 + 1 '32 Nutzdaten, 7 Overhead, 1 Reserve
Dim Sendebytes(max_Sendebytes) As Byte 'max. Anzahl Ausgangsbytes (mit CRC und 0-Byte)
Dim Anzahlbyte_s As Byte 'Anzahl zu sendende Bytes
'Dim Dummy As Byte at Sendebytes(0) Overlay 'Dummy wegen 0-basiertem Array; wird nie benutzt
Dim Lens As Byte At Sendebytes(1) Overlay 'Längenbyte ohne LEN inkl. CRC
Dim Dabs As Byte At Sendebytes(2) Overlay 'Adresse an den die Daten geschickt werden (DAB)
Dim Sabs As Byte At Sendebytes(3) Overlay 'eigene Adresse (SAB)
Dim Cdbs As Byte At Sendebytes(4) Overlay : Cdbs = &B01100000 'Kommandobyte; Datenmode, fordert ACK
Dim CRC_16s as Word '
'
'=== Hier werden die funkseitig zu EMPFANGENDEN BYTES (max TOTAL 66 möglich) abgelegt ===
' 0 1 2 3 4 5 6 7 8 9 10 max 66
' +----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
' Dummy| IRQ_Empfangsbytes / Empfangsbytes |
'+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
'| AA | AA | 2D | D4 |LENe|DABe|SABe|CDBe| De1| De2| De1| De4| De5| .. | Dex| Dey|CRC2|CRC1|
'+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
' | | |
' | |<------------ LEN = Anzahl Daten und CRC OHNE LEN ------------>|
' |<--------------- Totale Anzahl zu empfangende Bytes ---------------->|
Const Maxanzahlempfangsbytes = 32 + 7 + 1 'zu empfangende Datenmenge (maximal total 66 Byte)
Dim Empfangsbytes(maxanzahlempfangsbytes + 3) As Byte 'Empfangspuffer nach Empfang
'Dim Dummy As Byte at Empfangsbytes(0) Overlay 'Dummy wegen 0-basiertem Array; wird nie benutzt
Dim Lene As Byte At Empfangsbytes(1) Overlay 'Längenbyte
Dim Dabe As Byte At Empfangsbytes(2) Overlay
Dim Sabe As Byte At Empfangsbytes(3) Overlay
Dim Cdbe As Byte At Empfangsbytes(4) Overlay
Dim CRC_16e as Word
Dim CRC_16ger as Word
Dim Anzahlbyte_e as Byte
Dim Funkdaten_vorhanden As Bit
Dim PNe as Byte 'Paketnummer bei Empfang
Dim Empfangscount as Byte 'nur für Fehlersuche
Dim Reg_h01w as Byte : Reg_h01w = &h81 'Register1 schreiben
Dim Reg_h01r as Byte : Reg_h01r = &h01 'Register1 lesen
Dim FifoW as Byte : FifoW = &h80 'FIFO schreiben
Dim FifoR as Byte : FifoR = &h00 'FIFO lesen
Const Rfm69_mode_sleep = 0 'Xtal Off
Const Rfm69_mode_standby = 1 'Xtal On
Const Rfm69_mode_synth = 2 'Pll On
Const Rfm69_mode_rx = 3 'Rx Mode
Const Rfm69_mode_tx = 4 'Tx Mode
Const Time_out = 50
Const Csma_limit = -90 'Upper Rx Signal Sensitivity Threshold In Dbm For Carrier Sense Access
Const Csma_limit_ms = 500 'max. Wartezeit bevor Senden
'================== Interrupt für den Empfang aktivieren =======================
Config PinD.2 = Input 'Int0 = RFM69 Interrupt
'PortD.2 = 1 'Pullup, für RFM69 nicht nötig
_interrupt_pin Alias Pind.2 'Test für Senden ferig
Config Int0 = Rising 'RFM12 = Falling; RFM69 = Rising
On Int0 Rfm_funkirq nosave
Enable Int0
Disable Interrupts 'alle Interrupts sperren
'*************************************************************
'* Serielle Schnittstellendefinition *
'*************************************************************
Config Com1 = Dummy , Synchrone = 0 , Parity = None , Stopbits = 1 , Databits = 8 , Clockpol = 0
Open "COM1:" For Binary As #1
Enable Urxc
On Urxc Daten_empfang 'bei Interrupt
Dim ETH_Empfangsdaten(Maxanzahlempfangsbytes) as Byte 'UART-Empfangspuffer
Dim Bytecounter as Byte : Bytecounter = 0 'zählt die vom UART empf. Zeichen
Dim Daten_ab_ETH as Byte
Open "COMC.4:38400,8,N,1" For Output As #2 'SW-UART für Testausgaben
'_______________________________________________________________________________
Dim Debuggen as Byte : Debuggen = 0 'Debuggen ist aus
Dim N As Byte
Dim X As Byte
Dim I as Integer
Dim Z as Byte : Z = 0
Dim Reg as Byte
Dim Timeout as Word
Dim _powerlevel As Byte : _powerlevel = 31
Dim _spymode As Byte : _spymode = 1 'alles empfangen, keine Adressauswertung
Dim Rssi As Integer 'Most Accurate Rssi During Reception(closest To The Reception)
Dim _mode As Byte
Dim Helpb As Byte
Dim Helpi As Integer
Dim Helpint as Byte 'nur im Interrupt verwendet
Dim Millis As Word
' ***************
' **********************************
' ********************************************************
'*******************************************************************************
'***************************** PROGRAMMSTART ***********************************
'*******************************************************************************
Config Watchdog = 8192 '8 sec. Timeout
Start Watchdog 'und Start
Print #2 ,
Print #2 , "==================================================="
Print #2 ,
Print #2 , "File: " ; Version(3);
Print #2 ,
'Print #2 , "#2 Start Server"
'Print #1 , "#1 Start Server"
Print #2 , "#2 Start Client"
Print #1 , "#1 Start Client"
Print #2 ,
Print #2 ,
Wait 2
Reset RST1 'UART to ETH zurücksetzen
waitms 100
Set RST1
Reset Watchdog
call Rfm69_init()
Call Receive_begin() 'Rx aktivieren
Eifr.intf0 = 1 'Eventuell anstehenden Interrupt löschen
Enable Interrupts
'##############################################################################
'############################## Hauptprogramm ##################################
Do
'Ethernet --> Funk Senden
If Daten_ab_ETH = 1 then
Daten_ab_ETH = 0 'Merker zurückstellen
If Debuggen_ETx = 0 then
Print #2 ,
Print #2 , "ETH --> TxD: " ;
For helpb = 1 to Sendebytes(1) + 1 'Bytecounter
Print #2 , Hex(Sendebytes(helpb)) ; " ";
next helpb
End if
If Sendebytes(1) = 3 then 'Spezialfall Quittung
If Debuggen_ETx = 0 then Print #2 , " --> Quittung"
Call RFM69_senden() 'Senden
Call Receive_begin() 'und weiter mit Empfang
Bytecounter = 0
goto EtoF_End
End if
If Sendebytes(1) >= 4 and Sendebytes(1) <= Max_sendebytes then 'and DABe = Steuerzentralenadresse then
Anzahlbyte_s = Sendebytes(1) + 1 'total Anzahl = LEN + 1
Crc_16s = Makeint(Sendebytes(anzahlbyte_s) , Sendebytes(anzahlbyte_s - 1))
helpb = Sendebytes(1) - 1 'Datenlänge über alles ohne CRC16
Crc_16ger = Crc16(Sendebytes(1) , helpb ) 'CRC16 gerechnet
If Crc_16ger = Crc_16s Then 'CRC i.O.
Bytecounter = 0
If Tx_out = 0 then 'Sender freigegeben
If Debuggen_ETx = 0 then Print #2 , " --> Daten zu Funk"
Call Rfm69_senden() 'somit Daten senden
Call Receive_begin() 'und weiter mit Empfang
else
If Debuggen_ETx = 0 then Print #2 , " --> Daten zu Funk deaktiviert"
End if
Else
If Debuggen_ETx = 0 then Print #2 , " --> CRC-Fehler ETH"
End if
Else
If Debuggen_ETx = 0 then Print #2 , " --> Sendedaten ausserhalb Bereich"
End if
EtoF_End:
Reset Watchdog
End if
'Funkempfang --> Ethernet
If Funkdaten_vorhanden = 1 Then
Funkdaten_vorhanden = 0 'Merker zurücksetzen
I = Empfangsbytes(1) + 1
If Debuggen_RxE = 0 then
Print #2 ,
Print #2 , "RxD --> ETH: ";
For helpb = 1 to I
Print #2 , Hex(Empfangsbytes(helpb)) ; " ";
next helpb
End if
If Empfangsbytes(1) = 3 then 'Spezialfall Quittung
If Debuggen_RxE = 0 then Print #2 , " --> Quittung"
Printbin #1 , Empfangsbytes(1) , I 'zum ETH_in weiterleiten
goto FtoE_End
End if
If Empfangsbytes(1) >= 4 and Empfangsbytes(1) <= Maxanzahlempfangsbytes then 'ohne Quittung
Anzahlbyte_e = Empfangsbytes(1) + 1 'total Anzahl = LEN + 1
Crc_16e = Makeint(empfangsbytes(anzahlbyte_e) , Empfangsbytes(anzahlbyte_e - 1))
helpb = Empfangsbytes(1) - 1 'Datenlänge über alles ohne CRC16
Crc_16ger = Crc16(empfangsbytes(1) , helpb ) 'CRC16 gerechnet
If Crc_16ger = Crc_16e Then 'CRC i.O.
If Trans_out = 0 then
If Debuggen_RxE = 0 then Print #2 , " --> Daten zu ETH"
Printbin #1 , Empfangsbytes(1) , I 'zum ETH_in weiterleiten
else
If Debuggen_RxE = 0 then Print #2 , " --> Daten zu ETH deaktiviert"
End if
Else
If Debuggen_RxE = 0 then Print #2 , " --> CRC-Fehler Empfang"
End if
Else
If Debuggen_RxE = 0 then Print #2 , " --> Empfangsdaten ausserhalb Bereich"
End if
FtoE_End:
End if
Reset Watchdog
Loop
'###############################################################################
'********************************* Interrupts *******************************
'Serieller Empfang ab Ethernet
Daten_empfang: 'es ist etwas da
Timer0 = Timer0_Preload '1ms-Timer zurückstellen
Start Timer0 'und starten
incr Bytecounter 'Bytezähler erhöhen
ETH_Empfangsdaten(Bytecounter) = Inkey(#1) 'Data holen
If Bytecounter > Maxanzahlempfangsbytes then Bytecounter = 0 'verhindert Überlauf
x = ETH_Empfangsdaten(1) + 1
If Bytecounter = x then ' 20 then
helpb = Memcopy(ETH_Empfangsdaten(1) , Sendebytes(1) , x) 'zum Funk-Sendpuffer umkopieren
Daten_ab_ETH = 1
Bytecounter = 0
Disable Timer0 'Timer ausschalten
End if
Return
'***************************** Timer0-Interrupt *****************************
Seriell_End:
Stop Timer0 'Timer stoppen
Bytecounter = 0 'Bytezähler zurückstellen
If Debuggen_ETx = 0 then
Print #2 , "ETH Timeout"
Print #2,
End if
Return
'************************ Sendet das Datenpaket ********************************
' Die Senderoutine ist für Polling des Senders geschrieben
Sub Rfm69_senden()
Disable Int0
Call avoid_deadlock()
Timeout = 0
Do 'Funkfrequenz frei?
If _mode = Rfm69_mode_rx Then
If Read_rssi(0) < Csma_limit Then Exit Do 'Pegel unter Minimum --> ok, Abbruch
Incr Timeout : If Timeout >= Csma_limit_ms Then Exit Do 'wenn über, max. Zeit abgelaufen?
waitms 1
Else
Incr Timeout : If Timeout >= Csma_limit_ms Then Exit Do 'max. Zeit abgelaufen?
waitms 1
End If
Loop
Call Set_mode(rfm69_mode_standby) 'vermeidet gleichzeitiger Empfang
Do
Reg = Read_reg(reg_irqflags1) And Irqflags1_modeready 'wartet bis RFM69 bereit ist
Loop Until Reg = Irqflags1_modeready
Call Write_reg(reg_diomapping1 , Diomapping1_dio0_00) 'DIO0 ist "Packet Sent"
LEDr = 0 'LED ein
Anzahlbyte_s = LENs + 1 'zu sendende Bytes korrigieren
CS_RFM = 0 'RFM69 Select ein
SPIOUT FifoW , 1 'Register h00 zum schreiben adressieren (h80)
SPIOUT Sendebytes(1) , Anzahlbyte_s 'Komplette Sendedaten ins Fifo schreiben, Anzahl Bytes
CS_RFM = 1 'RFM69 Select aus
Call Set_mode(rfm69_mode_tx) 'Sender ein
If Debuggen = 1 then
helpb = Lens + 1
For N = 1 To helpb
Print #1 , Hex(sendebytes(n)) ; " ";
Next N
Print #1,
End if
Millis = 0
Do
If _interrupt_pin = 1 Then Exit Do 'warten auf DIO0 = 1 => Daten gesendet
If Millis >= 50 Then Exit Do 'max. Sendedauer 50ms
Incr Millis
Waitms 1
Loop
LEDr = 1 'LED aus
Call Set_mode(rfm69_mode_standby)
Enable Int0
End Sub
'===============================================================================
Function Read_reg(byval Addr As Byte)as Byte
Reset CS_RFM
Addr = Addr And &H7F
Spiout Addr , 1
Spiin Read_reg , 1
Set CS_RFM
Enable Int0
End Function
'===============================================================================
Sub Write_reg(byval Addr As Byte , Byval Value As Byte)
Reset CS_RFM
Addr = Addr Or &H80
Spiout Addr , 1
Spiout Value , 1
Set CS_RFM
Enable Int0
End Sub
'===============================================================================
Sub Set_mode(byval New_mode As Byte)
If New_mode <> _mode Then
Helpb = Read_reg(reg_opmode) And &HE3
Select Case New_mode
Case Rfm69_mode_tx : Helpb = Helpb Or Opmode_transmitter
Case Rfm69_mode_rx : Helpb = Helpb Or Opmode_receiver
Case Rfm69_mode_synth : Helpb = Helpb Or Opmode_synthesizer
Case Rfm69_mode_standby : Helpb = Helpb Or Opmode_standby
Case Rfm69_mode_sleep : Helpb = Helpb Or Opmode_sleep
Case Else : Goto Exit_Set_mode 'skip wait for change
End Select
Call Write_reg(reg_opmode , Helpb)
If _mode = Rfm69_mode_sleep Then 'waiting for mode ready is necessary...
Timeout = 0 'when going from sleep because the FIFO may...
Do 'not be immediately available from previous mode
Helpb = Read_reg(reg_irqflags1) And Irqflags1_modeready 'Wait For Modeready
Incr Timeout : If Timeout >= Time_out Then Exit Do
Waitms 1
Loop Until Helpb = Irqflags1_modeready
End If
_mode = New_mode
End If
Exit_Set_mode:
End Sub
'===============================================================================
Function Read_rssi(byval Force_trigger As Byte)as Integer 'Local Rssi_ As Integer
If Force_trigger = 1 Then 'Start neue Messung
Call Write_reg(reg_rssiconfig , Rssi_start)
Do
Helpb = Read_reg(reg_rssiconfig) And Rssi_done
Loop Until Helpb = 0 'wait for RSSI_Ready
End If
Helpb = Read_reg(reg_rssivalue) 'Wert holen
Shift Helpb , Right , 1 '/2
Helpi = -helpb
Read_rssi = Helpi
End Function
'===============================================================================
Sub Avoid_deadlock()
Reg = Read_reg(reg_packetconfig2) And &HFB 'Restart-Bit freistellen
Reg = Reg Or Packet2_rxrestart 'und setzen
Call Write_reg(reg_packetconfig2 , Reg) 'und zurückschreiben
End Sub
'===============================================================================
Sub Receive_begin() 'internal function
Rssi = 0
Helpb = Read_reg(reg_irqflags2) And Irqflags2_payloadready 'ist Payload Ready?
If Helpb > 0 Then 'ja, also
Call Avoid_deadlock() 'Restart-Bit setzen
End If
Call Write_reg(reg_diomapping1 , Diomapping1_dio0_01) 'setzen auf Payload Ready
Call Set_mode(rfm69_mode_rx) 'Rx ein
End Sub
'===============================================================================
Sub Rfm69_init()
Local Wert As Byte : Local E As Byte
E = 0
CS_RFM = 0
SPIOUT Reg_h01w , 1 'Schreiben ab Register 01
Restore Data_RFM69_init 'Initialisierungsfolge
Do
Read Wert
SPIOUT Wert , 1 'Register schreiben
Incr E
Loop Until E = &h72
CS_RFM = 1
Waitms 10
End Sub
'================ Empfangs-Interrupt vom Funkmodul RFM69xy ===================
RFM_Funkirq:
Disable INT0
$asm
!PUSH R3
!PUSH R4
!PUSH R10
!PUSH R15
!PUSH R16
!PUSH R17
!PUSH R18
!PUSH R19
!PUSH R20
!PUSH R21
!PUSH R22
!PUSH R24
!PUSH R25
!PUSH R26
!PUSH R27
!PUSH R28
!PUSH R29
!in R24, sreg
!PUSH R24
$end Asm
' internal function - interrupt gets called when a packet is received
Ledg = 0
If _mode = Rfm69_mode_rx Then
Helpint = Read_reg(reg_irqflags2) And Irqflags2_payloadready
If Helpint > 0 Then
Call Set_mode(rfm69_mode_standby)
CS_RFM = 0
SPIOUT FifoR , 1 'lesend auf Fifo zugreifen
SPIIN Empfangsbytes(1) , 1 'erstes Byte einlesen = Länge
If Empfangsbytes(1) >= 3 and Empfangsbytes(1) <= Maxanzahlempfangsbytes then
SPIIN Empfangsbytes(2) , Empfangsbytes(1) 'Rest holen
Funkdaten_vorhanden = 1
incr Empfangscount 'für Fehelersuche
else
Call Receive_begin()
Goto Exit2
End if
CS_RFM = 1
Call Set_mode(rfm69_mode_rx)
End If
End If
Rssi = Read_rssi(0)
Exit2:
LEDg = 1
$asm
!POP R24
!out sreg, r24
!POP R29
!POP R28
!POP R27
!POP R26
!POP R25
!POP R24
!POP R22
!POP R21
!POP R20
!POP R19
!POP R18
!POP R17
!POP R16
!POP R15
!POP R10
!POP R4
!POP R3
$end Asm
Enable INT0
Return
'*******************************************************************************
'(
'_______________________________________________________________________________
RFM_Lesen: 'Registerdump
Reg_h01r = &h01 'Lesebefehl
CS_RFM = 0
SPIOUT Reg_h01r , 1
SPIIN Reg_h01 , 1
SPIIN Reg_h02 , 1
SPIIN Reg_h03 , 1
SPIIN Reg_h04 , 1
SPIIN Reg_h05 , 1
SPIIN Reg_h06 , 1
SPIIN Reg_h07 , 1
SPIIN Reg_h08 , 1
SPIIN Reg_h09 , 1
SPIIN Reg_h0A , 1
SPIIN Reg_h0B , 1
SPIIN Reg_h0C , 1
SPIIN Reg_h0D , 1
SPIIN Reg_h0E , 1
SPIIN Reg_h0F , 1
SPIIN Reg_h10 , 1
SPIIN Reg_h11 , 1
SPIIN Reg_h12 , 1
SPIIN Reg_h13 , 1
SPIIN Reg_h14 , 1
SPIIN Reg_h15 , 1
SPIIN Reg_h16 , 1
SPIIN Reg_h17 , 1
SPIIN Reg_h18 , 1
SPIIN Reg_h19 , 1
SPIIN Reg_h1A , 1
SPIIN Reg_h1B , 1
SPIIN Reg_h1C , 1
SPIIN Reg_h1D , 1
SPIIN Reg_h1E , 1
SPIIN Reg_h1F , 1
SPIIN Reg_h20 , 1
SPIIN Reg_h21 , 1
SPIIN Reg_h22 , 1
SPIIN Reg_h23 , 1
SPIIN Reg_h24 , 1
SPIIN Reg_h25 , 1
SPIIN Reg_h26 , 1
SPIIN Reg_h27 , 1
SPIIN Reg_h28 , 1
SPIIN Reg_h29 , 1
SPIIN Reg_h2A , 1
SPIIN Reg_h2B , 1
SPIIN Reg_h2C , 1
SPIIN Reg_h2D , 1
SPIIN Reg_h2E , 1
SPIIN Reg_h2F , 1
SPIIN Reg_h30 , 1
SPIIN Reg_h31 , 1
SPIIN Reg_h32 , 1
SPIIN Reg_h33 , 1
SPIIN Reg_h34 , 1
SPIIN Reg_h35 , 1
SPIIN Reg_h36 , 1
SPIIN Reg_h37 , 1
SPIIN Reg_h38 , 1
SPIIN Reg_h39 , 1
SPIIN Reg_h3A , 1
SPIIN Reg_h3B , 1
SPIIN Reg_h3C , 1
SPIIN Reg_h3D , 1
SPIIN Reg_h3E , 1
SPIIN Reg_h3F , 1
SPIIN Reg_h40 , 1
SPIIN Reg_h41 , 1
SPIIN Reg_h42 , 1
SPIIN Reg_h43 , 1
SPIIN Reg_h44 , 1
SPIIN Reg_h45 , 1
SPIIN Reg_h46 , 1
SPIIN Reg_h47 , 1
SPIIN Reg_h48 , 1
SPIIN Reg_h49 , 1
SPIIN Reg_h4A , 1
SPIIN Reg_h4B , 1
SPIIN Reg_h4C , 1
SPIIN Reg_h4D , 1
SPIIN Reg_h4E , 1
SPIIN Reg_h4F , 1
SPIIN Reg_h50 , 1
SPIIN Reg_h51 , 1
SPIIN Reg_h52 , 1
SPIIN Reg_h53 , 1
SPIIN Reg_h54 , 1
SPIIN Reg_h55 , 1
SPIIN Reg_h56 , 1
SPIIN Reg_h57 , 1
SPIIN Reg_h58 , 1
SPIIN Reg_h59 , 1
SPIIN Reg_h5A , 1
SPIIN Reg_h5B , 1
SPIIN Reg_h5C , 1
SPIIN Reg_h5D , 1
SPIIN Reg_h5E , 1
SPIIN Reg_h5F , 1
SPIIN Reg_h60 , 1
SPIIN Reg_h61 , 1
SPIIN Reg_h62 , 1
SPIIN Reg_h63 , 1
SPIIN Reg_h64 , 1
SPIIN Reg_h65 , 1
SPIIN Reg_h66 , 1
SPIIN Reg_h67 , 1
SPIIN Reg_h68 , 1
SPIIN Reg_h69 , 1
SPIIN Reg_h6A , 1
SPIIN Reg_h6B , 1
SPIIN Reg_h6C , 1
SPIIN Reg_h6D , 1
SPIIN Reg_h6E , 1
SPIIN Reg_h6F , 1
SPIIN Reg_h70 , 1
SPIIN Reg_h71 , 1
CS_RFM = 1
Return
Reg_Out:
Print #1 , "Registerausgabe des RFM69CW / RFM69W / RFM69HW:"
Print #1 , "Register h01 enthaelt &h" ; Hex(Reg_h01) ; " bzw. &b" ; Bin(Reg_h01) ; " RegOpMode RW"
Print #1 , "Register h02 enthaelt &h" ; Hex(Reg_h02) ; " bzw. &b" ; Bin(Reg_h02) ; " RegDataMdul RW"
Print #1 , "Register h03 enthaelt &h" ; Hex(Reg_h03) ; " bzw. &b" ; Bin(Reg_h03) ; " RegBitrateMSB RW"
Print #1 , "Register h04 enthaelt &h" ; Hex(Reg_h04) ; " bzw. &b" ; Bin(Reg_h04) ; " RegBitrateLSB RW"
Print #1 , "Register h05 enthaelt &h" ; Hex(Reg_h05) ; " bzw. &b" ; Bin(Reg_h05) ; " RegFdevMSB RW"
Print #1 , "Register h06 enthaelt &h" ; Hex(Reg_h06) ; " bzw. &b" ; Bin(Reg_h06) ; " RegFdevLSB RW"
Print #1 , "Register h07 enthaelt &h" ; Hex(Reg_h07) ; " bzw. &b" ; Bin(Reg_h07) ; " RegFrfMSB RW"
Print #1 , "Register h08 enthaelt &h" ; Hex(Reg_h08) ; " bzw. &b" ; Bin(Reg_h08) ; " RegFrfCSB RW"
Print #1 , "Register h09 enthaelt &h" ; Hex(Reg_h09) ; " bzw. &b" ; Bin(Reg_h09) ; " RegFrfLSB RW"
Print #1 , "Register h0A enthaelt &h" ; Hex(Reg_h0A) ; " bzw. &b" ; Bin(Reg_h0A) ; " RegOsc1 RW"
Print #1 , "Register h0B enthaelt &h" ; Hex(Reg_h0B) ; " bzw. &b" ; Bin(Reg_h0B) ; " RegAfcCtrl RW"
Print #1 , "Register h0C enthaelt &h" ; Hex(Reg_h0C) ; " bzw. &b" ; Bin(Reg_h0C) ; " Reserved 0C R "
Print #1 , "Register h0D enthaelt &h" ; Hex(Reg_h0D) ; " bzw. &b" ; Bin(Reg_h0D) ; " RegListen1 RW"
Print #1 , "Register h0E enthaelt &h" ; Hex(Reg_h0E) ; " bzw. &b" ; Bin(Reg_h0E) ; " RegListen2 RW"
Print #1 , "Register h0F enthaelt &h" ; Hex(Reg_h0F) ; " bzw. &b" ; Bin(Reg_h0F) ; " RegListen3 RW"
Print #1 ,
Print #1 , "Register h10 enthaelt &h" ; Hex(Reg_h10) ; " bzw. &b" ; Bin(Reg_h10) ; " RegVersion R "
Print #1 , "Register h11 enthaelt &h" ; Hex(Reg_h11) ; " bzw. &b" ; Bin(Reg_h11) ; " RegPaLevel RW"
Print #1 , "Register h12 enthaelt &h" ; Hex(Reg_h12) ; " bzw. &b" ; Bin(Reg_h12) ; " RegPaRamp RW"
Print #1 , "Register h13 enthaelt &h" ; Hex(Reg_h13) ; " bzw. &b" ; Bin(Reg_h13) ; " RegOcp RW"
Print #1 , "Register h14 enthaelt &h" ; Hex(Reg_h14) ; " bzw. &b" ; Bin(Reg_h14) ; " Reserved 14 R "
Print #1 , "Register h15 enthaelt &h" ; Hex(Reg_h15) ; " bzw. &b" ; Bin(Reg_h15) ; " Reserved 15 R "
Print #1 , "Register h16 enthaelt &h" ; Hex(Reg_h16) ; " bzw. &b" ; Bin(Reg_h16) ; " Reserved 16 R "
Print #1 , "Register h17 enthaelt &h" ; Hex(Reg_h17) ; " bzw. &b" ; Bin(Reg_h17) ; " Reserved 17 R "
Print #1 , "Register h18 enthaelt &h" ; Hex(Reg_h18) ; " bzw. &b" ; Bin(Reg_h18) ; " RegLna RW"
Print #1 , "Register h19 enthaelt &h" ; Hex(Reg_h19) ; " bzw. &b" ; Bin(Reg_h19) ; " RegRxBw RW"
Print #1 , "Register h1A enthaelt &h" ; Hex(Reg_h1A) ; " bzw. &b" ; Bin(Reg_h1A) ; " RegAfcBw RW"
Print #1 , "Register h1B enthaelt &h" ; Hex(Reg_h1B) ; " bzw. &b" ; Bin(Reg_h1B) ; " RegOokPeak RW"
Print #1 , "Register h1C enthaelt &h" ; Hex(Reg_h1C) ; " bzw. &b" ; Bin(Reg_h1C) ; " RegOokAvg RW"
Print #1 , "Register h1D enthaelt &h" ; Hex(Reg_h1D) ; " bzw. &b" ; Bin(Reg_h1D) ; " RegOokFix RW"
Print #1 , "Register h1E enthaelt &h" ; Hex(Reg_h1E) ; " bzw. &b" ; Bin(Reg_h1E) ; " RegAfcFei RW"
Print #1 , "Register h1F enthaelt &h" ; Hex(Reg_h1F) ; " bzw. &b" ; Bin(Reg_h1F) ; " RegAfcMSB R "
Print #1 ,
Print #1 , "Register h20 enthaelt &h" ; Hex(Reg_h20) ; " bzw. &b" ; Bin(Reg_h20) ; " RegAfcLSB R "
Print #1 , "Register h21 enthaelt &h" ; Hex(Reg_h21) ; " bzw. &b" ; Bin(Reg_h21) ; " RegFeiMSB R "
Print #1 , "Register h22 enthaelt &h" ; Hex(Reg_h22) ; " bzw. &b" ; Bin(Reg_h22) ; " RegFeiLSB R "
Print #1 , "Register h23 enthaelt &h" ; Hex(Reg_h23) ; " bzw. &b" ; Bin(Reg_h23) ; " RegRssiConfig RW"
Print #1 , "Register h24 enthaelt &h" ; Hex(Reg_h24) ; " bzw. &b" ; Bin(Reg_h24) ; " RegRssiValue R "
Print #1 , "Register h25 enthaelt &h" ; Hex(Reg_h25) ; " bzw. &b" ; Bin(Reg_h25) ; " RegDioMapping1 RW"
Print #1 , "Register h26 enthaelt &h" ; Hex(Reg_h26) ; " bzw. &b" ; Bin(Reg_h26) ; " RegDioMapping2 RW"
Print #1 , "Register h27 enthaelt &h" ; Hex(Reg_h27) ; " bzw. &b" ; Bin(Reg_h27) ; " RegIrqFlags1 R "
Print #1 , "Register h28 enthaelt &h" ; Hex(Reg_h28) ; " bzw. &b" ; Bin(Reg_h28) ; " RegIrqFlags2 R"
Print #1 , "Register h29 enthaelt &h" ; Hex(Reg_h29) ; " bzw. &b" ; Bin(Reg_h29) ; " RegRssiThresh RW"
Print #1 , "Register h2A enthaelt &h" ; Hex(Reg_h2A) ; " bzw. &b" ; Bin(Reg_h2A) ; " RegRxTimeout1 RW"
Print #1 , "Register h2B enthaelt &h" ; Hex(Reg_h2B) ; " bzw. &b" ; Bin(Reg_h2B) ; " RegRxTimeout2 RW"
Print #1 , "Register h2C enthaelt &h" ; Hex(Reg_h2C) ; " bzw. &b" ; Bin(Reg_h2C) ; " RegPreambleMSB RW"
Print #1 , "Register h2D enthaelt &h" ; Hex(Reg_h2D) ; " bzw. &b" ; Bin(Reg_h2D) ; " RegPreambleLSB RW"
Print #1 , "Register h2E enthaelt &h" ; Hex(Reg_h2E) ; " bzw. &b" ; Bin(Reg_h2E) ; " RegSyncConfig RW"
Print #1 , "Register h2F enthaelt &h" ; Hex(Reg_h2F) ; " bzw. &b" ; Bin(Reg_h2F) ; " RegSyncValue1 RW"
Print #1 ,
Print #1 , "Register h30 enthaelt &h" ; Hex(Reg_h30) ; " bzw. &b" ; Bin(Reg_h30) ; " RegSyncValue2 RW"
Print #1 , "Register h31 enthaelt &h" ; Hex(Reg_h31) ; " bzw. &b" ; Bin(Reg_h31) ; " RegSyncvalue3 RW"
Print #1 , "Register h32 enthaelt &h" ; Hex(Reg_h32) ; " bzw. &b" ; Bin(Reg_h32) ; " RegSyncvalue4 RW"
Print #1 , "Register h33 enthaelt &h" ; Hex(Reg_h33) ; " bzw. &b" ; Bin(Reg_h33) ; " RegSyncValue5 RW"
Print #1 , "Register h34 enthaelt &h" ; Hex(Reg_h34) ; " bzw. &b" ; Bin(Reg_h34) ; " RegSyncvalue6 RW"
Print #1 , "Register h35 enthaelt &h" ; Hex(Reg_h35) ; " bzw. &b" ; Bin(Reg_h35) ; " RegSyncvalue7 RW"
Print #1 , "Register h36 enthaelt &h" ; Hex(Reg_h36) ; " bzw. &b" ; Bin(Reg_h36) ; " RegSyncValue8 RW"
Print #1 , "Register h37 enthaelt &h" ; Hex(Reg_h37) ; " bzw. &b" ; Bin(Reg_h37) ; " RegPacketConfig1 RW"
Print #1 , "Register h38 enthaelt &h" ; Hex(Reg_h38) ; " bzw. &b" ; Bin(Reg_h38) ; " RegPayloadLength RW"
Print #1 , "Register h39 enthaelt &h" ; Hex(Reg_h39) ; " bzw. &b" ; Bin(Reg_h39) ; " RegNodeAdrs RW"
Print #1 , "Register h3A enthaelt &h" ; Hex(Reg_h3A) ; " bzw. &b" ; Bin(Reg_h3A) ; " RegBroadcastAdrs RW"
Print #1 , "Register h3B enthaelt &h" ; Hex(Reg_h3B) ; " bzw. &b" ; Bin(Reg_h3B) ; " RegAutoMode RW"
Print #1 , "Register h3C enthaelt &h" ; Hex(Reg_h3C) ; " bzw. &b" ; Bin(Reg_h3C) ; " RegFifoThresh RW"
Print #1 , "Register h3D enthaelt &h" ; Hex(Reg_h3D) ; " bzw. &b" ; Bin(Reg_h3D) ; " RegPacketConfig2 RW"
Print #1 , "Register h3E enthaelt &h" ; Hex(Reg_h3E) ; " bzw. &b" ; Bin(Reg_h3E) ; " RegAESKey01 RW"
Print #1 , "Register h3F enthaelt &h" ; Hex(Reg_h3F) ; " bzw. &b" ; Bin(Reg_h3F) ; " RegAESKey02 RW"
Print #1 ,
Print #1 , "Register h40 enthaelt &h" ; Hex(Reg_h40) ; " bzw. &b" ; Bin(Reg_h40) ; " RegAESKey03 RW"
Print #1 , "Register h41 enthaelt &h" ; Hex(Reg_h41) ; " bzw. &b" ; Bin(Reg_h41) ; " RegAESKey04 RW"
Print #1 , "Register h42 enthaelt &h" ; Hex(Reg_h42) ; " bzw. &b" ; Bin(Reg_h42) ; " RegAESKey05 RW"
Print #1 , "Register h43 enthaelt &h" ; Hex(Reg_h43) ; " bzw. &b" ; Bin(Reg_h43) ; " RegAESKey06 RW"
Print #1 , "Register h44 enthaelt &h" ; Hex(Reg_h44) ; " bzw. &b" ; Bin(Reg_h44) ; " RegAESKey07 RW"
Print #1 , "Register h45 enthaelt &h" ; Hex(Reg_h45) ; " bzw. &b" ; Bin(Reg_h45) ; " RegAESKey08 RW"
Print #1 , "Register h46 enthaelt &h" ; Hex(Reg_h46) ; " bzw. &b" ; Bin(Reg_h46) ; " RegAESKey09 RW"
Print #1 , "Register h47 enthaelt &h" ; Hex(Reg_h47) ; " bzw. &b" ; Bin(Reg_h47) ; " RegAESKey10 RW"
Print #1 , "Register h48 enthaelt &h" ; Hex(Reg_h48) ; " bzw. &b" ; Bin(Reg_h48) ; " RegAESKey11 RW"
Print #1 , "Register h49 enthaelt &h" ; Hex(Reg_h49) ; " bzw. &b" ; Bin(Reg_h49) ; " RegAESKey12 RW"
Print #1 , "Register h4A enthaelt &h" ; Hex(Reg_h4A) ; " bzw. &b" ; Bin(Reg_h4A) ; " RegAESKey13 RW"
Print #1 , "Register h4B enthaelt &h" ; Hex(Reg_h4B) ; " bzw. &b" ; Bin(Reg_h4B) ; " RegAESKey14 RW"
Print #1 , "Register h4C enthaelt &h" ; Hex(Reg_h4C) ; " bzw. &b" ; Bin(Reg_h4C) ; " RegAESKey15 RW"
Print #1 , "Register h4D enthaelt &h" ; Hex(Reg_h4D) ; " bzw. &b" ; Bin(Reg_h4D) ; " RegAESKey16 RW"
Print #1 , "Register h4E enthaelt &h" ; Hex(Reg_h4E) ; " bzw. &b" ; Bin(Reg_h4E) ; " RegTemp1 RW"
Print #1 , "Register h4F enthaelt &h" ; Hex(Reg_h4F) ; " bzw. &b" ; Bin(Reg_h4F) ; " RegTemp2 R "
Print #1 ,
Print #1 , "Register h50 enthaelt &h" ; Hex(Reg_h50) ; " bzw. &b" ; Bin(Reg_h50) ; " RegTestLna "
Print #1 , "Register h51 enthaelt &h" ; Hex(Reg_h51) ; " bzw. &b" ; Bin(Reg_h51) ; " RegTest (undokumentiert)"
Print #1 , "Register h52 enthaelt &h" ; Hex(Reg_h52) ; " bzw. &b" ; Bin(Reg_h52) ; " RegTest (undokumentiert)"
Print #1 , "Register h53 enthaelt &h" ; Hex(Reg_h53) ; " bzw. &b" ; Bin(Reg_h53) ; " RegTest (undokumentiert)"
Print #1 , "Register h54 enthaelt &h" ; Hex(Reg_h54) ; " bzw. &b" ; Bin(Reg_h54) ; " RegTest (undokumentiert)"
Print #1 , "Register h55 enthaelt &h" ; Hex(Reg_h55) ; " bzw. &b" ; Bin(Reg_h55) ; " RegTest (undokumentiert)"
Print #1 , "Register h56 enthaelt &h" ; Hex(Reg_h56) ; " bzw. &b" ; Bin(Reg_h56) ; " RegTest (undokumentiert)"
Print #1 , "Register h57 enthaelt &h" ; Hex(Reg_h57) ; " bzw. &b" ; Bin(Reg_h57) ; " RegTest (undokumentiert)"
Print #1 , "Register h58 enthaelt &h" ; Hex(Reg_h58) ; " bzw. &b" ; Bin(Reg_h58) ; " RegTestPa1 "
Print #1 , "Register h59 enthaelt &h" ; Hex(Reg_h59) ; " bzw. &b" ; Bin(Reg_h59) ; " RegTest (undokumentiert)"
Print #1 , "Register h5A enthaelt &h" ; Hex(Reg_h5A) ; " bzw. &b" ; Bin(Reg_h5A) ; " RegTestPa2 "
Print #1 , "Register h5B enthaelt &h" ; Hex(Reg_h5B) ; " bzw. &b" ; Bin(Reg_h5B) ; " RegTest (undokumentiert)"
Print #1 , "Register h5C enthaelt &h" ; Hex(Reg_h5C) ; " bzw. &b" ; Bin(Reg_h5C) ; " RegTest (undokumentiert)"
Print #1 , "Register h5D enthaelt &h" ; Hex(Reg_h5D) ; " bzw. &b" ; Bin(Reg_h5D) ; " RegTest (undokumentiert)"
Print #1 , "Register h5E enthaelt &h" ; Hex(Reg_h5E) ; " bzw. &b" ; Bin(Reg_h5E) ; " RegTest (undokumentiert)"
Print #1 , "Register h5F enthaelt &h" ; Hex(Reg_h5F) ; " bzw. &b" ; Bin(Reg_h5F) ; " RegTest (undokumentiert)"
Print #1 ,
Print #1 , "Register h60 enthaelt &h" ; Hex(Reg_h60) ; " bzw. &b" ; Bin(Reg_h60) ; " RegTest (undokumentiert)"
Print #1 , "Register h61 enthaelt &h" ; Hex(Reg_h61) ; " bzw. &b" ; Bin(Reg_h61) ; " RegTest (undokumentiert)"
Print #1 , "Register h62 enthaelt &h" ; Hex(Reg_h62) ; " bzw. &b" ; Bin(Reg_h62) ; " RegTest (undokumentiert)"
Print #1 , "Register h63 enthaelt &h" ; Hex(Reg_h63) ; " bzw. &b" ; Bin(Reg_h63) ; " RegTest (undokumentiert)"
Print #1 , "Register h64 enthaelt &h" ; Hex(Reg_h64) ; " bzw. &b" ; Bin(Reg_h64) ; " RegTest (undokumentiert)"
Print #1 , "Register h65 enthaelt &h" ; Hex(Reg_h65) ; " bzw. &b" ; Bin(Reg_h65) ; " RegTest (undokumentiert)"
Print #1 , "Register h66 enthaelt &h" ; Hex(Reg_h66) ; " bzw. &b" ; Bin(Reg_h66) ; " RegTest (undokumentiert)"
Print #1 , "Register h67 enthaelt &h" ; Hex(Reg_h67) ; " bzw. &b" ; Bin(Reg_h67) ; " RegTest (undokumentiert)"
Print #1 , "Register h68 enthaelt &h" ; Hex(Reg_h68) ; " bzw. &b" ; Bin(Reg_h68) ; " RegTest (undokumentiert)"
Print #1 , "Register h69 enthaelt &h" ; Hex(Reg_h69) ; " bzw. &b" ; Bin(Reg_h69) ; " RegTest (undokumentiert)"
Print #1 , "Register h6A enthaelt &h" ; Hex(Reg_h6A) ; " bzw. &b" ; Bin(Reg_h6A) ; " RegTest (undokumentiert)"
Print #1 , "Register h6B enthaelt &h" ; Hex(Reg_h6B) ; " bzw. &b" ; Bin(Reg_h6B) ; " RegTest (undokumentiert)"
Print #1 , "Register h6C enthaelt &h" ; Hex(Reg_h6C) ; " bzw. &b" ; Bin(Reg_h6C) ; " RegTest (undokumentiert)"
Print #1 , "Register h6D enthaelt &h" ; Hex(Reg_h6D) ; " bzw. &b" ; Bin(Reg_h6D) ; " RegTest (undokumentiert)"
Print #1 , "Register h6E enthaelt &h" ; Hex(Reg_h6E) ; " bzw. &b" ; Bin(Reg_h6E) ; " RegTest (undokumentiert)"
Print #1 , "Register h6F enthaelt &h" ; Hex(Reg_h6F) ; " bzw. &b" ; Bin(Reg_h6F) ; " RegTestDagc "
Print #1 ,
Print #1 , "Register h70 enthaelt &h" ; Hex(Reg_h70) ; " bzw. &b" ; Bin(Reg_h70) ; " RegTest (undokumentiert)"
Print #1 , "Register h71 enthaelt &h" ; Hex(Reg_h71) ; " bzw. &b" ; Bin(Reg_h71) ; " RegTestAcf "
Print #1 , "Registerdump Ende"
Print #1 , "======================================================================================================"
Print #1 ,
Return
')
Close #1
Close #2
End
$include "RFM69_Modulation 4800Baud.inc"
'*******************************************************************************
Print