RFM12 Interrupt gesteuert

[Jonas E. (jonas_e43)]

Hallo,
seid kurzem versuche ich  mit der Hilfe von RFM12 Modulen eine Art Chat 
zu bauen. Dabei verwende ich zwei Pollin Funk-Evaluationboard, auf denen 
jeweils ein Atmega32 arbeitet. Eine Polling-Kommuniktation habe ich 
schon hinbekommen, in welcher das eine Board der Transmitter und das 
andere der Receiver ist. Nun ist es für mich an der Reihe dies Interrupt 
gesteuert hinzubekommen und desweiteren müssen beide Senden und 
Empfangen können.

Zu dem Thema RFM12 habe ich mir schon einige Threads im Forum angesehen, 
die mir aber nicht unbedingt weiterhelfen.
Der Thread von Benedikt über die Polling Kommunikation hat mich schon 
etwas nach vorne gebracht, aber jetzt komme ich nicht weiter voran :/.

Vielleicht hat ja schon jemand von euch ein ähnliches Problem gehabt und 
eine Lösung gefunden, die mir auch helfen könnte...

Gruß Jonas

[c-hater (Gast)]

Jonas E. schrieb:

> Nun ist es für mich an der Reihe dies Interrupt
> gesteuert hinzubekommen und desweiteren müssen beide Senden und
> Empfangen können.
>
> Vielleicht hat ja schon jemand von euch ein ähnliches Problem gehabt und
> eine Lösung gefunden, die mir auch helfen könnte...

Wo soll denn da ein Problem sein? Der RFM12 hat einen Pin, über den er 
einen Interrupt auslösen kann, der Mega32 hat fünf interruptfähige 
Eingangspins. Knotest du also den einen an einen der anderen und 
programmierst ein wenig Software dazu.

Der Ablauf ist immer gleich: Als Reaktion auf den Interrupt 
Statusregister des RFM12 auslesen, um die auslösende Interruptquelle des 
RFM12 festzustellen und dann geeignet darauf reagieren.

So wie man das halt prinzipiell mit jeder externen Hardware machen muß, 
bei der es mehrere mögliche Interruptquellen gibt, die über nur einen 
Pin signalisiert werden.

Die einzige Schwierigkeit hier ist, daß du auch auf die Situation 
vorbereitet sein mußt, daß du auf den Int des RFM12 nicht unverzüglich 
reagieren kannst, weil du schon mit ihm (oder ggf. auch einem anderen 
Gerät am SPI-Bus) redest. Dann mußt du dir halt den Int merken und ihn 
dann behandeln, wenn du mit dem anderen Gequatsche fertig bist.

[Jonas E. (jonas_e43)]

c-hater schrieb:
> Wo soll denn da ein Problem sein? Der RFM12 hat einen Pin, über den er
> einen Interrupt auslösen kann, der Mega32 hat fünf interruptfähige
> Eingangspins. Knotest du also den einen an einen der anderen und
> programmierst ein wenig Software dazu.

Alles klar. Ich habe jetzt den nIRQ Pin an den INT0 des Atmega32 
angeschlossen und den Interrupt auf eine fallende Flanke gelegt.
Als Beispiel habe ich diesen Code gefunden:

ISR(INT0_vect)
{
  PORTD |= (1<<PD6);
  static uint8_t daten[32];
  static uint8_t checksum = 0;
  static uint8_t bytecount = 0;
  uint8_t i, sensor_nr, byte;

  RFM12_PORT &= ~(1<<RFM12_CS);                  // CS auf L
  
  byte = 0xB0;                                  // Receive FIFO

  for (i=0; i<8; i++)                           // Kommando senden
  {
    if (byte & 0x80)
    {
      RFM12_PORT |= (1<<RFM12_SDI);          // DATA auf H
    }
    else
    {
      RFM12_PORT &= ~(1<<RFM12_SDI);        // DATA auf L
    }
    RFM12_PORT |= (1<<RFM12_SCK);              // CLK auf H

    byte = (byte << 1);                        // nächstes Bit nach oben

    RFM12_PORT &= ~(1<<RFM12_SCK);            // CLK auf L
  }

  byte = 0;

  for (i=0; i<8; i++)                           // FIFO Daten lesen
  {
    byte = (byte << 1);                        // eins höher schieben
    if ((RFM12_PIN & (1<<RFM12_SDO)))          // Bit 1?
    {
      byte = (byte | 0x01);                  // ja
    }
    RFM12_PORT |= (1<<RFM12_SCK);              // CLK auf H
    asm("nop");
    RFM12_PORT &= ~(1<<RFM12_SCK);            // CLK auf L
  }
  
  RFM12_PORT |= (1<<RFM12_CS);                  // CS auf H

  if (bytecount != (PAKET_LEN-1))
  {
    daten[bytecount] = byte;                  // Daten speichern
    checksum += byte;
    bytecount++;
  }
  else
  {
    rfm12_send_cmd(0xCA81);                   // set FIFO mode
    rfm12_send_cmd(0xCA83);                   // enable FIFO

    if (checksum == byte)                     // Checksumme ok?
    {
      sensor_nr = daten[0];
      if (sensor_nr == (uint8_t) ~(daten[1]))
      {
        sensor_nr = (sensor_nr - 1) & 0x0F;
        memcpy((void *) sensor[sensor_nr], (void const *) daten, PAKET_LEN);
      }
    }
    checksum = 0;
    bytecount = 0;
  }

Da ich noch etwas unerfahren in der Programmierung in C bin stellt sich 
für mich die Frage wie ich dieses Byte Array wieder in ein ASCII Zeichen 
Array umwandeln kann um dieses dann auf dem Bildschirm anzuzeigen