Probleme mit RFM12 868Mhz Code und Snap

[mat-sche]

Hallo Dieter,
leider bin ich noch weiter gekommen, in der Woche fehlte mir die Zeit (arbeiten & Haus ausbauen)
Heute wollte ich etwas machen aber....
Nun gut. Das Protokoll habe ich soweit verstanden und bin eigentlich noch dran den Fehler zu suchen warum der Ursprungscode bei mir nicht läuft. Dieser hat mir deswegen gefallen, weil dieser mit einer Lib fungiert. Noch habe ich viele Fragen zu der Initialisierung des RFM12, vielleicht funktioniert deswegen der code nicht, da anders initialisiert wird. Melde mich die Woche noch einmal...
Zu einem Energiemonitor habe ich keine Idee, wo soll dieser ANwendung finden?
Schönen Sonntag noch.
Grüße MAT

[raptor_79]

hallo ihr zwei!

ich hab das gerade gefunden.... weil ich auch gerad an einem RFM12 (433Mhz) herumwerkle.
ich habe aber gerade mal angefangen, schaltung (pollin avr-funk-eval-board) ist noch nicht mal kalt.... also gerade zusammen gelötet.

mir ist bei den boards so einiges noch unklar. aber wie gesagt, habe gerade angefangen. noch nicht mal den schaltplan richtig angesehen, und die doku zum board/modul gelesen. nur mal überflogen.

ja, ich hoffe, da bekommen wir was hin.


viel erfolg wollte ich euch nur mal wünschen.



ja, wegen energiemonitor.... schon mal dran gedacht, das ganze übe eine induktionsspule zu messen? also draht über das 230V kabel wickeln und mit dem adc messen. vorher halt über eine diode und C gleichrichten.....

[Holli_]

Hallo Matthias
Spiin = &HB0 wir müssen ja, wenn wir Daten lesen wollen in dem ersten Byte &hB0 übergeben, das wird damit angegeben. Ansonsten würde die SPI nur &H00 ausgeben.

Der Code war übrigens von mir, daher habe ich noch eine Anmerkung. Es gibt 2 Möglichkeiten den FIFO zu Lesen. Einmal mit "FIFO read command", dafür wird Spiin = &HB0 verwendet. Es geht auch mit dem "Status read command" dann muss Spiin = 0 benutzt werden. Beim "Status read command" müssen 3 Byte gelesen werden, in den ersten beiden sind die Statusbits, danach kommen Fifo Daten.

[mat-sche]

HAllo Holli & Dieter,

mit dem Code von oben

'Interrupt Routine zum empfangen der bytes aus dem RFM 12
Ffit_isr:
      Set Led1                                              ':zum debuggen für LA
      Reset Led1
      Spiin Fifo(1) , 2                                     '1 Byte lesen
      Temp = Fifo(2)

     If Temp = Snap_sync And Rf_sync = 0 Then
        Rf_sync = 1
        Lv = 1
        Framelength = 6
    End If

     If Lv = 3 Then
        Ndb = Temp And &H0F                                 'Anzahl Datenbytes berechnen
        Ndb = 9                                             'zum debuggen
        Select Case Ndb
               Case 0 To 8 : Framelength = 6 + Ndb          '6-14 (0--8 Datebyte)
               Case 9 : Framelength = 6 + 16                '22   (16 Datenbyte)
               Case 10 : Framelength = 6 + 32               '38   (32 Datenbyte)
               'Case 11 : Framelength = 6 + 64               '70   (64 Datenbyte)
               End Select
    End If

    If Lv >= Framelength And Rf_sync = 1 Then               'alles eingetroffen
            Rf_rxd = 1                                      'Flag setzen und Empfänger zurück setzen
            Rf_sync = 0
           Call Rf_cmd(&H0000)                              'read status
           Call Rf_cmd(&Hca81)                              'Reset FIFO       wir warten wieder auf SYNC vom RFM 12
           Call Rf_cmd(&Hca83)                              'enable FIFO
    End If

    Rf12_data(lv) = Temp


    Incr Lv
   ' Überlauf abgefangen , passend zum Empfangsbuffer
    If Lv >= Recive_buffer_size Then
         'Überlauf
          Rf_sync = 0
           Lv = 1
           Rf12_s = ""                                      'buffer löschen
    End If
Return

kann ich gut meine Daten empfangen. Nur leider habe ich festgestellt, dass das letzte Byte nicht mit dem gesendeten übereinstimmt. Woran kann das liegen?

Grüße Matthias

[Holli_]

Auf der Senderseite musst du am Ende noch 2 Byte zusätzlich zu den Daten senden z.B. &Haa. Damit werden die Datenbytes aus dem Sendepuffer noch gesendet. Sonst bleiben die nämlich im Puffer stecken.

[Dino Dieter]

Hallo Holli_

Ich habe auch mit dem Code von dir angefangen und es hat direkt gut geklappt. Schreibe den Code jetzt nach meinen Bedürfnissen um. Viel ist von deinem Code leider nicht mehr übrig geblieben, das liegt aber auch an den neuen Versionen von Bascom, welche heute andere Möglichkeiten haben.


An dieser Stelle eine großes Danke für den leichten Einstieg.

MFG
Dieter

[mat-sche]

@ Holli,

werde ich mal ausprobieren. Nur was mir spanisch vorkommt ist, dass ja ein letztes byte gesendet wird...

[Holli_]

Es braucht aber 2 Byte, da der TX-Puffer auch 16 bit groß ist. Ebenso ist der RX-Puffer 16 bit, es werden meistens aber nur 8 bit genutzt. Außerdem kann nur für den RX-Puffer die Größe eingestellt werden, "Fifo IT level" im Register &HCAxx. Der TX-Puffer ist immer 16 bit.

[mat-sche]

N'Abend,

laut meinem Code schiebe ich ja noch 2 Bytes hinterher:

Sub Rf12_txdata(byval Txlen As Byte)
  Temp = Rf12_trans(&H8238) : Rf12_ready                                                                                          'Power CMD: synt.& PLL on
  Temp = Rf12_trans(&H8230) : Rf12_ready
  Temp = Rf12_trans(&H0000) : Rf12_ready                                                                                          'Status holen
 Rf12_status = Temp                                                                                                               'Status einlesen
  Temp = Rf12_trans(&Hb8aa) : Rf12_ready                                                                                          'Preamble
 Temp = Rf12_trans(&Hb8aa) : Rf12_ready                                                                                           'Preamble
  Temp = Rf12_trans(&Hb8aa) : Rf12_ready                                                                                          'Preamble in FIFO schieben
  Temp = Rf12_trans(&Hb82d) : Rf12_ready                                                                                          'Startzeichen: 2D für den Empfänger
  Temp = Rf12_trans(&Hb8d4) : Rf12_ready                                                                                          'Startzeichen: D4 für den Empfänger
  Print "sende1"
  For Lv = 1 To Txlen
      Rf12_ready
      Temp = &HB800 + Rf12_data(lv)                                                                                               'Sende Nutzdaten
      Temp = Rf12_trans(temp)
      'Toggle Led2
      Print "temp" ; Temp
      Next Lv
Temp = Rf12_trans(&Hb8aa) : Rf12_ready
  Temp = Rf12_trans(&Hb8aa) : Rf12_ready                                                                                          'Dummybyte nachschieben
  Temp = Rf12_trans(&H8208) : Rf12_ready                                                                                          'Power CMD: synt.& PLL off, Quarz-clk läuft weiter
  Print "sende2"
  End Sub

und hier wird es über SPI übertragen:

Function Rf12_trans(byval Wert As Word) As Word
  Local Lowbyte As Byte
  Local Highbyte As Byte

  Lowbyte = Low(wert) : Highbyte = High(wert)
Reset Spi_cs
  Highbyte = Spimove(highbyte) : Lowbyte = Spimove(lowbyte)
Set Spi_cs
  Temp = Makeint(lowbyte , Highbyte)                                                                                              'debug
  Rf12_trans = Temp
     Print "SPI receive: " ; Hex(temp)
     Print "SPI send " ; Hex(highbyte)
End Function

Irgend eine Idee warum das letzte Byte dennoch falsch sein kann?

[Holli_]

Folgendes habe ich bei diesem Code gefunden:
- Print Ausgaben während des Sendezyklus (von TX on bis TX off) sollten nicht sein, da die recht viel Zeit brauchen und der Sendepuffer rechtzeitig gefüllt werden muss.
- Rf12_ready brauchst du nur zur Übertragung der Sendedaten in den Puffer, nicht zum Beschreiben der Register selbst. Zuerst rf12_ready, dann rf12_trans ausführen. Mit Rf12_ready bekommt der RFM erst dann Daten, wenn er diese braucht.
- Zwischen der Übertragung der Nutzdaten und dem Dummybyte ist kein Rf12_ready, damit wird das Byte unkontrolliert in den Puffer geschrieben. Damit die Übertragung entweder gestört oder das Byte wird intern verworfen.
- Prinzipiell kann man auf das Senden der Preambel an den RFM verzichten, da der TX-Puffer selbst eine 2 Byte lange Preambel erzeugt.


So sollte der Code dann aussehen:

Sub Rf12_txdata(byval Txlen As Byte)
  Temp = Rf12_trans(&H8238)                                                                                         'Power CMD: synt.& PLL on
  Temp = Rf12_trans(&H8230)
  Temp = Rf12_trans(&H0000)                                                                                         'Status holen
 Rf12_status = Temp  
 Rf12_ready                                                                                                              'Status einlesen
  Temp = Rf12_trans(&Hb8aa)                                                                                         'Preamble
 Rf12_ready                                                                                                              'Status einlesen
 Temp = Rf12_trans(&Hb8aa)  
 Rf12_ready                                                                                           'Preamble
  Temp = Rf12_trans(&Hb8aa) 
  Rf12_ready                                                                                          'Preamble in FIFO schieben
  Temp = Rf12_trans(&Hb82d)  
  Rf12_ready                                                                                          'Startzeichen: 2D für den Empfänger
  Temp = Rf12_trans(&Hb8d4)                                                                                           'Startzeichen: D4 für den Empfänger
  'Print "sende1"
  For Lv = 1 To Txlen
      Rf12_ready
      Temp = &HB800 + Rf12_data(lv)                                                                                               'Sende Nutzdaten
      Temp = Rf12_trans(temp)
      'Toggle Led2
      'Print "temp" ; Temp
      Next Lv
Rf12_ready                                                                                                              'Status einlesen
 Temp = Rf12_trans(&Hb8aa) 
Rf12_ready                                                                                                              'Status einlesen
   Temp = Rf12_trans(&Hb8aa)                                                                                         'Dummybyte nachschieben
  Temp = Rf12_trans(&H8208)                                                           'Power CMD: synt.& PLL off, Quarz-clk läuft weiter
  Print "sende2"
End Sub