Einfaches Testprogramm für RFM12BP-868MHz

vielleicht hilft der "Schaltplan" weiter

vielleicht hat doch noch jemand einen Tipp

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...

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