Druckbare Version
Hi,
ich habe mir eine Schaltung mit einem RFM02 868 Modul und einem Attiny2313 aufgebaut.
Nur leider funktioniert nicht alles wie ich möchte (eigentlich garnichts xD).
Daher möchte ich Schritt für Schritt die Fehlerquellen streichen.
Wie kann ich prüfen, ob der RFM überhaupt sendet?
Gibt es irgendwie sowas wie einen Statusbericht des Moduls?
Wenn du einen alten Fernseher mit Antenne hast, kannst du ihn auf diese Frequenz einstellen. Das Bild sollte flackern, wenn was gesendet wird.
Ansonsten ist es verdammt schwer Fehler mit diesen Modulen zu finden. Ich selbst habe auch schon sehr viel Zeit damit verbracht, diese Module zu betreiben und habe sie schon soweit gebracht, dass wenigstens Müll empfangen wurde xD
Was für eine Lib zum Ansteuern benutzt du?
Ich benutze diesen Code
Eine Library die für das RFM02-868 nicht für das RFM12er Modul ist, hab ich bis jetzt nicht gefunden.Code:#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/eeprom.h>
#include <util/delay.h>
#include <stdlib.h>
#define BAUD 2400UL
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1) // clever runden
#define RFM02_CS PB5 // AVR MOSI
#define RFM02_SDI PB6 // AVR MISO
#define RFM02_SCK PB7 // AVR SCK
#define RFM02_IRQ PB0
#define RFM02_DDR DDRB
#define RFM02_PORT PORTB
#define RFM02_PIN PINB
void rfm02_init();
void rfm02_send_data(void);
uint8_t rfm02_send_cmd(uint16_t);
uint8_t rfm02_send_8bit(uint8_t);
void uart_putc(unsigned char c)
{
while (!(UCSRA & (1<<UDRE))); /* warten bis Senden moeglich */
UDR = c; /* sende Zeichen */
}
//######################################################################################################
void uart_puts( char * s )
{
while(*s)
{ /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */
uart_putc(*s);
s++;
}
}
void uart_init()
{
UCSRB |= (1<<RXEN);
UCSRB |= (1<<TXEN);
UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL;
}
char buffer = 'B';
void rfm02_init()
{
RFM02_PORT |= (1<<RFM02_IRQ) | (1<<RFM02_CS) | (1<<RFM02_SDI); // PullUp ein / Ausgang H
RFM02_DDR |= (1<<RFM02_CS) | (1<<RFM02_SCK) | (1<<RFM02_SDI); // Ausgänge
RFM02_DDR &= ~(1<<RFM02_IRQ); // Eingang
rfm02_send_cmd(0xCC00); // Status read
rfm02_send_cmd(0xC0E0); // Power Settings: Quarz ein, Synthesizer und PA ein bei Send-Command
rfm02_send_cmd(0xC220); //ENABLE BIT SYNC
rfm02_send_cmd(0x8883); // Control: 1MHz Clock Out, 12,5pF Last Quarz, 120kHz Shift
rfm02_send_cmd(0xA620); // Frequenz: 860MHz + (0,005 * 0x620) -> 867,84MHz
rfm02_send_cmd(0xB200); // Power 2 * -3dBm -> -6dBm
rfm02_send_cmd(0xD2C0); // Set PLL: set 33%
rfm02_send_cmd(0xC810); // Baudrate: 344827 / 19200 = 17 - 1 -> 0x10 // Status read
rfm02_send_cmd(0xE500 + 200); // WakeUp-Timer 2^7 *234ms ~ 30s ???!! nicht 1ms sondern 10ms !!???
rfm02_send_cmd(0xC002); // alles aus, WakeUp-Timer ein
rfm02_send_cmd(0xC440); // sleep, noch 64 Takte
}
uint8_t rfm02_send_cmd(uint16_t command)
{
uint8_t status;
RFM02_PORT &= ~(1<<RFM02_CS); // CS auf L
rfm02_send_8bit(command >> 8); // H-Byte senden
status = rfm02_send_8bit(command & 0xFF); // L-Byte senden
RFM02_PORT |= (1<<RFM02_CS); // CS auf H
return status;
}
//-----------------------------------------------------------------------------------------
uint8_t rfm02_send_8bit(uint8_t byte)
{
uint8_t i;
for (i=0; i<8; i++)
{
if (byte & 0x80)
{
RFM02_PORT |= (1<<RFM02_SDI); // DATA auf H als Ausgang
}
else
{
RFM02_PORT &= ~(1<<RFM02_SDI); // DATA auf L
}
asm("nop");
RFM02_PORT |= (1<<RFM02_SCK); // CLK auf H
asm("nop");
asm("nop");
byte = (byte << 1); // nächstes Bit nach oben
if (RFM02_PIN & (1<<RFM02_IRQ)) // unteres Bit Status einlesen, H?
{
byte |= 0x01; // DATA war H
}
else
{
byte &= ~(0x01); // DATA war L
}
asm("nop");
RFM02_PORT &= ~(1<<RFM02_SCK); // CLK auf L
}
return byte;
}
//-----------------------------------------------------------------------------------------
void rfm02_send_byte(uint8_t byte)
{
uint8_t i;
for (i=0; i<8; i++)
{
while (!(RFM02_PIN & (1<<RFM02_IRQ))) {
uart_putc('6');
} // warten bis IRQ L/H
while (RFM02_PIN & (1<<RFM02_IRQ)) {
uart_putc('7');
} // warten bis IRQ Impuls zuende H/L
if (byte & 0x80)
{
RFM02_PORT |= (1<<RFM02_SDI); // DATA auf H als Ausgang
}
else
{
RFM02_PORT &= ~(1<<RFM02_SDI); // DATA auf L
}
byte = (byte << 1); // Bit 7 rausschieben
}
uart_putc('1');
}
//-----------------------------------------------------------------------------------------
void rfm02_send_data()
{
uint8_t i;
rfm02_send_cmd(0xC0E0); // einschalten
RFM02_PORT &= ~(1<<RFM02_CS); // CS auf L
rfm02_send_8bit(0xC6); // Kommando Daten senden
rfm02_send_byte(0xAA); // Sync
rfm02_send_byte(0xAA);
rfm02_send_byte(0xAA);
rfm02_send_byte(0x2D); // Magic
rfm02_send_byte(0xD4);
rfm02_send_byte(buffer);
while (!(RFM02_PIN & (1<<RFM02_IRQ))) {
uart_putc('3');
}
// auf Ende sendes letztes Byte warten -> L/H
while (RFM02_PIN & (1<<RFM02_IRQ)) {
uart_putc('4');
} // erledigt, wenn IRQ wieder -> H/L
while (!(RFM02_PIN & (1<<RFM02_IRQ))) {
uart_putc('5');
} // auf Ende Power Off warten -> L/H
RFM02_PORT |= (1<<RFM02_CS); // CS auf H
rfm02_send_cmd(0xC002); // alles aus, WakeUp-Timer ein
rfm02_send_cmd(0xC440); // sleep, noch 64 Takte
}
int main(void) {
uart_init();
sei();
rfm02_init();
while(1) {
_delay_ms(100);
uart_putc('2');
rfm02_send_data();
}
return 0;
}
Hast du vielleicht einen Schaltplan von deinem µC+RFM?
Vielleicht sind bei mir da schon Fehler...
Im Anhang mal meiner.
Er bleibt bei mir immer in dieser Schleife hängen:
while (!(RFM02_PIN & (1<<RFM02_IRQ))) {
uart_putc('6');
} // warten bis IRQ L/H
Dieses Problem kenne ich, da hat bei mir nur mehrfaches neu starten des µCs geholfen, aber evtl. ist dein RFM auch falsch initialisiert.Zitat:
Er bleibt bei mir immer in dieser Schleife hängen:
while (!(RFM02_PIN & (1<<RFM02_IRQ))) {
uart_putc('6');
} // warten bis IRQ L/H
Schaltplan zum Anschließen unter meiner Website -> Zeitschalter (der sollte mal funkgesteuert werden, was nie funktioniert hat, aber der Schaltplan stimmt)
Sehr schön. Danke. Nun scheint er hoffentlich zu senden.
Hast du vielleicht noch ein Plan vom Empfänger?
Ich hab schon den Code (+Schaltung) probiert ( http://www.obersomer.com/furios-powe...d=77&Itemid=69 ).Jedoch lässt sich der Code nichtmal kompilieren.
Der Sender ist bei mir extern und der Empfänger (RFM12-868) soll erstmal ans stk500.
Sorry für Doppelpost, aber es scheint so, als ob ich es fast selbst gelöst habe.
Ich habe nun den Empfänger und den Sender soweit, dass sie irgendwas machen. Sie bleiben nirgends mehr stecken.
Das Problem ist aber, dass beim RFM12 (Empfänger) in der FIFO immer nur 0xFF drin steht. Auch wenn der Sender aus ist!
Woran kann das liegen?
Falls es dich interessiert, das ist der originale RFM Thread im microcontroller.net Forum (ja ist ein bisschen viel zu lesen, geb ich zu ;D):
http://www.mikrocontroller.net/topic/67273
Diese Lib von Benedikt benutze ich auch zum Ansteuern.
Woran das liegt, dass nichts Übertragen wird, kann niemand sagen, das ist das gemeine an diesen Dingern, man braucht viel Geduld und Zeit, um dem Fehler auf der Spur zu kommen, evtl. bietet der Thread im microcontroller.net Forum aber Hilfe an.
Als Anhang, Schaltplan für RFM01
Was ist denn das für ne Sender-Schaltung?
Die kann ja gar nicht funktionieren!
Schaltplan als .gif anhängen wäre fast sinnvoller; nicht jeder hat Eagle >4.60
(bei mir gehts z.B. nicht...)
Warum nicht?Zitat:
Was ist denn das für ne Sender-Schaltung?
Die kann ja gar nicht funktionieren!
1.) Der Sender kriegt ja gar kein Saft! Da kommt doch kein Vorwiderstand in die Leitung. Und wenn doch, dann ganz bestimmt kein 10k!!!
2.) Die LED1 wird so (wie eingezeichnet) auch nie leuchten (verpolt).
3.) Das Sendemodul muss per SPI konfiguriert werden, dazu muss nSel auf Low gezogen werden (vom Controller), damit das Modul weis, dass was ankommt. nSel hängt aber auf VCC. Das Modul wird nicht funktionieren!
4.) fehlende Junktion.
Über den Vorwiderstand sag ich mal nix. Weis ja nicht wasfür ne LED da rein soll. Üblicherweise bei Standart-Leds geht man von 10..15mA aus, das ergibt bei einer Durchlass-Spannung von 1,6V bei 3,3V ein R5= max. 170Ohm.
Weiter hab ich nicht kontrolliert. Schaus nochmal genau und kritisch an!
Mitch.
Du meintest meine Schaltung?
Oder die von _R2D2?
Hast du vielleicht einen funktionierenden Schaltplan?
(Falls du meinen meinst: Die LED wurde trotz falschem Schaltplan richtig eingesetzt und leuchtet mit dem eingezeichneten Widerstand)
Ich habe das mal auf meine Schaltung bezogen, aber nach genauerem überlegen, meint er wohl deine und hat Recht.
Schau dir lieber meinen Schaltplan nochmal an.
ich meine die: schaltung_rfm02.png
Ja die von dir.
Die LED ist im Schaltplan verpolt. hatte ich ja geschrieben. Dass sie trotzdem leutet ist auch ok und auch logisch. Sie leuchtet eben schwächer.
Funkt das teil denn überhaupt?
Keine Ahnung ob das funkt, dass ist ja Teil des Problems.
Man merkt ja nicht ob es sendet oder nicht...
So wie es in der Schaltung eingezeichnet ist, funkt das mit Sicherheit nicht.
Google mal nach "RFM02 Circuit" oder "RFM02 Schaltung" oder "RFM02 Sender". Da solltest du etwas finden können. oder hier im Forum mal suchen nach rfm02.