rfm69 wirft viele timeouts

[Matthias T. (matthias_199)]

Hallo alle zusammen,

meine RFM69 Module sind so konfiguriert das sie bei einem RX timeout 
einen Interrupt werfen.

Leider funktioniert das nicht so wirklich bei allem meinen Platinen.
Die aber baugleich sind

Es scheint so das mache RFM69 extrem viele timeouts  kriegen und mein 
AVR nur doch am Interrupt ab arbeiten ist.

Kann das jemand bestätigen ?

 
ISR(INT0_vect)
{
    cli();
    uint8_t rfm_Mode_temp = rfm_Mode; //kopieren wegen votaile

    if (rfm_Mode_temp == 4)
    {
       rfm_switch_mode(1); //1 ist standby
       rfm_switch_mode(4); //4 is RX
       rfm_reset_by_timer = true;

    }
    sei();
}

void rfm_switch_mode(uint8_t mode)
{
    EIMSK |= (0<<INT0); //stoppe INt0
    EIMSK |= (0<<INT2); //stoppe INt2
    if (mode == 0)
    {
        rfm_spi_write_register(0x01,rfm_mode_sleep);
        rfm_Mode = 0;
    }
    else if (mode == 1)
    {
        rfm_spi_write_register(0x01,rfm_mode_standby);
        rfm_Mode = 1;
    }
    else if (mode == 2)
    {
        rfm_spi_write_register(0x01,rfm_mode_fs);
        rfm_Mode = 2;
    }
    else if (mode == 3)
    {
         if(rfm_dbi_boost_value)
             rfm_dbi_boost_aktivate(true);
         rfm_spi_write_register(0x01,rfm_mode_tx);
         rfm_spi_write_register(0x25,rfm_dio0_tx);
         rfm_Mode = 3;
         return;
    }
    else if (mode == 4)
    {
        rfm_spi_write_register(0x01,rfm_mode_rx);
        //rfm_spi_write_register(0x25,(rfm_dio0_rx||rfm_dio1_rx));
        rfm_spi_write_register(0x25,0x70);
        rfm_Mode = 4;
    }

    while(!rfm_read_ModeReady())
    {

    }

    EIMSK |= (1<<INT0); //aktiviere INt0
    EIMSK |= (1<<INT2); //aktiviere INt2

Er scheint sich einfach zu verlaufen obwohl im mode change ja die 
interuppts inaktive sind .....

MFG Matthias

[Stefan E. (sternst)]

ISR(INT0_vect)
{
    cli();
...
    sei();
}

Das cli() ist überflüssig, das sei() sogar potenziell gefährlich. Beides 
wird bereits von der Hardware erledigt.

    EIMSK |= (0<<INT0); //stoppe INt0
    EIMSK |= (0<<INT2); //stoppe INt2

Nein, die beiden Zeilen stoppen nichts. Die machen rein gar nichts.

Und wenn du das dann korrigiert hast: das Ausschalten der Interrupts 
verhindert nicht, dass die Interrupt-Flags bei entsprechender Aktivität 
an den Pins gesetzt werden. Also musst du vor dem Wiedereinschalten 
diese Flags löschen.

[Matthias T. (matthias_199)]

wie würde man den int dan abschlaten ich meine

EIMSK |= (1<<INT0);

aktiviert ihn ja ?

MFG Matthias

[Stefan E. (sternst)]

Matthias T. schrieb:
> wie würde man den int dan abschlaten

Bitmanipulation

[Felix P. (fixxl)]

Timeouts treten häufig auf, wenn die RSSI-Schwelle auf eine zu niedrige 
Leistung eingestellt ist, weil dann schon das Umgebungsrauschen den Rx 
glauben machen kann, dass er eine Präambel empfängt.

Je nach Umfeld sollte man beim Empfänger also den Wert im Register 0x29 
(RSSI-Threshold) schrittweise verringern (0xFF entspricht maximaler 
Empfindlichkeit), bis die Anzahl an Rx-Timeouts bei ausgeschalteten 
Transmittern minimal ist. Hatte bei mir schon Fälle, in denen es mit 
-110 dBm als Schwellwert gut funktioniert hat, woanders musste ich auf 
-90 dBm gehen, um nicht ständig den Rx getriggert zu bekommen.

[Torsten (Gast)]

Hallo Felix,

>Timeouts treten häufig auf, wenn die RSSI-Schwelle auf eine zu niedrige
>Leistung eingestellt ist, weil dann schon das Umgebungsrauschen den Rx
>glauben machen kann, dass er eine Präambel empfängt.

beim RFM12 wartet der Empfänger bis das Synchron-Pattern empfangen wird.
Erst dann würde ich den Timeout-Timer starten. Es ist sehr 
unwahrscheinlich
das das Umgebungsrauschen auch noch das Synchron-Pattern simuliert. Wenn
schon beim Empfang von jeder Preamble das Timeout gesetzt wird ist ja
klar das dann nur noch Timeouts erzeugt werden. Leider kenne ich den
RFM69 nicht da kann es ja anders sein. Oder?

Gruß Torsten

[Felix P. (fixxl)]

Hallo Torsten,

es geht schon früher los: Um das Synchronpattern (und die anschließende 
Nachricht) empfangen zu können, muss der Empfänger einige Vorarbeit 
leisten, nämlich sich auf den Pegel (AGC), die Trägerfrequenz (AFC) und 
die Bitrate einstellen. Deswegen schickt man diese 0xAA- oder 
0x55-Präambeln vor dem eigentlichen Syncword.

Obwohl ich lange mit dem RFM12 gearbeitet habe, weiß ich nicht, wie dort 
sichergestellt wurde, dass falsche Präambeldetektionen ausgeschlossen 
wurden (interner Timeout?), dort hatte ich das Problem auch nie.

Beim RFM69 ist es so, dass man einstellen kann, wie hoch der Pegel im 
Bereich der gewählten Frequenz sein muss, damit überhaupt eine Präambel 
erkannt wird (RSSI-Threshold) und ob und nach welcher Zeit der Empfänger 
einen Timeout signalisieren und neu starten soll, falls nach dem 
Erkennen eines ausreichenden Pegels für eine kein gültiges Paket mit 
Syncword, Payload und passendem CRC empfangen wurde.

Ansonsten ist es mir schon öfter passiert, dass das RFM69 einen Träger 
zu erkennen glaubt und seine Empfangsfrequenz verzieht, so dass es für 
"echte" Pakete taub wird.

Gruß
Felix

[Torsten (Gast)]

>Obwohl ich lange mit dem RFM12 gearbeitet habe, weiß ich nicht, wie dort
>sichergestellt wurde, dass falsche Präambeldetektionen ausgeschlossen
>wurden (interner Timeout?), dort hatte ich das Problem auch nie.

Hallo Felix,

einen internen Timeout gibt es beim RFM12 nicht. Man muss das selber
Programmieren. Am besten überwacht man den VDI(Valid Data Indicator)
der wiederum von den drei Signalen
-DRSSI(Digital Received Signal Strength Indication)
-DQD (Data Quality Detector)
-CR_LOCK (Clock Recovery Locked)
beeinflusst wird. Dieser wird bei mir von einen PinChange-Interrupt
überwacht, welcher den Empfang bei abfallenden VDI unterbricht.
Der Chip sollte so eingestellt werden das die emfpangenen
Daten erst nach dem Synchron-Pattern in den Puffer geschrieben werden.
Falsche Preamblen werden also ignoriert.

Gruß Torsten