AVRCAN bekommt RX-Interrupt nicht mit

[Mechatronk A. (mechatronk)]

Mein AVRCAN hat ein Problem, lustiger weise mit Code, von dem ich 
schwören könnte der es vor einem Jahr in der Form noch getan hat.

Mit 2 verschiedenen Can-Interfaces, Oszi und allen möglichen 
Einstellungen getestet, das zu Empfangenen Signal ist auf jeden Fall im 
Bus und sieht OK aus.
Senden geht vom Controller aus wunderbar, der TX Interrupt feuert auch 
wenn man ihn aktiviert.
Der RX Interrupt wird einfach nicht ausgelöst, Remote Requests 
Funktionieren auch nicht.
Ich verwende eine leicht modifizierte Lib Michael aus diesem Thread:
Beitrag "CAN-Bibliothek für den at90CAN128 und das AVRStudio"

Ich habe zusätzlich eine Inbox angelegt, in der für jeden Mob bei 
eintreffen einer den Filter passierenden Nachricht die Nachricht 
hinterlegt wird, aber so weit kommt es ja garnicht.

Ich habe mein Programm auf das Nötigste eingedampft. In einer 
Endlosschleife wird der Bereich der Inbox auf Mob 0 mit ID 2 ausgegeben, 
der von Mob 1 mit ID 1 beschrieben wird.
Ich bitte Schönheitsfehler zu entschuldigen, ich pfusche da schon den 
ganzen Tag dran rum und komme auf keinen grünen Zweig.

Danke das ihr bis hier gelesen habt, da ist der Code:

main.c

#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>
#include <stdbool.h>

#define F_CPU 16000000ULL
#include <util/delay.h>

#include "can.h"

//Variablen


int8_t can_out[8];


  
void PORT_Init()
{
  PORTA = 0b00000000;
  DDRA = 0b00000000;

  PORTB = 0b00000000;
  DDRB = 0b00000000;     

  PORTC = 0b00000000;
  DDRC = 0b00000000;

  PORTD = 0b00000000;
  DDRD = 0b00000100;     

  PORTE = 0b00010000;
  DDRE = 0b00010000;    //Led set as output (Bit4 = 1) 
    
  PORTF = 0b00000000;
  DDRF = 0b00000000;
  }


void WDT_off(void)
  {
  cli();
  /* Write logical one to WDCE and WDE */
  WDTCR = (1<<WDCE) | (1<<WDE);
  /* Turn off WDT */
  WDTCR = 0x00;
  }
void bus_init(void)
  {
    
  // baudrate: 1M,rx interrupt, extendet Id
  can_init(CAN_BAUDRATE_1000K , CAN_INTERRUPT_RX, 1);
 
  can_enable_mob(1, CAN_MODE_RECEIVE_DATA,    1, 0xffffffff);
 
  }


void sleep(uint32_t i) 
{
  while(i--)
    _delay_ms(1);
}

int main()
  {
  WDT_off();
  PORT_Init();
  bus_init(); 
  sei();  // Alles Initialisiert, Interupts Freischalten
  
    
  
  while (1)
  
    {



     //Ausgabe Status  

     int j;
    
      for (j=0;j<8;j++)
        {
        can_out[j]=inbox[0][j];
        }
      can_enable_mob(0, CAN_MODE_TRANSMIT_DATA, 2 ,0xffffffff);
      can_send_data(0,8,can_out); 
      can_disable_mob(0);
      sleep(100);
      
      

    
     }

     
  }

can.h

#ifndef CAN_H
  #define CAN_H

  #include <inttypes.h>

  #define setbit(ADR,BIT)   (ADR |= (1<<BIT))
  #define clearbit(ADR,BIT) (ADR &=~(1<<BIT))
  #define getbit(ADR, BIT)  (ADR &  (1<<BIT))

  /* CAN Objekte */
  #define NO_MOBS 15   // Anzahl der Message Objects festlegen
  #define NOMOB   0xff // Definition für ungültigen Objektindex

  // Betriebsmodi
  enum { CAN_MODE_DISABLED, CAN_MODE_TRANSMIT_DATA, CAN_MODE_TRANSMIT_REMOTE,
         CAN_MODE_RECEIVE_DATA, CAN_MODE_AUTO_REPLY };

  // Interrupt-Modi
  enum { CAN_INTERRUPT_NONE, CAN_INTERRUPT_TX, CAN_INTERRUPT_RX,
         CAN_INTERRUPT_TXRX };

  // baudrate
  enum { CAN_BAUDRATE_100K, CAN_BAUDRATE_125K, CAN_BAUDRATE_200K,
         CAN_BAUDRATE_250K, CAN_BAUDRATE_500K, CAN_BAUDRATE_1000K };

  // "hauptfunktionen"
  int can_init(uint8_t baudrate, uint8_t intmode, uint8_t eid);
  int can_deinit(void);
  int can_enable_mob(uint8_t mob, uint8_t mode, uint32_t id, uint32_t idm);
  int can_disable_mob(uint8_t mob);
  int can_send_data(uint8_t mob, uint8_t length, int8_t * data);
  int can_send_remote(uint8_t mob);
  void can_set_autoreply(uint8_t mob, uint8_t length, int8_t *buf);

  volatile uint8_t inbox[15][8]; // Inbox auf die uebergreifend zugegriffen werden kann

  // sonstige hilfsfunktionen
  int can_set_baudrate(uint8_t baudrate);
  int can_set_interrupt(uint8_t mode);
  void can_get_mob(uint8_t mob);
  uint32_t can_get_id(void);
  void can_set_id_mask(uint32_t idm);
  void can_set_id(uint32_t id);
  int can_set_mode(uint8_t mode);
  uint8_t can_get_mode(void);
  void can_set_data(uint8_t length, int8_t * data);
  void can_get_data(int8_t *msg);
  void can_set_mob_interrupt(uint8_t object);
  void can_clear_mob_interrupt(uint8_t mob);
  uint8_t can_get_mob_interrupt(void);

#endif /* CAN_H */

can.c

#include "can.h"

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>  
#include <inttypes.h>
#include <stdbool.h>


int8_t iemob[15] = {
  IEMOB0, IEMOB1, IEMOB2,  IEMOB3,  IEMOB4,  IEMOB5,  IEMOB6, IEMOB7,
  IEMOB8, IEMOB9, IEMOB10, IEMOB11, IEMOB12, IEMOB13, IEMOB14 };


// extended id
int8_t extended_id;

// Message Objects zuruecksetzen, CAN-Controller aktivieren
// Parameter:
//   uint8_t baud: 0,1,2...5 (fuer 100, 125, 200, 250, 500, 1000)
//   uint8_t intmode: Ereignis, bei dem ein Interrupt ausgelöst werden soll
//     - NONE  - Deaktiviert
//     - TX    - Daten gesendet
//     - RX    - Daten empfangen
//     - TXRX  - Daten gesendet und/oder empfangen
int can_init(uint8_t baudrate, uint8_t intmode, uint8_t eid)
{
  uint8_t i;

  extended_id = eid ? 1 : 0;

  // Status- und Steuerregister aller Message Objects initialisieren
  for(i = 0; i < NO_MOBS; i++)
  {
    can_get_mob(i);
    CANSTMOB = 0;
    CANCDMOB = 0;
  }

  // set baudrate
  if(can_set_baudrate(baudrate) == 0)
    return 0;

  if(can_set_interrupt(intmode) == 0)
    return 0;

  // CAN-Controller in Enabled Mode setzen
  setbit(CANGCON, ENASTB);

  // Warten bis der CAN-Controller das Enabled-Bit gesetzt hat und
  // einsatzbereit ist
  while (!getbit(CANGSTA, ENFG));

  return 1; 
}

int can_deinit(void)
{
  uint8_t i;

  for(i = 0; i < 15; i++)
    can_disable_mob(i);

  // CAN-Controller ausschalten
  clearbit(CANGCON, ENASTB);

  // warten bis wirklich ausgechaltet
  while (getbit(CANGSTA, ENFG));

  return 1;
}

void can_set_autoreply(uint8_t mob, uint8_t length, int8_t *buf)
{
  can_get_mob(mob);
  can_set_mode(CAN_MODE_AUTO_REPLY);
  can_set_data(length, buf);
}

int can_set_baudrate(uint8_t baudrate)
{
  // @16 MHz
  switch(baudrate)
  {
    case CAN_BAUDRATE_100K:
      CANBT1 = 0x12;
      CANBT2 = 0x0c;
      CANBT3 = 0x37;
      break;

    case CAN_BAUDRATE_125K:
      CANBT1 = 0x0e;
      CANBT2 = 0x0c;
      CANBT3 = 0x37;
      break;

    case CAN_BAUDRATE_200K:
      CANBT1 = 0x08;
      CANBT2 = 0x0c;
      CANBT3 = 0x37;
      break;

    case CAN_BAUDRATE_250K:
      CANBT1 = 0x06;
      CANBT2 = 0x0c;
      CANBT3 = 0x37;
      break;

    case CAN_BAUDRATE_500K:
      CANBT1 = 0x02;
      CANBT2 = 0x0c;
      CANBT3 = 0x37;
      break;

    case CAN_BAUDRATE_1000K:
      CANBT1 = 0x00;
      CANBT2 = 0x0c;
      CANBT3 = 0x37;
      break;

    default:
      return 0;
  }

  return 1;
}

// Parameter:
//   uint8_t mob: Nummer des zu wählenden Objekts (0-14)
//
//   uint8_t mode
//     - Betriebsart des Message Objekts:
//     - DISABLED         Deaktiviert
//     - TRANSMIT_DATA    Daten senden
//     - TRANSMIT_REMOTE  Anfrage senden
//     - RECEIVE_DATA     Empfangsmodus
//     - AUTO_REPLY       automatischer Antwortmodus
//
// Funktion setzt die Betriebsart des vorher gewählten Objekts
int can_enable_mob(uint8_t mob, uint8_t mode, uint32_t id, uint32_t idm)
{
  // Objekt wählen
  can_get_mob(mob);

  // Interrupt für dieses Objekt aktivieren
  can_set_mob_interrupt(mob);

  // ID-Maske setzen
  can_set_id_mask(idm);

  // ID setzen
  can_set_id(id);

  // Betriebsmodus setzen
  if(can_set_mode(mode) == 0)
    return 0;

  return 1;
}


int can_send_data(uint8_t mob, uint8_t length, int8_t * data)
{
  uint8_t mode;

  // Objekt wählen
  can_get_mob(mob);
  
  // Aktuelle Betriebsart sichern
  mode = can_get_mode();

  // Nutzdaten in Register schreiben
  can_set_data(length, data);

  // Datenübertragung starten
  can_set_mode(CAN_MODE_TRANSMIT_DATA);

  // Warten bis die Datenübertragung beendet ist (TXOK-Flag von CAN-Controller
  // gesetzt)
  while (!getbit(CANSTMOB, TXOK));      

  // TXOK-Flag von Hand löschen
  clearbit(CANSTMOB, TXOK);

  // Alte Betriebsart wiederherstellen
  can_set_mode(mode);

  return 1;
}


// Parameter: uint8_t mode: Ereignis, bei dem Interrupt ausgelöst werden soll
//   - NONE  - Deaktiviert
//   - TX    - Daten gesendet
//   - RX    - Daten empfangen
//   - TXRX  - Daten gesendet und/oder empfangen
int can_set_interrupt(uint8_t mode)
{
  switch(mode)
  {
    case CAN_INTERRUPT_NONE:
      clearbit(CANGIE, ENIT);
      clearbit(CANGIE, ENRX);
      clearbit(CANGIE, ENTX);
      break;

    case CAN_INTERRUPT_TX:
      setbit(CANGIE, ENIT);
      clearbit(CANGIE, ENRX);
      setbit(CANGIE, ENTX);
      break;

    case CAN_INTERRUPT_RX:
      setbit(CANGIE, ENIT);
      setbit(CANGIE, ENRX);
      clearbit(CANGIE, ENTX);
      break;

    case CAN_INTERRUPT_TXRX:
      setbit(CANGIE, ENIT);
      setbit(CANGIE, ENRX);
      setbit(CANGIE, ENTX);
      break;

    default:
      return 0;
  }

  return 1;
}


// Funktion wählt CANPAGE des betreffenden Objekts aus und stellt Zugang zu
// Registern des Objekts her
void can_get_mob(uint8_t mob)
{
  CANPAGE = (mob << 4);
}

  
// Parameter: uint32_t idm: ID-Maske in Dezimalschreibweise
// Funktion setzt ID-Maske eines Objekts auf einen neuen Wert. In CANIDM4
// bleiben dabei die Werte der unteren 3 Bit (RTRTAG, Reserved und IDEMSK)
// erhalten.
void can_set_id_mask(uint32_t idm)
{
  //Standart identifier (11 bit)
  if(!extended_id)
  {
    CANIDM2 = (uint8_t)(idm << 5); 
    CANIDM1 = (uint8_t)(idm >> 3);
  }
  //extended identifier
  else
  {
    idm <<= 3;
    idm  |= 7;

    CANIDM4 = (int8_t) (idm);
    CANIDM3 = (int8_t) (idm>>8);
    CANIDM2 = (int8_t) (idm>>16);
    CANIDM1 = (int8_t) (idm>>24);
  }
}

// Funktion holt ID der empfangenen Nachricht
uint32_t can_get_id(void)
{
  uint32_t id = 0;

  //Standart identifier (11 bit)
  if(!extended_id)
  {
    id  = (uint8_t)  CANIDT2 >> 5;
    id |= (uint16_t) CANIDT1 << 3;
  }
  //extended identifier
  else
  {
    id |= ((uint32_t) CANIDT1 << 24);
    id |= ((uint32_t) CANIDT2 << 16);
    id |= ((uint32_t) CANIDT3 << 8);
    id |= (CANIDT4&0xF8);
    id >>= 3;
  }

  return id;
}

// Funktion setzt ID eines Objekts auf einen neuen Wert. In CANIDM4 bleiben
// dabei die Werte der unteren 3 Bit (RTRTAG, RB1TAG und RB0TAG) erhalten.
void can_set_id(uint32_t id)
{
  //Standart identifier (11 bit)
  if(!extended_id)
  {
    CANIDT2 = (uint8_t)(id << 5); 
    CANIDT1 = (uint8_t)(id >> 3);
  }
  //extended identifier
  else
  {
    id <<= 3;
    id &= 0xfffffff8;
    id |= (CANIDT4 & 0x07);

    CANIDT4 = (int8_t) (id);
    CANIDT3 = (int8_t) (id>>8);
    CANIDT2 = (int8_t) (id>>16);
    CANIDT1 = (int8_t) (id>>24);
  }
}


// Funktion setzt die Betriebsart des vorher gewählten Objekts.
// Parameter: uint8_t mode:
//   - Betriebsart des Message Objekts:
//   - DISABLED        - Deaktiviert
//   - TRANSMIT_DATA   - Daten senden
//   - TRANSMIT_REMOTE - Anfrage senden
//   - RECEIVE_DATA    - Empfangsmodus
//   - AUTO_REPLY      - automatischer Antwortmodus
int can_set_mode(uint8_t mode)
{
  if(extended_id)
    setbit(CANCDMOB, IDE);
  else
    clearbit(CANCDMOB, IDE);

  switch(mode)
  {
    case CAN_MODE_DISABLED:
      clearbit(CANCDMOB, CONMOB0);
      clearbit(CANCDMOB, CONMOB1);
      clearbit(CANCDMOB, RPLV);
      clearbit(CANIDT4, RTRTAG);
      clearbit(CANIDM4, RTRMSK);
      break;

    case CAN_MODE_TRANSMIT_DATA:
      setbit(CANCDMOB, CONMOB0);
      clearbit(CANCDMOB, CONMOB1);
      clearbit(CANCDMOB, RPLV);
      clearbit(CANIDT4, RTRTAG);
      break;

    case CAN_MODE_TRANSMIT_REMOTE:
      clearbit(CANCDMOB, CONMOB1);
      setbit(CANCDMOB, CONMOB0);
      clearbit(CANCDMOB, RPLV);
      setbit(CANIDT4, RTRTAG);
      break;

    case CAN_MODE_RECEIVE_DATA:
      clearbit(CANCDMOB, CONMOB0);
      setbit(CANCDMOB, CONMOB1);
      clearbit(CANCDMOB, RPLV);
      clearbit(CANIDT4, RTRTAG);
      break;

    case CAN_MODE_AUTO_REPLY:
      clearbit(CANCDMOB, CONMOB0);
      setbit(CANCDMOB, CONMOB1);
      setbit(CANCDMOB, RPLV);
      setbit(CANIDT4, RTRTAG);
      break;

    default:
      return 0;
  }

  return 1;
}


// Funktion holt die Betriebsart des vorher gewaehlten Objekts
uint8_t can_get_mode(void)
{
  uint8_t mode = 0;

  if(!getbit(CANCDMOB, CONMOB1) && !getbit(CANCDMOB, CONMOB0))
  {
    mode = CAN_MODE_DISABLED;
  }
  else if(!getbit(CANCDMOB, CONMOB1) && getbit(CANCDMOB, CONMOB0) &&
    !getbit(CANIDT4, RTRTAG))
  {
    mode = CAN_MODE_TRANSMIT_DATA;
  }
  else if(!getbit(CANCDMOB, CONMOB1) && getbit(CANCDMOB, CONMOB0) &&
    getbit(CANIDT4, RTRTAG))
  {
    mode = CAN_MODE_TRANSMIT_REMOTE;
  }
  else if(getbit(CANCDMOB, CONMOB1) && !getbit(CANCDMOB, CONMOB0) &&
    !getbit(CANIDT4, RTRTAG))
  {
    mode = CAN_MODE_RECEIVE_DATA;
  }
  else if(getbit(CANCDMOB, CONMOB1) && !getbit(CANCDMOB, CONMOB0) &&
    getbit(CANCDMOB,RPLV) && getbit(CANIDT4, RTRTAG))
  {
    mode = CAN_MODE_AUTO_REPLY;
  }

  return mode;
}


// Funktion schreibt in das Objekt die zu uebermittelnden Daten
void can_set_data(uint8_t length, int8_t * data)
{
  uint8_t i;
  uint8_t cancdmob;

  if(length > 8)
    length = 8;

  // Anzahl der Datenbytes in der Nachricht
  // scheinbar darf man das CANCDMOB register nicht beliebig oft
  // schreiben/lesen, daher speichern wir den wert dazwischen, loeschen die
  // entsprechenden bits fuer die laenge und schreiben dann usere laenge rein
  // wie dem auch sei: so funktionierts zumindest, also vorsicht beim aufraeumen ;-)
  cancdmob = CANCDMOB;
  clearbit(cancdmob, DLC0);
  clearbit(cancdmob, DLC1);
  clearbit(cancdmob, DLC2);
  clearbit(cancdmob, DLC3);
  CANCDMOB = (cancdmob | (length << DLC0));
  for(i = 0; i < length; i++)
    CANMSG = data[i];
}

void can_get_data(int8_t *msg)
{
  uint8_t i;

  for(i = 0; i < 8; i++)
    msg[i] = CANMSG;
}

// Parameter: uint8_t mob: Nummer des Objekts (0-14)
// Funktion setzt den Interrupt für das jeweilige Objekt
void can_set_mob_interrupt(uint8_t mob)
{
  setbit(CANIE2, iemob[mob]);
}

// Parameter: uint8_t mob: Nummer des Objekts (0-14)
// Funktion löscht den Interrupt für das jeweilige Objekt
void can_clear_mob_interrupt(uint8_t mob)
{
  clearbit(CANIE2, iemob[mob]);
}

// Rückgabe: uint8_t mob: Nummer des Objekts
// Funktion ermittelt, welches Objekt Interrupt ausgeloest hat
uint8_t can_get_mob_interrupt(void)
{
  uint8_t  mob;
  uint16_t maske;
  maske = CANSIT2 | (CANSIT1 << 8);

  // Wenn alle 32 Bit der Bitmaske 0 sind dann ist ein Fehler aufgetreten
  if(maske == 0)
    return NOMOB;

  // Die Bitmaske wird so lange nach rechts geschoben, bis Bit0 eine 1 hat.
  // Die Anzahl der Schiebeoperatoren gibt somit die Nummer des MOBs zurück
  for(mob=0; (maske & 0x01)==0; maske >>= 1, ++mob);

  // Kontrolle: Wenn mob größer als die Anzahl der verfügbaren
  // Message Objects ist das Ergebnis falsch
  if(mob > 14)
    return NOMOB;

  return mob;
}


// Funktion deaktiviert das gewählte Objekt
int can_disable_mob(uint8_t mob)
{
  // Objekt wählen
  can_get_mob(mob);

  // Interrupt für dieses Objekt aktivieren
  can_clear_mob_interrupt(mob);

  // Betriebsmodus setzen
  can_set_mode(CAN_MODE_DISABLED);

  return 1;
}


// Funktion sendet eine Anfrage (Remote Frame)
int can_send_remote(uint8_t mob)
{
  uint8_t mode;

  // Objekt wählen
  can_get_mob(mob);
  
  // Aktuelle Betriebsart sichern
  mode = can_get_mode();

  // Datenübertragung starten
  can_set_mode(CAN_MODE_TRANSMIT_REMOTE);

  // Warten bis die Datenübertragung beendet ist (TXOK-Flag von CAN-Controller
  // gesetzt)
  while (!getbit(CANSTMOB, TXOK));      

  // TXOK-Flag von Hand löschen
  clearbit(CANSTMOB, TXOK);

  // Alte Betriebsart wiederherstellen
  can_set_mode(mode);

  return 1;
}


// Interrupt fuer Empfang einer Nachricht
SIGNAL(SIG_CAN_INTERRUPT1)
{
  uint8_t save_canpage;
  uint8_t mob;
  uint8_t i;
  // Aktuelle CANPAGE sichern
  save_canpage = CANPAGE;

  // Index des MOB ermitteln, der den Interrupt ausgelöst hat
  mob = can_get_mob_interrupt();
    
  // Falls es kein gültiges MOB war abbrechen
  if(mob == NOMOB)
    return;

  // Objekt das den Interrupt ausgelöst hat holen
  can_get_mob(mob);
  
  // XXX hier eintragen, was bei einem interrupt passieren soll XXX
  // Id der Nachricht holen und Daten des MOBs aus CANMSG auslesen
  //id = can_get_id();
  
   for(i = 0; i < 8; i++)
    inbox[mob][i] = CANMSG;

  // RXOK-Flag löschen
  clearbit(CANSTMOB, RXOK);
    
  // MOB auf Empfang und CAN 2.0B Standard setzen
  can_set_mode(CAN_MODE_RECEIVE_DATA);
    
  // CANPAGE wiederherstellen
  CANPAGE = save_canpage;
}