Forum: HF, Funk und Felder Einfache Funkbrücke mit RFM12 und ATmega16


Einfache Funkbrücke mit RFM12 und ATmega16
von Ti B. (duriel)

Angehängte Dateien:
Lesenswert?
• ▲
▼ 
Hi erstmal,

bin noch ganz neu im Forum und auch Anfänger in Sachen Mikrocontroller, 
leider hab ich gemerkt dass dieses Forum scheinbar seine Sensibilität 
für Anfänger verloren hat, ich stell euch trotzdem mein Anliegen.
Ich hab mir für die RFM12 Module den Code von Julian Portik auf 
http://www.julian-portik.de geholt und hab versucht ihn auf meine 868 
Mhz Module umzuschreiben.

Generell hab ich mich an den Aufbauplan im Anhang gehalten, außer dem 
ISP zum Pc, stattdessen wollte ich ein einfaches Signal schicken, der 
anstatt einer grün leuchtenden LED eine rote leuchten lässt.
Hab versucht mir den Code so weit ich konnte zu kommentieren, aber bin 
leider an einem Punkt wo ich nicht weiter komme.

Beide Schaltungen habe ich mit getrennten Spannungsversorgungen 
aufgebaut, die uC´s laufen mit 5 V, die RFMs mit 3,3V.

Leider funktioniert es bei mir nicht, ich kann aber auch nicht sagen 
woran es liegt, möglich wäre:
1. Falsche Initialisierung der RFMs (868, anstatt 433 MHZ) weiß leider 
nicht genau, auf was es alles ankommt, hab mit Funk keine Erfahrung
2. Code ist falsch für den uC ausgelegt, im Bspl.Code wurde ein ATmega8 
verwendet, ich versuch es mit einem ATmega16
3. Mein Code ist einfach falsch aufgebaut. Ich hab die RFM12_send 
Funktion verändert, in ein int, weiß nicht ob das richtig ist, weiß auch 
gar nicht ob der Code prinzipiell richtig aufgebaut ist für das 
Umschalten auf die rote LED... Ich verstehe auch nicht ganz was der 
main.h Header macht ..

Ich hoffe es könnte sich jemand die Zeit nehmen sich mein Problem 
vielleicht mal anzuschauen.

Vielen Dank im Vorraus!

Ursprungscode stammt von Julian Portik

RFM12.h
1
#ifndef RFM12_H_

2
#define RFM12_H_

3
4
5
#define RFM12_SEL_port  PORTD

6
#define RFM12_SEL_pin  PIND

7
#define RFM12_SEL_dir  DDRD

8
#define RFM12_SEL_bit  3

9
#define RFM12_SEL_on()  clear_bit  (RFM12_SEL_port,  RFM12_SEL_bit)

10
#define RFM12_SEL_off()  set_bit    (RFM12_SEL_port,  RFM12_SEL_bit)

11
12
#define RFM12_SCK_port  PORTD

13
#define RFM12_SCK_pin  PIND

14
#define RFM12_SCK_dir  DDRD

15
#define RFM12_SCK_bit  2

16
#define RFM12_SCK_on()  set_bit    (RFM12_SCK_port,  RFM12_SCK_bit)

17
#define RFM12_SCK_off()  clear_bit  (RFM12_SCK_port,  RFM12_SCK_bit)

18
19
#define RFM12_SDI_port  PORTC

20
#define RFM12_SDI_pin  PINC

21
#define RFM12_SDI_dir  DDRC

22
#define RFM12_SDI_bit  5

23
#define RFM12_SDI_on()  set_bit    (RFM12_SDI_port,  RFM12_SDI_bit)

24
#define RFM12_SDI_off()  clear_bit  (RFM12_SDI_port,  RFM12_SDI_bit)

25
26
#define RFM12_SDO_port  PORTC

27
#define RFM12_SDO_pin  PINC

28
#define RFM12_SDO_dir  DDRC

29
#define RFM12_SDO_bit  2

30
31
#define  RFM12_IRQ_port  PORTC

32
#define  RFM12_IRQ_pin  PINC

33
#define  RFM12_IRQ_dir  DDRC

34
#define  RFM12_IRQ_bit  3

35
36
#define RFM12_command_CONF  0b1000000000000000  //  Grundkonfiguration ;; LATCH ;; FIFO ;; BAND ;; BALLASTKONDESATOR FÜR QUARTZ

37
#define RFM12_command_PWR  0b1000001000000000  //  Komponentenauswahl ;; Empfängertrakt ein/ausschalten ;; Basisband ;; Transmitter ;; synth ;; Quartz-Oszi ;; Betriebsspannungsüberwachung   ;; Wake-Up    ;; Clock

38
#define RFM12_command_FREQ  0b1010000000000000  //  Frequenzeinstellung 

39
#define RFM12_command_PLL   0b1100110000000000  //   Taktgenerator-Einstellungen ;; Treiberstärke ;; Low-Power Mode für Quarz ;; delay ;; dithering ;; Bandbreite

40
#define RFM12_command_DTRT  0b1100011000000000  //  Bitrate         ;; Vorteiler  ;; Bitratenteilerfaktor

41
#define RFM12_command_RXCT  0b1001000000000000  //  Empfängersteuerung ;; pin int/vdi ;; Definiert Geschwindigkeit ;; Bestimmt die Bandbreite des Empfängers ;; Verstärkungsfaktor des UHF-Verstärkers ;; Relative Empfangsfeldstärke 

42
#define RFM12_command_DFLT  0b1100001000000000  //  Empfangsdatenrekonstruktion ;; Bittakt-Rekonstruktion ;; Typ des Datenfilters(dig/ana) ;; Bestimmt den Schwellwert, ab dem ein Signal als gut befunden wird

43
#define RFM12_command_FFRM  0b1100101000000000  //  FIFO-Steuerung     ;; Füllstand interrupt steuerung ;; Länge des Synchronmusters ; Legt fest ab wann FIFO füllt ;; Freigabe FIFO ;; Power-On-Reset

44
#define RFM12_command_RXFR  0b1011000000000000  //  Empfänger-FIFO lesen

45
/*

46
Empfänger FIFO lesen

47
Byte  MSB              LSB                Vorgabe

48
Bit  15  14  13  12  11  10  9  8  7  6  5  4  3  2  1  0

49
?  1  0  1  1  0  0  0  0  0  0  0  0  0  0  0  0  0xB000

50
51
 ___ _                                                                                  __

52
 SEL  \________________________________________________________________________________/  \___|?|__________________

53
 _   _   _   _   _   _   _   _    __    __    __    __    __    __    __    __              _   _   _   _

54
 SCK ___/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \_______|?|__/ \_/ \_/ \_/ \_

55
 _____     _______                        ggf. reduzierte Schiebetaktfrequenz      _______   ____     _______

56
 SDI _/   \___/  0xB0 \_______________________________________________________________/_______|?|/   \___/  0xB0 \_

57
 ________________________________ _____ _____ _____ _____ _____ _____ _____ _____ _       ____________________

58
 SDO -________________________________X_____X_____X_____X_____X_____X_____X_____X_____X_---___/?

59
 FFIT (sollte HIGH sein)         D7    D6    D5    D4    D3    D2    D1    D0   D?      ??Interrupt

60
61
 D?  = FIFO ist vom Fall-Through-Typ; ungültig oder nächstes Datenbit wenn nicht leer

62
 |?| = warten bis SDO = HIGH (nicht auf die L-H-Flanke, diese könnte ausbleiben!)

63
 --- = Tristate, der Bus-Holder hält den Ausgang auf den letzten Pegel fest

64
 */

65
#define RFM12_command_AFC  0b1100010000000000  //  Automatische Frequenznachregelung ;; Modus der AFC-Schaltung ;; Ziehfrequenzbegrenzung ;; Genauer Berechnungsmodus ;; AFC-Offset freischalten ;; AFC-Berechnung aktivieren

66
#define RFM12_command_TXCC  0b1001100000000000  //  TX Senderkonfiguration ;; Richtung der FSK-Erzeugung ;; Frequenzhub ;; relative Ausgangsleistung des Senders 

67
#define RFM12_command_TXRW  0b1011100000000000  //  Senderegister schreiben 

68
/*

69
Senderegister schreiben 

70
 ___ _                                                                                                                                          _

71
 SEL  \_________________________________________________________________|?|_________________________________|?|________________________________/

72
 _   _   _   _   _   _   _   _    _   _   _   _   _   _   _   _       _   _   _   _   _   _   _   _       _   _   _   _   _   _   _   _

73
 SCK __/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \__/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_|?|_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_|?|_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \__

74
 __     ___________              ___ ___ ___ ___ ___ ___ ___ _____    ___ ___ ___ ___ ___ ___ ___ ___     ___ ___ ___ ___ ___ ___ ___ ___

75
 SDI _/  \___/  = B 8    \____________/___X___X___X___X___X___X___X_____|?|X___X___X___X___X___X___X___X___X|?|X___X___X___X___X___X___X___X___\_

76
 __________________________________________                          ___________                         ___________

77
 SDO -          = RGIT                          \\\\\____________________/           \\\\\___________________/           \\\\\__________________-

78
79
 |?| = warten bis SDO ? wieder HIGH wird, bspw. per Interrupt

80
*/

81
#define RFM12_command_WAKE  0b1110000000000000  //  Zeitgeber für Wake-Up ;; radix ;; mantissa 

82
#define RFM12_command_LDC  0b1100100000000000  //  Automatisch zyklischer Empfänger ;; Einschaltdauer während der zyklischen Einschaltung ;; Zyklische Einschaltung aktivieren

83
#define RFM12_command_BDCD  0b1100000000000000  //  Unterspannungs-Detektor und Taktausgangsteiler ;; Bestimmt den Teilungsfaktor für die Taktausgabe am CLK-Anschluss ;; Bestimmt die Betriebsspannung, bei der der RFM12 einen Unterspannungs-Interrupt auslöst.

84
#define RFM12_command_STAT  0b0000000000000000  //  Status lesen ;; 

85
86
#define RFM12_PWR_off  RFM12_command (RFM12_command_PWR  |  0b00000001); //Deaktiviert die Ausgabe des Taktes auf dem CLK Ausgang (1 = LOW)

87
#define RFM12_TX_on    RFM12_command (RFM12_command_PWR  |  0b00111001); //Sendertrakt komplett einschalten ;; PLL-Synthesizer einschalten ;; Quarz-Oszillator ein

88
#define RFM12_TX_off  RFM12_command (RFM12_command_PWR  |  0b00000001); 

89
#define RFM12_RX_on    RFM12_command (RFM12_command_PWR  |  0b11011001); //Empfänger-Trakt komplett einschalten ;;Basisband-Empfangsteil einschalten ;; Synth ;; quartz

90
#define RFM12_RX_off  RFM12_command (RFM12_command_PWR  |  0b00011001);

91
#define RFM12_FIFO_on  RFM12_command (RFM12_command_FFRM  |  0b10000011); //8 Bit Füllstand (Interrupt bei vollem Byte) ;; FIFO freigeben ;; Abschalten des Power-On-Resets

92
#define RFM12_FIFO_off  RFM12_command (RFM12_command_FFRM  |  0b10000001); //8 Bit Füllstand ;; Abschalten Power-On-Reset

93
#define RFM12_AFC_on  RFM12_command (RFM12_command_AFC  |  0b01000011); //Automatische Frequenznachregelung ;; Modus der AFC-Schaltung ( 10 = Solange VDI low ist) ;; AFC-Offset freischalten ;; AFC-Berechnung aktivieren

94
#define RFM12_AFC_off  RFM12_command (RFM12_command_AFC  |  0b01000010); //Automatische Frequenznachregelung ;; Modus der AFC-Schaltung ( 10 = Solange VDI low ist) ;; AFC-Offset freischalten

95
96
void      RFM12_init    ();            // Modul initialisieren

97
unsigned int  RFM12_command  (unsigned int cmd);    // 

98
void      RFM12_send    (unsigned int byte);  // Senden

99
unsigned int  RFM12_receive  ();            // Empfangen

100
101
/* Ursprungscode

102
void      RFM12_send    (unsigned char byte);  // Senden

103
unsigned char  RFM12_receive  ();            // Empfangen

104
*/

105
106
#endif /* RFM12_H_ */


main.h

1
#ifndef MAIN_H_

2
#define MAIN_H_

3
4
#define   set_bit(var, bit)   ((var) |= (1 << (bit)))

5
#define   clear_bit(var, bit)   ((var) &= (unsigned)~(1 << (bit)))

6
7
//#define loop_until_bit_is_set(sfr, bit) do { } while (!check_bit(sfr, bit))

8
//#define loop_until_bit_is_clear(sfr, bit) do { } while (check_bit(sfr, bit))

9
10
int check_bit (unsigned int Port_Pin, unsigned int Port_Bit)

11
12
{

13
  

14
  if ( Port_Pin & ( 1 << Port_Bit ) )

15
  {

16
    return 1;

17
  }

18
  

19
  else

20
  

21
  {

22
    return 0;

23
  }

24
  

25
}

26
27
28
#endif /* MAIN_H_ */


Code fuer Sender
1
#define F_CPU 4000000L

2
3
#include <avr/io.h>

4
#include <util/delay.h>

5
#include "RFM12.h"

6
#include "main.h"

7
8
// CODE FUER TESTSENDER

9
10
void RFM12_init ()      // Modul initialisieren

11
{

12
  RFM12_SEL_off ();

13
  RFM12_SDI_on ();

14
  RFM12_SCK_off ();

15
  

16
  set_bit (RFM12_SEL_dir, RFM12_SEL_bit);    //  SEL = Output ;; (DDRD , 3)

17
  set_bit (RFM12_SDI_dir, RFM12_SDI_bit);    //  SDI = Output ;; (DDRC , 5)

18
  clear_bit (RFM12_SDO_dir, RFM12_SDO_bit);  //  SDO = Input  ;; (DDRC , 2)

19
  set_bit (RFM12_SCK_dir, RFM12_SCK_bit);    //  SCK = Output ;; (DDRD , 2)

20
  

21
  clear_bit (RFM12_IRQ_dir, RFM12_IRQ_bit);  //  IRQ = Input  ;; (DDRC , 3)

22
  

23
  RFM12_PWR_off; //Deaktiviert die Ausgabe des Taktes auf dem CLK Ausgang (1 = LOW)

24
  

25
  RFM12_command (RFM12_command_FREQ  |  400);      //  Frequenzsteuerbyte ;; Frequenz festgelegt auf 862 MHZ (siehe Formel)

26
  RFM12_command (RFM12_command_DTRT  |  36);      //  Datenrate 9600 kbps

27
  RFM12_command (RFM12_command_CONF  |  0b11101000);  //  Modul initialisieren ;; Latch ein ;; Puffer ein ;; 868 MHZ ;; Ballastkondensator 12,5pF

28
  RFM12_command (RFM12_command_RXCT  |  0b10010100000);  //  Empfänger konfigurieren

29
  RFM12_command (RFM12_command_DFLT  |  0b10101100);  //  Empfangsdatenrekonstruktion

30
  RFM12_command (RFM12_command_TXCC  |  0b001010000);  //  Sender konfigurieren

31
  RFM12_command (RFM12_command_PWR  |  0b11111000);    //  Komponentenauswahl 

32
  

33
  RFM12_FIFO_on;    //FIFO einschalten

34
  RFM12_AFC_on;    //Automatische Frequenzkontrolle einschalten

35
  RFM12_command (RFM12_command_STAT);  //Statusregister einmal abfragen (bei manchen Revisionen wohl notwendig)

36
}

37
38
unsigned int RFM12_command (unsigned int command)

39
{

40
  unsigned int serial_data = 0;

41
  

42
  RFM12_SEL_on ();    //SELECT-Leitung für das Modul einschalten

43
  

44
  for (unsigned char i = 0; i < 16; i++)  //Jedes Bit mit dieser Schleife übertragen

45
  {

46
    if (command & 0x8000) //Alle Bits bis auf das Vorderste ausblenden und bei 1 SDI einschalten

47
    

48
    RFM12_SDI_on (); 

49
  

50
    else

51
    

52
     RFM12_SDI_off (); 

53
     

54
    command <<= 1;    //Alle Bits nach links schieben

55
    

56
    RFM12_SCK_on ();    //SCK ein 

57
    

58
    serial_data <<= 1;

59
    if (check_bit(RFM12_SDO_pin, RFM12_SDO_bit)) //Kommen Daten vom Modul zurück? (z.B. bei Statusregister oder Empfängerabfrage)

60
    

61
    serial_data |= 0x0001;  

62
    _delay_us(1);

63
    

64
    RFM12_SCK_off ();   //SCK aus

65
  }

66
  

67
  RFM12_SEL_off ();    //Alle 16 bit übertragen / empfangen, SELECT Leitung ausschalten

68
  

69
  return serial_data;     //Falls etwas vom Modul zurück gegeben wurde, liefert die Funktion die Daten zurück

70
}

71
72
void RFM12_send (unsigned int senden) //geändert von char senden

73
{

74
  loop_until_bit_is_clear (RFM12_IRQ_pin, RFM12_IRQ_bit);  //Warten, bis Sender bereit

75
  RFM12_command (RFM12_command_TXRW | senden);      //Daten an das Modul senden

76
}

77
78
unsigned int RFM12_receive () //geändert von char

79
{

80
  loop_until_bit_is_clear (RFM12_IRQ_pin, RFM12_IRQ_bit);  //Auf Daten warten

81
  RFM12_command (RFM12_command_STAT);            //Daten auslesen

82
  return RFM12_command (RFM12_command_RXFR) & 0x00FF;    //Daten zurückgeben

83
}

84
85
int main(void)

86
{

87
  _delay_ms(250);      //Kurz warten mind. 100 ms laut Datenblatt bis uC bereit

88
  RFM12_init();      //Modul initialisieren

89
  _delay_ms(250);      

90
  RFM12_init();      // Doppelt initialisieren

91
  

92
  uint8_t led = 0xFF;

93
  while(1)

94
  {

95
    RFM12_command (RFM12_command_STAT);      //Kurz Statusregister abfragen

96
    RFM12_TX_on;                //Sendetrakt einschalten

97
    

98
    RFM12_send (0xAA);              //Taktregenerierung erleichtern 0xAA entspricht 10101010 damit hoher Flankenwechsel

99
    RFM12_send (0xAA);              //Taktregenerierung erleichtern

100
    RFM12_send (0xAA);              //Taktregenerierung erleichtern

101
    RFM12_send (0x2D);              //Synchronmuster  (0x2DD4)            

102
    RFM12_send (0xD4);              //Synchronmuster  ..

103
    

104
    //########################    Test    ###############################

105
    

106
    

107
    RFM12_send (led) ;      

108
    

109
//    led = (led << 1) ;

110
    

111
//    if (led == 0xFF)

112
//      led = 0x01;

113
    loop_until_bit_is_clear (RFM12_IRQ_pin, RFM12_IRQ_bit); 

114
    

115
    //########################    Ende    ###############################

116
    

117
    /*      Eigentlicher Programmcode

118
    RFM12_send (0x41);              //Eigentliches Datenbyte

119
    loop_until_bit_is_clear (RFM12_IRQ_pin, RFM12_IRQ_bit);   //Warten, bis der Sendevorgang abgeschlossen ist

120
    //loop_until.. vor neuem Sendevorgang abgeben

121
          Ende 

122
    */

123
    

124
    _delay_ms(10);                        //Nochmal kurz warten

125
    RFM12_TX_off;                        //Sendetrakt ausschalten

126
    _delay_ms (1000);

127
  }

128
}


Code fuer Empfaenger

1
#define F_CPU 4000000L

2
3
#include <avr/io.h>

4
#include <util/delay.h>

5
#include "RFM12.h"

6
#include "main.h"

7
8
// CODE FÜR TESTEMPFÄNGER

9
10
#define BAUD 9600L

11
12
#define UBRR_VAL ((F_CPU+BAUD * 8)/(BAUD*16)-1)    //clever runden

13
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))      //reale Baudrate

14
15
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000)    //Fehler in Promille

16
17
#if ((BAUD_ERROR>10)||(BAUD_ERROR<-10))

18
#error Systematischer Fehler in der Baudrate größer 1% und damit zu hoch!

19
#endif

20
21
22
23
void RFM12_init ()

24
{

25
  RFM12_SEL_off ();

26
  RFM12_SDI_on ();

27
  RFM12_SCK_off ();

28
  

29
  set_bit (RFM12_SEL_dir, RFM12_SEL_bit);    //  SEL = Output

30
  set_bit (RFM12_SDI_dir, RFM12_SDI_bit);    //  SDI = Output

31
  clear_bit (RFM12_SDO_dir, RFM12_SDO_bit);  //  SDO = Input

32
  set_bit (RFM12_SCK_dir, RFM12_SCK_bit);    //  SCK = Output

33
  

34
  clear_bit (RFM12_IRQ_dir, RFM12_IRQ_bit);  //  IRQ = Input

35
  

36
  RFM12_PWR_off;    //Deaktiviert die Ausgabe des Taktes auf dem CLK Ausgang (1 = LOW)

37
  RFM12_command (RFM12_command_FREQ  |  400);      //  Frequenzsteuerbyte ;; Frequenz festgelegt auf 862 MHZ (siehe Formel)

38
  RFM12_command (RFM12_command_DTRT  |  36);      //  Datenrate 9600 kbps

39
  RFM12_command (RFM12_command_CONF  |  0b11101000);  //  Modul initialisieren ;; Latch ein ;; Puffer ein ;; 868 MHZ ;; Ballastkondensator 12,5pF

40
  RFM12_command (RFM12_command_RXCT  |  0b10010100000);  //  Empfänger konfigurieren

41
  RFM12_command (RFM12_command_DFLT  |  0b10101100);  //  Empfangsdatenrekonstruktion

42
  RFM12_command (RFM12_command_TXCC  |  0b001010000);  //  Sender konfigurieren

43
  RFM12_command (RFM12_command_PWR  |  0b11111000);  //  Komponentenauswahl 

44
  

45
  RFM12_FIFO_on;    //FIFO einschalten

46
  RFM12_AFC_on;    //Automatische Frequenzkontrolle einschalten

47
  RFM12_command (RFM12_command_STAT);  //Statusregister einmal abfragen (bei manchen Revisionen wohl notwendig)

48
}

49
50
unsigned int RFM12_command (unsigned int command)

51
{

52
  unsigned int serial_data = 0;

53
  

54
  RFM12_SEL_on ();

55
  

56
  for (unsigned char i = 0; i < 16; i++)

57
  {

58
    

59
    if (command & 0x8000) RFM12_SDI_on (); else RFM12_SDI_off ();

60
    command <<= 1;

61
    

62
    RFM12_SCK_on ();

63
    

64
    serial_data <<= 1;

65
    if (check_bit(RFM12_SDO_pin, RFM12_SDO_bit)) serial_data |= 0x0001;

66
    _delay_us(1);

67
    RFM12_SCK_off ();

68
  }

69
  

70
  RFM12_SEL_off ();

71
  

72
  return serial_data;

73
}

74
75
void RFM12_send (unsigned int senden) //geändert von char

76
{

77
  loop_until_bit_is_clear (RFM12_IRQ_pin, RFM12_IRQ_bit);  //wait for previously TX over

78
  RFM12_command (RFM12_command_TXRW | senden);

79
}

80
81
unsigned int RFM12_receive () // geändert von Char

82
{

83
  loop_until_bit_is_clear (RFM12_IRQ_pin, RFM12_IRQ_bit);  //wait for data

84
  RFM12_command (RFM12_command_STAT);

85
  return RFM12_command (RFM12_command_RXFR) & 0x00FF;

86
}

87
88
int main(void)

89
{

90
  int Puffer_led = 0x00 ; 

91
  

92
  UBRRH = UBRR_VAL >> 8;

93
  UBRRL = UBRR_VAL & 0xFF;

94
  UCSRB = (1<<RXEN)|(1<<TXEN);          //UART TX einschalten

95
  UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);    //Asynchron 8N1

96
  

97
  _delay_ms(250);

98
  RFM12_init();

99
  _delay_ms(250);

100
  RFM12_init();

101
  

102
  // Von mir verschoben

103
  /*

104
  RFM12_RX_on;

105
  RFM12_FIFO_off;

106
  RFM12_FIFO_on;

107
  */

108
  // ende

109
  

110
  //PORTA Ausgang und Ausgeschaltet

111
  DDRA = 0xFF;

112
  PORTA = 0x00;

113
  

114
  while(1)

115
  {

116
    while (!(UCSRA & (1<<UDRE))){}    //warten bis Senden möglich  ###### Ausgabe an serieller schnittstelle ######

117
      

118
    

119
    // ursprünglich hier

120
    RFM12_RX_on;

121
    RFM12_FIFO_off;

122
    RFM12_FIFO_on;

123
    //

124
    Puffer_led = RFM12_receive();

125
    

126
    if (Puffer_led < 15)

127
      {

128
        PORTA = 0b00000001;

129
      }

130
    else 

131
      {

132
        PORTA = 0b00000010;

133
      }

134
    

135
//    UDR = RFM12_receive();          //Empfangenes Bit auf die Schnittstelle schreiben

136
    

137
    RFM12_FIFO_off;

138
    RFM12_RX_off;

139
    

140
  }

141
}


  


  




  

    Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Einfache Funkbrücke mit RFM12 und ATmega16
  


  

    

      von
      
        Joachim B.
        (jar)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Timo Bordon schrieb:
> Ich hoffe es könnte sich jemand die Zeit nehmen sich mein Problem
> vielleicht mal anzuschauen.

ich bin da zu wenig firm um mich in fremden Code einzuarbeiten

aber vielleicht hilft dir das hier?

Ich habe die RFM RS232 Funkbrücke nachgebaut und es funktionierte auf 
Anhieb, bevor ich mögliche Fehler im fremden Code suche, schaust du dir 
eventuell nachweisslich funktionierenden an?

Beitrag "bidirektionale RS232 Funkbrücke mit RFM12"

nimm aber nicht gleich das erste zip File, sondern das letzte im Thread 
vom  Benedikt K.

beachte die Modulangaben 434MHz 868MHz die verschiedenen Inits und ich 
gehe von aus das du die Antenne angepasst hast zur Frequenz, auf 
Lambda/4

  


  



  

  
:
    Bearbeitet durch User
  

  


  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  








    

    

       Thread beobachten

      |
         Seitenaufteilung abschalten

    

        


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
  





  Noch kein Account? Hier anmelden.