www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik RFM12B - Wozu sendet man drei Dummybytes?


Autor: Olaf (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

warum sendet man nach den Datenwörtern noch drei Dummybytes (0xAA) bei 
der Senderoutine des RFM12B. Sende ich gar kein Dummybyte hinterher, 
werden scheinbar Zufallswörter empfangen. Sende ich ein oder mehr 
Dummybytes mit funktioniert es. Was passiert da genau? Muss da ein 
Puffer gefüllt werden?

Gruß
Olli

Autor: Claudio H. (hedie)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nein

Die Dummybytes dienen dazu, das sich das RFM Modul Synchronisieren kann.
Durch Bittoggeling also Abwechselnd 0 und 1 kann es sich perfekt ein 
Tunen.

Alles was danach kommt wird somit korrekt empfangen...

Kannst du mir mal deine Initialisierung Posten?

Ich beschäftige mich derzeit auch mit den RFM12 Modulen.

Bei mir hapert es jedoch mit dem empfang.

Siehe hier: Beitrag "RFM12 Beispiel funktioniert nicht"

Autor: Olli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Claudio,

was die Synchronisation betrifft habe ich in der Initialisierungsphase 2 
Synchronisationsbytes eingestellt. 0x2D ist standard und 0xD4 ist das 
zweite Synchronisationsbyte. Beim Senden schicke ich drei 0xAA 
Dummybytes voraus und mindestens eines nach den Datenbytes hinterher. 
Von den 0xAA-Bytes ist im Datenblatt soweit ich es gelesen habe nicht 
die Rede - wohl aber tauchen sie im Beispielcode auf: (Seite 16 - 
RFM12B_code)
RF12_SEND(0xAA);//PREAMBLE
RF12_SEND(0xAA);//PREAMBLE
RF12_SEND(0xAA);//PREAMBLE
RF12_SEND(0x2D);//SYNC HI BYTE
RF12_SEND(0xD4);//SYNC LOW BYTE
RF12_SEND(0x30);//DATA BYTE 0
ChkSum+=0x30;
RF12_SEND(0x31);//DATA BYTE 1
ChkSum+=0x31;
RF12_SEND(0x32);
ChkSum+=0x32;
RF12_SEND(0x33);
ChkSum+=0x33;
RF12_SEND(0x34);
ChkSum+=0x34;
RF12_SEND(0x35);
ChkSum+=0x35;
RF12_SEND(0x36);
ChkSum+=0x36;
RF12_SEND(0x37);
ChkSum+=0x37;
RF12_SEND(0x38);
ChkSum+=0x38;
RF12_SEND(0x39);
ChkSum+=0x39;
RF12_SEND(0x3A);
ChkSum+=0x3A;
RF12_SEND(0x3B);
ChkSum+=0x3B;
RF12_SEND(0x3C);
ChkSum+=0x3C;
RF12_SEND(0x3D);
ChkSum+=0x3D;
RF12_SEND(0x3E);
ChkSum+=0x3E;
RF12_SEND(0x3F); //DATA BYTE 15
ChkSum+=0x3F;
RF12_SEND(ChkSum); //send chek sum
RF12_SEND(0xAA);//DUMMY BYTE
RF12_SEND(0xAA);//DUMMY BYTE
RF12_SEND(0xAA);//DUMMY BYTE

Meinen die anderen auch, dass es sich um Synchronisation handelt?

Grüße
Olli

Autor: Gastino G. (gastino)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Die Dummy-Bytes werden verschickt, damit man den Sender nicht zu zeitig 
abschaltet und damit das letzte Byte abwürgt. Wenn der Schreibpuffer 
wieder beschreibbar ist, heißt das ja noch nicht, dass der Sender schon 
mit dem Versand des letzten Bytes auch wirklich fertig ist.
Man braucht übrigens, wenn ich mich recht erinnere, nur ein Dummy-Byte.

Autor: Claudio H. (hedie)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Olli

Danke für deinen Code...

Könntest du mir noch deine Initialisierung Posten?

Vielen Dank :)

Autor: Olli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@ Gastino :

Ja, die Erfahrung, dass man nur ein Dummybyte braucht habe ich auch 
gemacht.

@ Claudio :

Ich poste hier den Code, allerdings läuft der in einem Picoblaze ab und 
ist per Hardware-SPI an das Modul gepappt. Ich schreibe demnächst auch 
eine kleine Doku dazu, wenn ich daran denke poste ich dann noch den Link 
hier.
Viel Erfolg damit:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                            ;;
;; RFM12B control functions, used for wireless communication                  ;;
;;                                                                            ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

          ;
          ; initialize 
          ;
          ;; 80E7 - el, ef, 868MHZ, 16pF load capacitance  
          ;; 8239 - !er, !ebb, et, es, ex, !eb, !ew, dc
          ;; A74E
          ;; C647
          ;; 94A0
          ;; C2AC
          ;; CA81
          ;; CED4
          ;; C483
          ;; 9820
          ;; CC77
          ;; E000
          ;; C800
          ;; C040
init_rfm12b:
          LOAD GP_REG1, 80
          LOAD GP_REG2, E7
          CALL spi_exchange
          
          LOAD GP_REG1, 82
          LOAD GP_REG2, 39
          CALL spi_exchange
          
          LOAD GP_REG1, A7
          LOAD GP_REG2, 4E
          CALL spi_exchange
          
          LOAD GP_REG1, C6
          LOAD GP_REG2, 47
          CALL spi_exchange
          
          LOAD GP_REG1, 94
          LOAD GP_REG2, A0
          CALL spi_exchange
          
          LOAD GP_REG1, C2
          LOAD GP_REG2, AC
          CALL spi_exchange
          
          LOAD GP_REG1, CA
          LOAD GP_REG2, 81
          CALL spi_exchange
          
          LOAD GP_REG1, CE
          LOAD GP_REG2, D4
          CALL spi_exchange
          
          LOAD GP_REG1, C4
          LOAD GP_REG2, 83
          CALL spi_exchange
          
          LOAD GP_REG1, 98
          LOAD GP_REG2, 20
          CALL spi_exchange
          
          LOAD GP_REG1, CC
          LOAD GP_REG2, 77
          CALL spi_exchange
          
          LOAD GP_REG1, E0
          LOAD GP_REG2, 00
          CALL spi_exchange
          
          LOAD GP_REG1, C8
          LOAD GP_REG2, 00
          CALL spi_exchange
          
          LOAD GP_REG1, C0
          LOAD GP_REG2, E0
          CALL spi_exchange
          
          RETURN
          
          ;
          ; sends several bytes to another RFM module
          ;
          ;; DATA_DESTINATION_REG specifies where data to send is located in scratchpad RAM
          ;; DATA_LENGTH_REG indicates the length of the string to transmit
send_rfm12b:
          LOAD GP_REG1, 82
          LOAD GP_REG2, 38
          CALL spi_exchange
          
          LOAD RFM_DATA_REG, AA
          CALL put_rfm12b          ; 0xAA
          CALL put_rfm12b          ; 0xAA
          CALL put_rfm12b          ; 0xAA
          LOAD RFM_DATA_REG, 2D
          CALL put_rfm12b          ; 0x2D
          LOAD RFM_DATA_REG, D4
          CALL put_rfm12b          ; 0xD4
          
 send_byte_rfm12b:
          FETCH RFM_DATA_REG, (DATA_DESTINATION_REG)
          CALL put_rfm12b
          SUB DATA_LENGTH_REG, 01
          JUMP NZ, send_byte_rfm12b
          
          LOAD RFM_DATA_REG, AA
          ;CALL put_rfm12b          ; 0xAA ###############
          ;CALL put_rfm12b          ; 0xAA ###############
          CALL put_rfm12b          ; 0xAA
          
 send_rgit_wait:
          LOAD GP_REG1, 00
          LOAD GP_REG2, 00
          CALL spi_exchange
          TEST GP_REG1, 80
          JUMP Z, send_rgit_wait
          
          LOAD GP_REG1, 82
          LOAD GP_REG2, 08
          CALL spi_exchange
          
          RETURN
          
          ;
          ; receives several bytes from another RFM module
          ;
          ;; DATA_DESTINATION_REG specifies where received data is located in scratchpad RAM
          ;; DATA_LENGTH_REG indicates the length of the string to receive
receive_rfm12b:
          LOAD GP_REG1, 82
          LOAD GP_REG2, 99
          CALL spi_exchange
          
          LOAD GP_REG1, CA
          LOAD GP_REG2, 81
          CALL spi_exchange
          
          LOAD GP_REG1, CA
          LOAD GP_REG2, 83
          CALL spi_exchange
          
 receive_byte_rfm12b:
          CALL get_rfm12b
          STORE RFM_DATA_REG, (DATA_DESTINATION_REG)
          ADD DATA_DESTINATION_REG, 01
          SUB DATA_LENGTH_REG, 01
          JUMP NZ, receive_byte_rfm12b
          
 receive_ffit_wait:
          LOAD GP_REG1, 00
          LOAD GP_REG2, 00
          CALL spi_exchange
          TEST GP_REG1, 80
          JUMP Z, receive_ffit_wait
          
          LOAD GP_REG1, 82
          LOAD GP_REG2, 08
          CALL spi_exchange
          
          RETURN
          
put_rfm12b:
          LOAD GP_REG1, 00
          LOAD GP_REG2, 00
          CALL spi_exchange
          TEST GP_REG1, 80
          JUMP Z, put_rfm12b
          
          LOAD GP_REG1, B8
          LOAD GP_REG2, RFM_DATA_REG
          CALL spi_exchange
          
          RETURN
          
get_rfm12b:
          LOAD GP_REG1, 00
          LOAD GP_REG2, 00
          CALL spi_exchange
          TEST GP_REG1, 80
          JUMP z, get_rfm12b
          
          LOAD GP_REG1, B0
          LOAD GP_REG2, 00
          CALL spi_exchange
          LOAD RFM_DATA_REG, GP_REG2
          
          RETURN

Autor: Olli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Claudio:
Anmerkung:
Den Code, den ich davor gepostet habe, ist dem Datenblatt entnommen.

Autor: Claudio H. (hedie)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Olli schrieb:
> Ich poste hier den Code, allerdings läuft der in einem Picoblaze ab und
> ist per Hardware-SPI an das Modul gepappt

Danke für den Code

Ich hab deine Initialisierung 1:1 Übernommen.

Auch das senden habe ich genau so gemacht.

Jedoch klappt es nicht :(

Meine Module liegen 5 cm voneinander entfernt.


Nach dem ich gesendet habe, lese ich beim empfanger Modul das 
Statusregister aus. Diese zeigt merkwürdigerweise bei nach jedem senden 
un auslesen etwas anderes an :S

Nach dem ich das Statusregister ausgelesen habe, springt nIRQ auf High
Die solange bis ich den RX Deaktiviere.

Sehr merkwürdig oder?

Autor: Olli (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
* Hast du eine Antenne angelötet?
* Wie sieht deine Empfangsroutine aus?

Gruß

Autor: Sörn (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Schonmal darüber nachgedacht eine fertige library dafür zu nehmen? Ich 
sehe hier immer wieder threads aufpoppen, bei denen Leute fragen zu 
RF12(B) ICs stellen - okay zugegeben - die datenblätter sind echt 
schlecht... Aber ich verstehe nicht warum man nicht einfach was fertiges 
benutzen oder zumindest daraus abgucken kann...

Hier mal eine Auswahl:
* http://github.com/ethersex/ethersex/tree/master/ha...
* http://das-labor.org/wiki/RFM12_library
* http://cafe.jeelabs.net/sw/library_-_rf12/

Autor: Holger S. (holli_1)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Olaf schrieb:
> warum sendet man nach den Datenwörtern noch drei Dummybytes (0xAA) bei
> der Senderoutine des RFM12B. Sende ich gar kein Dummybyte hinterher,
> werden scheinbar Zufallswörter empfangen. Sende ich ein oder mehr
> Dummybytes mit funktioniert es. Was passiert da genau? Muss da ein
> Puffer gefüllt werden?

Richtig, wenn du den Sendepuffer des RFM12 verwendest, musst du an Ende 
noch 2 (Dummy)Bytes in den Puffer schieben. Damit werden deine letzten 2 
Datenbytes auch aus dem Puffer noch gesendet. Sonst bekommst du wie 
beobachtet diese Zufallswörter, da die Daten im Puffer stecken bleiben. 
Ob es 0xAA ist oder etwas anderes ist letztendlich egal.

Zu Beginn der Übertragung brauchst du die Dummybytes eigentlich auch 
nicht zu übertragen, da der RFM 2 Dummybytes automatisch erzeugt. Bei 
et=0 wird der Sendepuffer automatisch auf 0xAA gesetzt. Diese werden 
dann beim Übertragen der Sync bytes gesendet.

Autor: Gastino G. (gastino)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Sörn schrieb:
> Schonmal darüber nachgedacht eine fertige library dafür zu nehmen?

Kann man machen, muss man aber nicht. Manche haben auch den Anspruch, 
detailliert zu verstehen, wie das funktioniert. Und das geht nun mal am 
besten, wenn man es selber macht. Vom sportlichen Gedanken mal ganz 
abgesehen...

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.