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
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"
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)
1 | RF12_SEND(0xAA);//PREAMBLE |
2 | RF12_SEND(0xAA);//PREAMBLE |
3 | RF12_SEND(0xAA);//PREAMBLE |
4 | RF12_SEND(0x2D);//SYNC HI BYTE |
5 | RF12_SEND(0xD4);//SYNC LOW BYTE |
6 | RF12_SEND(0x30);//DATA BYTE 0 |
7 | ChkSum+=0x30; |
8 | RF12_SEND(0x31);//DATA BYTE 1 |
9 | ChkSum+=0x31; |
10 | RF12_SEND(0x32); |
11 | ChkSum+=0x32; |
12 | RF12_SEND(0x33); |
13 | ChkSum+=0x33; |
14 | RF12_SEND(0x34); |
15 | ChkSum+=0x34; |
16 | RF12_SEND(0x35); |
17 | ChkSum+=0x35; |
18 | RF12_SEND(0x36); |
19 | ChkSum+=0x36; |
20 | RF12_SEND(0x37); |
21 | ChkSum+=0x37; |
22 | RF12_SEND(0x38); |
23 | ChkSum+=0x38; |
24 | RF12_SEND(0x39); |
25 | ChkSum+=0x39; |
26 | RF12_SEND(0x3A); |
27 | ChkSum+=0x3A; |
28 | RF12_SEND(0x3B); |
29 | ChkSum+=0x3B; |
30 | RF12_SEND(0x3C); |
31 | ChkSum+=0x3C; |
32 | RF12_SEND(0x3D); |
33 | ChkSum+=0x3D; |
34 | RF12_SEND(0x3E); |
35 | ChkSum+=0x3E; |
36 | RF12_SEND(0x3F); //DATA BYTE 15 |
37 | ChkSum+=0x3F; |
38 | RF12_SEND(ChkSum); //send chek sum |
39 | RF12_SEND(0xAA);//DUMMY BYTE |
40 | RF12_SEND(0xAA);//DUMMY BYTE |
41 | RF12_SEND(0xAA);//DUMMY BYTE |
Meinen die anderen auch, dass es sich um Synchronisation handelt? Grüße Olli
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.
Hallo Olli Danke für deinen Code... Könntest du mir noch deine Initialisierung Posten? Vielen Dank :)
@ 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:
1 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
2 | ;; ;; |
3 | ;; RFM12B control functions, used for wireless communication ;; |
4 | ;; ;; |
5 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
6 | |
7 | ; |
8 | ; initialize |
9 | ; |
10 | ;; 80E7 - el, ef, 868MHZ, 16pF load capacitance |
11 | ;; 8239 - !er, !ebb, et, es, ex, !eb, !ew, dc |
12 | ;; A74E |
13 | ;; C647 |
14 | ;; 94A0 |
15 | ;; C2AC |
16 | ;; CA81 |
17 | ;; CED4 |
18 | ;; C483 |
19 | ;; 9820 |
20 | ;; CC77 |
21 | ;; E000 |
22 | ;; C800 |
23 | ;; C040 |
24 | init_rfm12b: |
25 | LOAD GP_REG1, 80 |
26 | LOAD GP_REG2, E7 |
27 | CALL spi_exchange |
28 | |
29 | LOAD GP_REG1, 82 |
30 | LOAD GP_REG2, 39 |
31 | CALL spi_exchange |
32 | |
33 | LOAD GP_REG1, A7 |
34 | LOAD GP_REG2, 4E |
35 | CALL spi_exchange |
36 | |
37 | LOAD GP_REG1, C6 |
38 | LOAD GP_REG2, 47 |
39 | CALL spi_exchange |
40 | |
41 | LOAD GP_REG1, 94 |
42 | LOAD GP_REG2, A0 |
43 | CALL spi_exchange |
44 | |
45 | LOAD GP_REG1, C2 |
46 | LOAD GP_REG2, AC |
47 | CALL spi_exchange |
48 | |
49 | LOAD GP_REG1, CA |
50 | LOAD GP_REG2, 81 |
51 | CALL spi_exchange |
52 | |
53 | LOAD GP_REG1, CE |
54 | LOAD GP_REG2, D4 |
55 | CALL spi_exchange |
56 | |
57 | LOAD GP_REG1, C4 |
58 | LOAD GP_REG2, 83 |
59 | CALL spi_exchange |
60 | |
61 | LOAD GP_REG1, 98 |
62 | LOAD GP_REG2, 20 |
63 | CALL spi_exchange |
64 | |
65 | LOAD GP_REG1, CC |
66 | LOAD GP_REG2, 77 |
67 | CALL spi_exchange |
68 | |
69 | LOAD GP_REG1, E0 |
70 | LOAD GP_REG2, 00 |
71 | CALL spi_exchange |
72 | |
73 | LOAD GP_REG1, C8 |
74 | LOAD GP_REG2, 00 |
75 | CALL spi_exchange |
76 | |
77 | LOAD GP_REG1, C0 |
78 | LOAD GP_REG2, E0 |
79 | CALL spi_exchange |
80 | |
81 | RETURN |
82 | |
83 | ; |
84 | ; sends several bytes to another RFM module |
85 | ; |
86 | ;; DATA_DESTINATION_REG specifies where data to send is located in scratchpad RAM |
87 | ;; DATA_LENGTH_REG indicates the length of the string to transmit |
88 | send_rfm12b: |
89 | LOAD GP_REG1, 82 |
90 | LOAD GP_REG2, 38 |
91 | CALL spi_exchange |
92 | |
93 | LOAD RFM_DATA_REG, AA |
94 | CALL put_rfm12b ; 0xAA |
95 | CALL put_rfm12b ; 0xAA |
96 | CALL put_rfm12b ; 0xAA |
97 | LOAD RFM_DATA_REG, 2D |
98 | CALL put_rfm12b ; 0x2D |
99 | LOAD RFM_DATA_REG, D4 |
100 | CALL put_rfm12b ; 0xD4 |
101 | |
102 | send_byte_rfm12b: |
103 | FETCH RFM_DATA_REG, (DATA_DESTINATION_REG) |
104 | CALL put_rfm12b |
105 | SUB DATA_LENGTH_REG, 01 |
106 | JUMP NZ, send_byte_rfm12b |
107 | |
108 | LOAD RFM_DATA_REG, AA |
109 | ;CALL put_rfm12b ; 0xAA ############### |
110 | ;CALL put_rfm12b ; 0xAA ############### |
111 | CALL put_rfm12b ; 0xAA |
112 | |
113 | send_rgit_wait: |
114 | LOAD GP_REG1, 00 |
115 | LOAD GP_REG2, 00 |
116 | CALL spi_exchange |
117 | TEST GP_REG1, 80 |
118 | JUMP Z, send_rgit_wait |
119 | |
120 | LOAD GP_REG1, 82 |
121 | LOAD GP_REG2, 08 |
122 | CALL spi_exchange |
123 | |
124 | RETURN |
125 | |
126 | ; |
127 | ; receives several bytes from another RFM module |
128 | ; |
129 | ;; DATA_DESTINATION_REG specifies where received data is located in scratchpad RAM |
130 | ;; DATA_LENGTH_REG indicates the length of the string to receive |
131 | receive_rfm12b: |
132 | LOAD GP_REG1, 82 |
133 | LOAD GP_REG2, 99 |
134 | CALL spi_exchange |
135 | |
136 | LOAD GP_REG1, CA |
137 | LOAD GP_REG2, 81 |
138 | CALL spi_exchange |
139 | |
140 | LOAD GP_REG1, CA |
141 | LOAD GP_REG2, 83 |
142 | CALL spi_exchange |
143 | |
144 | receive_byte_rfm12b: |
145 | CALL get_rfm12b |
146 | STORE RFM_DATA_REG, (DATA_DESTINATION_REG) |
147 | ADD DATA_DESTINATION_REG, 01 |
148 | SUB DATA_LENGTH_REG, 01 |
149 | JUMP NZ, receive_byte_rfm12b |
150 | |
151 | receive_ffit_wait: |
152 | LOAD GP_REG1, 00 |
153 | LOAD GP_REG2, 00 |
154 | CALL spi_exchange |
155 | TEST GP_REG1, 80 |
156 | JUMP Z, receive_ffit_wait |
157 | |
158 | LOAD GP_REG1, 82 |
159 | LOAD GP_REG2, 08 |
160 | CALL spi_exchange |
161 | |
162 | RETURN |
163 | |
164 | put_rfm12b: |
165 | LOAD GP_REG1, 00 |
166 | LOAD GP_REG2, 00 |
167 | CALL spi_exchange |
168 | TEST GP_REG1, 80 |
169 | JUMP Z, put_rfm12b |
170 | |
171 | LOAD GP_REG1, B8 |
172 | LOAD GP_REG2, RFM_DATA_REG |
173 | CALL spi_exchange |
174 | |
175 | RETURN |
176 | |
177 | get_rfm12b: |
178 | LOAD GP_REG1, 00 |
179 | LOAD GP_REG2, 00 |
180 | CALL spi_exchange |
181 | TEST GP_REG1, 80 |
182 | JUMP z, get_rfm12b |
183 | |
184 | LOAD GP_REG1, B0 |
185 | LOAD GP_REG2, 00 |
186 | CALL spi_exchange |
187 | LOAD RFM_DATA_REG, GP_REG2 |
188 | |
189 | RETURN |
@Claudio: Anmerkung: Den Code, den ich davor gepostet habe, ist dem Datenblatt entnommen.
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?
* Hast du eine Antenne angelötet? * Wie sieht deine Empfangsroutine aus? Gruß
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/hardware/radio/rfm12/ * http://das-labor.org/wiki/RFM12_library * http://cafe.jeelabs.net/sw/library_-_rf12/
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.
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...
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.