Den gleichen Text aus "RFM12BP Ansteuerung" jetzt hier noch einmal: Da es mir auch nach Monaten des Experimentierens noch nicht gelungen ist, eine Verbindung zwischen zwei RFM12BP 868MHz-modulen herzustellen, bitte ich um Hilfe. Ich hätte gern ein ganz einfaches Testprogramm für RFM12BP 868MHz, um mal den Einstieg zu schaffen. Leider sind die Beispielprogramme (z.B von Pollin, Hopfner) teilweise in sich widersprechend. Zunächst noch einige allg. Fragen: 1) wird mit RXEN = `H´ der Empfangsteil eingeschaltet? 2) wird mit TXEN = `H´ der Sendeteil eingeschaltet? Was könnte bei der angehängten Datei --Ausschnitte RFM12BP.c-- falsch sein? Vielen Dank.
wolle g. schrieb: > Den gleichen Text aus "RFM12BP Ansteuerung" jetzt hier noch einmal: Stimmt Beitrag "Re: RFM12BP Ansteuerung"
ICh habe RFM12B und RFM12BP laufen. Folgende Effekte bei (bei einer Arduino-NANO-HW mit Ansteuerung der RFM12BPs über SPI) habe ich festgestellt, daß diese nicht funktionieren (kein IRQ), sobald der AVR über einen SPI-Programmierer (bei mir DIAMEX) gerade beschrieben wurde. Abhilfe: RFM12 für einige Sekunden komplett abklemmen, dann Prozessor RESETTEN. Zudem ist darauf zu achten, daß RXENAB und TXENAB, sind bei HI aktiv, einen STROM brauchen. Laut Datenblatt 3 mA. Es ist also keine "CMOS-Logic" Ansteuerung. Solltest Du also Spannungsteiler vorsehen, um den 5-V Prozessor auf die 3,3 V Pegel des RFM12BP zu bringen, so ist das bei RX/TXENAB nicht brauchbar. Hier nur ggf. eine Strombegrenzungswiderstand vorzusehen. 2k2 sind ok. In Gegenrichtug, also vom RFM zum uP sollte zudem bei der nIRQ und bei der SDO Leitung kein "Spannungsteiler" vorgesehen sein, sondern nur ein Serien-Rm, z.B,. 2k2. Hast Du das System mit einem "normalen" RFM12B getestet? Ich hoffe, das hilft weiter...
:
Bearbeitet durch User
Hanns-Jürgen "Yogy" Mostert schrieb: > ICh habe RFM12B und RFM12BP laufen. Dann werde ich mich zunächst mal an Dich halten, falls nichts dagegen spricht. > Hast Du das System mit einem "normalen" RFM12B getestet? Nein. Ich habe nur die RFM12BP und stehe damit "funk-und programmiertechnisch" noch am Anfang. > Solltest Du also Spannungsteiler vorsehen, um den 5-V Prozessor auf die > 3,3 V Pegel des RFM12BP zu bringen..... Verwendet wird als µC ein MSP430F1611, sodass das gesamte System mit 3V betrieben werden kann. Leider kann ich mich aus Zeitmangel in nächster Zeit nicht mit den RFM12BP beschäftigen und werde mich zu gegebener Zeit wieder melden.
okay, frage dann mal ruhig. BTW: Hast Du ein Oszilioskop? Und hat Dein Prozessor eine HW-SPI-Schnittstelle? Ich kenn ihn nicht...
Hanns-Jürgen "Yogy" Mostert schrieb: > okay, frage dann mal ruhig. BTW: Hast Du ein Oszilioskop? Und hat Dein > Prozessor eine HW-SPI-Schnittstelle? Ich kenn ihn nicht... Ja, Oszi ist vorhanden MSP430F1611 hat HW-SPI-Schnittstelle (aber nur 8?- BIT Zeichen können damit übertragen werden) Wie schon mal gesagt, hätte ich besonderes Interesse an einem funktionierenden Programmschnipsel jeweils für den Sender und den Empfänger. Dabei würde ich zunächst Wert auf die Initialisierung und das Senden bzw. Empfangen eines einzelnen Zeichens legen. (analog meines im ersten Beitrag angehängtem Programmausschnitt) SW-SPI wollte ich beibehalten, da damit 16Bit Befehle übertragen werden können. Die Zeile: if (P5IN & BIT2 == BIT2) wurde geändert in: if ((P5IN & BIT2) == BIT2) //prüft, ob an P5.2 H anliegt
So...zur SPI-Schnittstelle. Natürlich überträgt die byteweise. Also werden immer 2 byte übertragen. Vor der Übertragung nSS auf Low, danach auf Hi. Das funzt wünderbar. Bei mir clockt die SPI mit 125 kbaud, Clock low when idle, sampling on leading edge, MSBit first. Deine SW-Emulation sieht für mich ok aus. Für die Initialisierung der RFM-BP sind RX-Enab und TX-Enab auf low (also abgeschaltet) (P2.2, P2.3., wie ich Deiner Schaltung entnehme. Ich nehme auch mal an, die Antenne ist angeklemmt (8,5 cm langer Draht).. Ich will Deine Init und meine nicht im einzelnen vergleichen. Ich arbeite z.Zt. mit 9600 bd und habe auch eine andere Frequenz. Bei mir arbeiten die Module im Halbduplex: Grundprinzip: nach Power-Up wird das Modul initialisiert. Anschließend wird es in den Receive Mode versetzt. ... Soll etwas gesendet werden, wird das Modul in den Sendemodus geschaltet, Die Daten werden ausgesendet Anschließend wird das Mopdul wieder in den Receive-Mode versetzt. Bei mir geschieht das alles im Interrupt, geht aber auch mit Polling des nIRQ-Pins. Nun mein Sourcecode (gekürzt) Initialisierung:
1 | // Die Groesse "nr" gibt die nr. des Moduls an, da ich in der ersten
|
2 | // Testphase zwei Module am selben uP verwendet habe.
|
3 | // Also don't care bzw. mit 0 gleichsetzen.
|
4 | |
5 | void Init_RFM12B(U8 nr) |
6 | {
|
7 | |
8 | |
9 | U16 iHelp = 0; |
10 | PortRFM12 &= ~(1 << RFM_POWER_RXE_0); // Schalte RX- und TX Enab auf LOW |
11 | PortRFM12 &= ~(1 << RFM_POWER_TXE_0); |
12 | |
13 | Write_Word_RFM12B(0x80E7,nr); // 868 Band, TX u Fifo on, Cap |
14 | |
15 | Write_Word_RFM12B(0x82D9,nr); // RX ein, DCLK aus, baseband/xtal ein |
16 | |
17 | Write_Word_RFM12B(0xA660,nr); // Frequ = def = 868,32 |
18 | |
19 | // Write_Word_RFM12B(0xC647,nr); // Datenrate 4800
|
20 | Write_Word_RFM12B(0xC623,nr); // Datenrate 9600 = 1000000/29/(wert+1) (Bit 7 muss hier 0) |
21 | // Write_Word_RFM12B(0xC611,nr); // Datenrate 19200 = 1000000/29/(wert+1) (Bit 7 muss hier 0)
|
22 | |
23 | Write_Word_RFM12B(0x94A4,nr); // |
24 | // data filter:
|
25 | Write_Word_RFM12B(0xC2AC,nr); // |
26 | // fifo reste mode cmd:
|
27 | Write_Word_RFM12B(0xCA81,nr); // FIFO IRQ Level = 8, Synchron-Pattern 0x2DD4 (2 bytes!) |
28 | // AFC Command
|
29 | Write_Word_RFM12B(0xC483,nr); // AFC enab |
30 | |
31 | // TX-Control reg
|
32 | Write_Word_RFM12B(0x9857,nr); // 90 khz Modulation, die 3 LSB sind für Power. -21 dB |
33 | // Wake Up timer
|
34 | Write_Word_RFM12B(0xE000,nr); // disabled |
35 | // Low Duty Cycle
|
36 | Write_Word_RFM12B(0xC800,nr); // disabled |
37 | // Low Batt Detector etc
|
38 | Write_Word_RFM12B(0xC000,nr); // disabked |
39 | //Status Read
|
40 | Write_Word_RFM12B(0x0000,nr); // lese Status/loescht IRQ |
41 | Write_Word_RFM12B(0x0000,nr); // lese Status/loescht IRQ |
42 | |
43 | }
|
44 | |
45 | //Umschalten auf Receivemodus:
|
46 | void Set_Receive_RFM12B(U8 nr) |
47 | {
|
48 | |
49 | U8 cnt = 0; |
50 | cnt = sys_tick_1ms + 2; // Warteschleife 2...3 ms |
51 | PortRFM12 &= ~(1 << RFM_POWER_TXE_0); |
52 | PortRFM12 |= (1 << RFM_POWER_RXE_0); |
53 | // RX, Basisband, XC-Osc on, bat-det, TX etc off
|
54 | Write_2Bytes_RFM12B(0x82,0xC8,nr); |
55 | // FIFO ein u. RESET, IRQ ein, Syncbyte enab (0x2DD4)
|
56 | Write_2Bytes_RFM12B(0xCA,0x83,nr); |
57 | //Achtung: wird /SS angelegt, bleibt das SPI-Signal
|
58 | //solange low, bis ein Byte breitsteht.
|
59 | |
60 | while (cnt != sys_tick_1ms) |
61 | WATCHDOG(); |
62 | ;
|
63 | |
64 | }
|
65 | // Anmerkung: Write_2Bytes_RFM12B(a,b,nr) ist identisch zu
|
66 | // Write_Word_RFM12B(((a << 8) | b),nr)
|
67 | |
68 | //Umschalten auf Sendsmodus:
|
69 | |
70 | void Set_Send_RFM12B(U8 nr) |
71 | {
|
72 | U8 cnt = 0; |
73 | EIMSK &= ~(1 << RFM_INT); //disable IRQ |
74 | cnt = sys_tick_1ms + 3; // Warteschleife 2...3 ms |
75 | PortRFM12 &= ~(1 << RFM_POWER_RXE_0); |
76 | PortRFM12 |= (1 << RFM_POWER_TXE_0); |
77 | nr &= 1; |
78 | Write_Word_RFM12B(0x9857,nr); // 90 khz Modulation, die 3 LSB sind für Power. -21 dB |
79 | // Sender, Synthesizer und Quatz-Oszi einschalten
|
80 | Write_2Bytes_RFM12B(0x82,0x38,nr); |
81 | while (cnt != sys_tick_1ms) |
82 | WATCHDOG(); |
83 | ;
|
84 | }
|
Das Aussenden einer Nachricht: Zum Senden eines Bytes muß auf den Interrupt (nIRQ) bzw dessen "Low" gewartet werden.
1 | //Das Senden beginnt wie Du richtig dargestellt hast durch:
|
2 | SPI_Config_CMD_16Bit(0xB8AA); |
3 | SPI_Config_CMD_16Bit(0xB8AA); |
4 | SPI_Config_CMD_16Bit(0xB8AA); |
5 | // Anschließend folgen die Synchronbytes: (bei Dir "disabled")
|
6 | SPI_Config_CMD_16Bit(0xB82D); |
7 | SPI_Config_CMD_16Bit(0xB8D4); |
8 | // Nun folgen die eigentlichen NAchrichtenbytes
|
9 | SPI_Config_CMD_16Bit(0xB8<databayte>); |
10 | // Am Ende der Nchricht sende ich nochmal:
|
11 | SPI_Config_CMD_16Bit(0xB8AA); |
12 | SPI_Config_CMD_16Bit(0xB8AA); |
13 | |
14 | // ... die ich auf der Empgangsseite dann verwerfe. Sie dienen nur
|
15 | // einer sauberen IRQ-Generierung (bei mir)
|
16 | |
17 | // Danach folgt:
|
18 | |
19 | Set_Receive_RFM12B(0); |
Die Empfangsroutine einer Nachricht: Sobald ein nIRQ vorliegt, wird ein Nachrichtenbyte ausgelesen. In Deiner Notation sähe das wie folgt aus:
1 | U8 Read_1Byte_RFM12B(U8 nr) |
2 | {
|
3 | U8 data; |
4 | data = (U8) (SPI_Config_CMD_16Bit(0xB000) & 0xff); |
5 | return data; // Die Date wird in den unteren 8 bits zurückgegeben. |
6 | }
|
So müßte es "eigentlich" funktionieren. Good Luck
@Yogy, zunächst vielen Dank für die Programmschnipsel, welche mir sehr geholfen haben. Die Funkübertragung funktioniert jetzt. Damit ist das 1.Ziel erreicht und auch der Beweis erbracht, dass die verwendeten Funkmodule funktionstüchtig sind. Z. Zt. gibt es bei der Funkübertragung allerdings noch Aussetzer, aber, so hoffe ich, dass diese sich noch beseitigen lassen. Noch eine Frage zu den Befehlen: // Anschließend folgen die Synchronbytes: SPI_Config_CMD_16Bit(0xB82D); SPI_Config_CMD_16Bit(0xB8D4); Was soll damit bewirkt werden? MfG
wolle g. schrieb: > Noch eine Frage zu den Befehlen: > // Anschließend folgen die Synchronbytes: > SPI_Config_CMD_16Bit(0xB82D); > SPI_Config_CMD_16Bit(0xB8D4); > > Was soll damit bewirkt werden? Die Kombination 0x2D, 0xD4 sorgt für die "Scharfschaltung" des FIFO-Puffers im Empfänger. Erst nachdem der Empfänger dieses Schlüsselwort gesehen hat, beginnt er, die ankommenden Daten zu erfassen.
@Wolle: schön, daß ich helfen konnte. Deine Frage nach den Synchronbytes hat Felix schon beantwortet. Schönes WE yogy
Bitte 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.