RFM01 Empfänger mit Interrupt

[ArduStemmi (Gast)]

Ich beschäftige mich schon geraume Zeit mit der Thematik, wie ich die 
Daten aus dem RFM01 per Interrupt auslesen kann. Leider komme ich nicht 
recht voran!

Ich habe mir eine Lösung für den RFM12 angeschaut, dort wird nach in der 
ISR der Befehl 0xB0 zum RFM12 geschickt und danach ein Byte aus dem FIFO 
ausgelesen! Daraus schlussfolgere ich, dass jedes einzelne Byte einen 
Interrupt auslösen muss! Hierbei werden keine Statusbytes gelesen und 
verarbeitet.

Im Vergleich dazu wird in der Polling Prozedur aus Benedikts Source Code 
nachdem das SDO Pin Low ist 16 Bit (Statusregister ausgelesen und 
verworfen, danach wird ein Byte gelesen und verarbeitet! Wenn die 
Paketgröße also 16 Byte beträgt, wird die Statusbytes 16mal gelesen und 
verworfen.

Woher kommt dieser Unterschied? Warum muss ich beim RFM12 erst noch 
einen Befehl hinschicken, und beim RFM01 erst Statusdaten lesen?

Bei der Polling Struktur ist natürlich immer klar, wann ein Paket zu 
Ende ist, das ist bei der Interruptstruktur nur mit Hilfe einer 
statischen Hilfsvariable möglich. Das heißt, dass Risiko ist hoch, dass 
ein Byte verlorengeht und dann keine sinnvolle Information zu Stande 
kommt.

Kann mir jemand erklären, wie man es richtig macht?

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

ArduStemmi schrieb:
> Warum muss ich beim RFM12 erst noch
> einen Befehl hinschicken, und beim RFM01 erst Statusdaten lesen?

Der RFM12 ist ein Transceiver, d.h. er kann senden und empfangen. Der 
RFM01 ist ein reiner Empfänger und deswegen muss man ihm nicht 
mitteilen, das er empfangen soll.

ArduStemmi schrieb:
> Das heißt, dass Risiko ist hoch, dass
> ein Byte verlorengeht und dann keine sinnvolle Information zu Stande
> kommt.

Gerade bei der Interuptsteuerung geht sehr wenig verloren, weil die 
Prioritäten hoch sind.
Leider ist der Grossteil meines IRQ gesteuerten RFM Moduls verloren 
gegangen, aber das Prinzip geht so:
* Pinchange Interrupt für den Pin, an dem nIRQ vom Modul dran ist, 
einrichten, aber noch nicht freigeben.
* (an den RFM sende ich dazu : 0xc0a2, 0xce88, 0xce8b)
* Empfänger initialisieren und Fifo anschalten. Datenpointer 
vorbereiten.
* ( RFM bekommt 0xc0a3)
* Pinchange Interrupt freigeben.

Im Interrupt:
Daten zum RFM01 dauerhaft lo setzen.
CS des RFM auf aktiv setzen, also RFM anwählen.
Jetzt 16 bit vom RFM Datenpin lesen, dabei mit der Clk weitertakten, 
also immer high, dann low, dann lesen. Das ist das Statusword. Wenn 
dadrin das FIFO_IT Bit gesetzt ist (das oberste  Bit15), das Datenbyte 
einlesen, sonst den Empfang abbrechen.
Byte einlesen mit Clk Hi, einige µs warten, Datenbit lesen, Clk low und 
8 mal wiederholen, dann das Byte im Buffer speichern.

Ganz am Ende dann CS wieder deaktivieren. Das wars.

im Hauptprogramm den Datenpointer checken. Wenn die Paketlänge komplett 
ist, Fifo resetten und wieder von vorne.
*

[Christian K. (the_kirsch)]

Ich kann dir ja mal ein paar Tipps wie ich es gelöst hatte.

du must die zwei Interrupt Routinen
ISR (INTx_vect){
}

und


ISR (SPI_STC_vect) {
}

aus programmieren.

zusätzlich brauchst du hilf Funktionen die du aus deinem Hauptprogramm 
aufrufst.

1. Es werden immer 16 Bit per SPI übertragen. Der AVR-SPI-Kontroller 
arbeitet aber nur mit 8 Bits, daher musst du ihn immer  zweimal 
'anwerfen'.

ich mach das immer so:

volatile uint8_t busyFlag_ISR;
volatile uint8_t rxBuf_ISR;
volatile uint8_t mode16Flag_ISR;
volatile uint8_t rxBufHi_ISR;
volatile uint8_t txBuf_ISR;


void Spi_init() {
  SPSR = 0x01;
  SPCR = 0xD1;
}

ISR (SPI_STC_vect)
{
  if ( mode16Flag_ISR ) {
    mode16Flag_ISR = 0;
    rxBufHi_ISR = SPDR;
    SPDR = txBuf_ISR;
  } else {
    rxBuf_ISR = SPDR;
    /* SS to Hi */
    SPI_NSEL_PORT |= ( 1 << SPI_NSEL_PIN );
    busyFlag_ISR = 0;
    rfm_code_here();
  }
}

uint8_t Spi_16( uint16_t data ) {
  uint8_t result;
  cli();
  result = Spi_16_ISR( data );
  sei();
  return result;
}

uint8_t Spi_16_ISR( uint16_t data ) {
  if ( busyFlag_ISR ) {
    return 0;
  }
  mode16Flag_ISR = 1;
  busyFlag_ISR = 1;
  txBuf_ISR = data;
  //SS to Low
  SPI_NSEL_PORT &= ~( 1 << SPI_NSEL_PIN );
  SPDR = ( data >> 8 );
  return 1;
}

void Spi_16W( uint16_t data ) {
  while ( 1 ) {
    cli();
    if ( busyFlag_ISR ) {
      sei();
      continue;
    }
    break;
  }
  Spi_16_ISR( data );
  sei();
}

uint8_t Spi_8( uint8_t data ) {
  uint8_t result;
  cli();
  result = Spi_8_ISR( data );
  sei();
  return result;
}

uint8_t Spi_8_ISR( uint8_t data ) {
  if ( busyFlag_ISR ) {
    return 0;
  }
  busyFlag_ISR = 1;
  //SS to Low
  SPI_NSEL_PORT &= ~( 1 << SPI_NSEL_PIN );
  SPDR = data;
  return 1;
}

void Spi_8W( uint8_t data ) {
  while ( 1 ) {
    cli();
    if ( busyFlag_ISR ) {
      sei();
      continue;
    }
    break;
  }
  Spi_8_ISR( data );
  sei();
}

uint8_t Spi_get( void ) {
  return rxBuf_ISR;
}

uint8_t Spi_getHi( void ) {
  return rxBufHi_ISR;
}

uint8_t Spi_isBusy( void ) {
  return busyFlag_ISR;
}

Du kannst ersmal deine Software SPI damit ersetzen, in dem du:

Spi_16W(w_data);
uint16_t r_data = (uint16_t)Spi_getHi() << 8 | Spi_get();

schreibst.

Der Hardware SPI ist um ein vielfaches schneller als über Software, 
daher ist es kein Problem jedes Mal das komplette Statusregister des RFM 
auszulesen.


Die gesamte Ansteuerung kommst in die "rfm_code_here()".

Die Interrupt Routine ist bei mir auch sehr klein, da sie nur den SPI 
startet:

volatile uint8_t interruptFlag_ISR = 0;

/*
 * si4420Physical_state_ISR:
 * 0 => not init
 * 1 => idle
 * 2 => listening
 * 3 => sending
 */
volatile uint8_t state_ISR = 0;

/* si4420Physical_SPIAction_ISR:
 * 0 => none
 * 1 => status read
 * 2 => receiver read
 */
volatile uint8_t spiAction_ISR = 0;

ISR (INT0_vect)
{
  if ( Spi_16_ISR( 0x0000 ) ) {
    spiAction_ISR = 1;
  } else {
    interruptFlag_ISR = 1;
  }
}

Nicht wundern si4420 ist der eigentliche Chip auf den RFMs. 
interruptFlag_ISR ist ein Merker, das nach der aktuell laufenden 
SPI-Übertragung wieder das Staus Register ausgelesen werden muss.

[ArduStemmi (Gast)]

Hallo Matthias Sch. Ich habe mal versucht, Dein Rezept umzusetzen, 
leider bisher ohne Erfolg.

Matthias Sch. schrieb:
> Gerade bei der Interuptsteuerung geht sehr wenig verloren, weil die
> Prioritäten hoch sind.
> Leider ist der Grossteil meines IRQ gesteuerten RFM Moduls verloren
> gegangen, aber das Prinzip geht so:
> * Pinchange Interrupt für den Pin, an dem nIRQ vom Modul dran ist,
> einrichten, aber noch nicht freigeben.

EICRA |= (1 << ISC01);          // The falling edge of INTx generates an interrupt request

 Zu Beginn des Programmes! Erste Zeile nach main.

> * (an den RFM sende ich dazu : 0xc0a2, 0xce88, 0xce8b)

  RF_PORT=(1<<CS);
  RF_DDR=(1<<SDI)|(1<<SCK)|(1<<CS);
  
  for (i=0; i<16; i++)
    _delay_ms(10);      // wait until POR done

  rf01_trans(0xC2E0);      // AVR CLK: 10MHz
  rf01_trans(0xC42B);      // Data Filter: internal
  rf01_trans(0xCE88);      // FIFO mode
  rf01_trans(0xC6F7);      // AFC settings: autotuning: -10kHz...+7,5kHz
  rf01_trans(0xE000);      // disable wakeuptimer
  rf01_trans(0xCC00);      // disable low duty cycle
  
  rf01_trans(0xC0E9);      //|((sgain&3)<<4)|((sdrssi&7)<<1));  // RX on
  rf01_trans(0xCE89);      // set FIFO mode
  rf01_trans(0xCE8B);      // enable FIFO

Die komplette Initialisierung des RFM 01 incl der letzten drei Zeilen, 
die RX anschalten, den FIFO Mode setzen und das den FIFO einschalten.

> * Empfänger initialisieren und Fifo anschalten. Datenpointer
> vorbereiten.
> * ( RFM bekommt 0xc0a3)
> * Pinchange Interrupt freigeben.

  EIMSK |= (1 << INT0);          // Turns on INT0
  
  
  sei();                  // turn on interrupts

Hier den Interrupt aktiviert und globale Interrupts freigegeben.
>
> Im Interrupt:
> Daten zum RFM01 dauerhaft lo setzen.
> CS des RFM auf aktiv setzen, also RFM anwählen.
> Jetzt 16 bit vom RFM Datenpin lesen, dabei mit der Clk weitertakten,
> also immer high, dann low, dann lesen. Das ist das Statusword. Wenn
> dadrin das FIFO_IT Bit gesetzt ist (das oberste  Bit15), das Datenbyte
> einlesen, sonst den Empfang abbrechen.
> Byte einlesen mit Clk Hi, einige µs warten, Datenbit lesen, Clk low und
> 8 mal wiederholen, dann das Byte im Buffer speichern.

ISR(INT0_vect)
{
  
  uart_puts("Interrupt");
  unsigned char c;
  
  cbi(RF_PORT, SDI);
  sbi(RF_PORT, CS);          //low avctiv
  cbi(RF_PORT, SCK);
  sbi(RF_PORT, SDO);          //low activ
  _delay_ms(2);
    
  cbi(RF_PORT,CS);          //RFM ausgewählt
  
  for (j=0; j<16; j++)        // lies Status Register
  {
    StatusFlag <<= 1;
    
    sbi(RF_PORT, SCK);
    _delay_us(0.2);
    cbi(RF_PORT, SCK);
  
    if (RF_PIN & (1<<SDO))
    {
      StatusFlag|=1;
    }
  }
    
  c=0;
  for (j=0; j<8; j++)          // lies Daten aus dem FIFO
  {
    c <<= 1;
      
    sbi(RF_PORT, SCK);
    _delay_us(0.2);
    cbi(RF_PORT, SCK);
      
    if (RF_PIN & (1<<SDO))
    {
      c|=1;
    }
    
  }
    
  data[nummer] = c;
  nummer += 1;
    
  }

Meine komplette Interrupt Routine!
>
> Ganz am Ende dann CS wieder deaktivieren. Das wars.


Der Interrupt wird niemals ausgelöst! Dass heißt nIRQ bleibt konstant 
auf High-Level. Wenn ich den Interrupt mit der Hand auslöse, GND an 
INT0, bleibt das Programm im ISR hängen, was ich nun gar nicht verstehe!

[ArduStemmi (Gast)]

Nachdem es mir in endlicher Zeit und mit vertretbarem Aufwand nicht 
gelungen war, eine Interruptroutine für den RFM02 zu programmieren, 
hatte ich beschlossen, den Datenempfang in einen Attiny zu verlagern. 
Dieser sollte dann mit Polling arbeiten und die Daten an den Atmega328p 
übergeben. Im 328er wollte ich eine Interrupt Routine für den Empfang 
der Daten aus dem Attiny programmieren. Somit hätte der 328er ohne 
Störung mit schon geprüften Daten arbeiten können.

Also habe ich mein Programm wieder auf Poling umgestrickt. Dabei habe 
ich die in diesem thread besprochenen Fehler vermieden 
(Frequenzfestlegung und Frequenzberechnung). Das Ergebnis war 
ernüchternd. Wieder dauert es zwischen 3 Sekunden und 3 Minuten bis der 
Empfänger sicher Daten empfängt. Das ist aus meiner Sicht inakzeptabel.

Aus diesem Grund mache ich jetzt Schluss mit RFM01 und RFM02!

Kann mir einer von euch eine Alternative nennen. Ich möchte eine 
Datenverbindung im Sinne des broadcasting für Innenräume aufbauen. Nach 
wie vor möchte ich mich nicht mit Hochfrequenztechnik beschäftigen. Es 
wäre sehr schön wenn es für diese Alternative Bibliotheken gäbe. Ich 
muss die verlorene Zeit wieder aufholen.

Ich danke euch für eure Hinweise.