RFM12 SDO polling

[René S. (grassh0pper)]

hallo,

wie genau funktioniert das sdo-polling beim RFM12 modul beim Senden und 
Empfangen?
Ich mache jetzt schon ewig damit rum, komme aber auf keinen grünen 
zweig.

Montan sieht meine Senderoutine (hard-spi) so aus:

1. sendeteil komplett einschalten (cs auf low, 0x8228 in reg. laden, cs 
auf high
2. cs auf low
3. warten, dass sdo high wird, solange nix machen
4. 0xb8aa in reg laden
5. warten, dass sdo high wird, solange nix machen
5. 0xaa in reg laden
6. warten, dass sdo high wird, solange nix machen
7. 0xaa in reg laden
8. warten, dass sdo high wird, solange nix machen
9. synchronmuster in reg laden 0x2DD4
10. warten, dass sdo high wird, solange nix machen
11. nutzdaten senden (je acht bit)
12. warten, dass sdo high wird, solange nix machen
13. 0xaa in reg laden
14. warten, dass sdo high wird, solange nix machen
15. sendetrakt aus (beeinhaltet cs auf high)

funktioniert auch soweit ganz gut, würd ich sagen. Die Bilder auf dem 
Oszi sehen ok aus. Hab quasi das logikdiagramm ausm artikel RFM12 
nachprogrammiert und das sieht wie gesagt ok aus.
Jetzt zur empfangsroutine:
wann genau bekomme ich beim empfangen vom RFM-Modul ein High-Signal am 
SDO?
wie genau funktioniert hier das polling? Bekomme einfach kein 
high-signal am sdo...
Aber einfach durchrauschen ohne auf das rfm modul zu reagieren klappt 
natürlich auch nicht...

[René S. (grassh0pper)]

void rfm_TX(uint8_t *data)
  {
    rfm_tx_enable(1);        //sendetrakt komplett ein
    rfm_enable();
    rfm_ready();
    spi_master_write_16(0xB8AA);  //takteinlaufbyte
    rfm_ready();
    spi_master_write_8(0xAA);    //takteinlaufbyte
    rfm_ready();
    spi_master_write_8(0xAA);    //takteinlaufbyte
    rfm_ready();
    spi_master_write_16(0x2DD4);  //synchronmuster
    for (int i=0; i<2; i++)
      {
        rfm_ready();
        spi_master_write_8(*data);    //nutzdaten: 1byte
      }
    rfm_ready();
    spi_master_write_8(0xAA);    //dummy-byte
    rfm_ready();
    rfm_tx_enable(0);        //sender ausschalten. (beeinhaltet rfm_disable)
  }
void rfm_RX(uint8_t *data)
  {
    rfm_rx_enable(1);    
    rfm_writecmd(0xCA81);  //FIFO leeren      
    rfm_writecmd(0xCA83);  //FIFO freigeben
    
    rfm_enable();
    rfm_ready();
    spi_master_write_16(0xB0000);
        rfm_ready();
    *data = spi_master_read(0x00);
    rfm_disable();
    rfm_enable();
    
    rfm_ready();
    spi_master_write_16(0xB000);
        rfm_ready();
    *data = spi_master_read(0x00);
    rfm_disable();
    rfm_enable();
    
    rfm_ready();
    
    blink(0, 100);
    
    rfm_rx_enable(0);
  }

so siehts aus, funzt aber nicht. Ich schätze es hängt am empfang... 
Achja: ich sende zuerst einmal fest 2 byte, deswegen die for schleife

[René S. (grassh0pper)]

nachtrag:

fehler lag am (auch / nur?!) am sender:

die Zeile

spi_master_write_16(0x2DD4);  //synchronmuster

muss aufgeteilt werden in

spi_master_write_8(0x2D);  //synchronmuster
rfm_ready();
spi_master_write_8(0xD4);  //synchronmuster

da ich cs permanent auf low halte während ich das senderegister 
beschreibe kann ich nach einmaliges 0xb8xx mir dieses sparen, muss aber 
nach jedem byte sdo abfragen!

[Martin K. (maart)]

Das Modul steht bei mir auch bald auf dem Plan.
Danke für die Beschreibung.
cs ist bei dir nSEL, also chip-select, oder?

[René S. (grassh0pper)]

ja, genau, cs = chip select!
Inzwischen läuft die Sache wirklich gut. Es war noch ein fehler im code 
des empfängers:

der befehl zum auslesen des FIFO ist im Artikel mit 0xb8000 angegeben. 
Eigentlich ist es so, dass mit den ersten 8 bit 0xb0 schon der befehl 
zum auslesen des FIFO ans rfm modul geschickt wird. die restlichen 8bit 
sind dann nur dazu da, damit der µc (beim hardware SPI) einen takt an 
sck anlegt.
das ganze sieht bei mir so aus (testweise mit 2 byte ohne irgendwelche 
längenangaben oder fehlerprüfsummen...)

void rfm_RX(uint8_t *data)
  {
    rfm_rx_enable(1);    
    rfm_writecmd(0xCA81);  //FIFO leeren      
    rfm_writecmd(0xCA83);  //FIFO freigeben  
    rfm_enable();
    
    rfm_ready();
    spi_master_write_8(0xB0);
    *data = spi_master_read(0x00);
    rfm_disable();
    rfm_enable();
    
    rfm_ready();
    spi_master_write_8(0xB0);
    *data = spi_master_read(0x00);
    rfm_disable();
    rfm_enable();
    
    rfm_ready();
    rfm_rx_enable(0);
    blink(LED_rt, 100);
  }

void spi_master_write_8(uint8_t cmd)
  {
    SPDR = cmd;
    while(!(SPSR & (1<<SPIF)))
      ;
  }
void spi_master_write_16(uint16_t cmd)
  {
    uint8_t cmd_msb = 0;
    uint8_t cmd_lsb = 0;
    
    cmd_msb = (cmd >> 8) & 0xFF;
    cmd_lsb = cmd & 0xFF;
    
    SPDR = cmd_msb;
    while(!(SPSR & (1<<SPIF)))
      ;
    
    SPDR = cmd_lsb;
    while(!(SPSR & (1<<SPIF)))
      ;
  }
uint8_t spi_master_read(uint8_t cmd)
  {
    uint8_t empfang = 0;
    
    SPDR = cmd;
    while(!(SPSR & (1<<SPIF)))
      ;
    empfang = SPDR;
    
    return empfang;
  }

void rfm_writecmd(uint16_t cmd)
  {
    rfm_enable();    // RFM12 anwählen
    spi_master_write_16(cmd);
    rfm_disable();  //RFM12 abwählen
  }

Höllisch aufpassen muss man dann eben auch noch mit dem chipselect, weil 
dieser maßgeblich am sdo-polling beteiligt ist.
Und fsk beim polling unbedingt auf H-Pegel!