CAN im AVR32 (Konfiguration der Register)

[Felix D. (skyfox)]

Hallo zusammen.

Ich habe ein kleines Problem mit dem CAN-Interface des AT32CU3C1512.
Erst einmal gehe ich davon aus, dass ich dieses Problem bin und nicht 
der AVR :-)

Kurz zur Hardware IST-Situation:
Es handelt sich um eine selbst entwickelte Platine mit AVR32 
(AT32UC3C1512) die auch die CAN-Schnittstellen des Prozessors nach außen 
führt.
Ich setze einen USB-CAN Adpter von PEAK ein und kommuniziere, unter 
Linux Ubuntu 14.04, mit dem canplayer (can-utils) mit dem Prozessor.

Rudimentär funktioniert das auch, allerdings "verschluckt" der AVR 
Nachrichten.

Meine Testapplikation auf dem AVR soll folgendes tun:
Eine empfangene Nachricht in ein Senderegister kopieren und dann zurück 
senden.
Mit dem canplayer schicke ich zwei Nachrichten im Abstand von einer 
Sekunde und diese kommen auch wieder zurück. Schicke ich das ganze noch 
Mal, kommt die Nachricht, die davor gesendet wurde, zurück. Die zweite 
Nachricht kommt dann original zurück. Um das zu beobachten hänge ich mit 
wireshark auf der CAN Schnittstelle. Zusätzlich habe ich einen 
Logic-Analyzer mit CAN-Interpreter an CAN-TX/RX welcher mir die Ausgaben 
des wireshark bestätigt.

hier noch ein paar Auszüge aus dem Quelltext. Das Ganze ist auch 
Bestandteil einer eigenen Framework Entwicklung, weswegen der Code hier 
etwas anders aussieht als üblich. Wenn noch jemand weitere Informationen 
oder Auszüge benötigt, bitte einfach melden.


Das CANIF des Controllers wird folgendermaßen initialisiert:

#define    TX_MOB  0
#define    RX_MOB  1
#define    OFFSET  0x3

Hier verwende ich die ersten beiden Nachrichten. Der Offset springt um 
3*32 bit in den MOBCTRLn Registern. (Im Datenblatt sind es 12*8 bit 
(0xC))

Hier die initialisierung der Register.

bool CanTransceiverAvr32::open(unsigned long baudRate) {
  GpioEnableModulePin(mRxPin,mRxFunc);
  GpioEnableModulePin(mTxPin,mTxFunc);

  mChannelAddr->CANCTRL.init     = 1;    //Initialization of the CAN channels
  while(mChannelAddr->CANSR.ces  == 1) {} ;    //wait for disabling the channel
  mChannelAddr->CANCTRL.init     = 0;
 
  //Configuration for 16MHz
  switch(baudRate) {
  case 125000:
    mChannelAddr->CANCFG.pres   = 7;
    mChannelAddr->CANCFG.prs   = 5;
    mChannelAddr->CANCFG.phs1   = 5;
    mChannelAddr->CANCFG.phs2   = 2;
    break;

  //Transmit
  (&mChannelAddr->MOBCTRL+(TX_MOB*OFFSET))->am  = 1;  //Automatic mode
  (&mChannelAddr->MOBCTRL+(TX_MOB*OFFSET))->dir  = 1;  //Transmission
  (&mChannelAddr->MOBCTRL+(TX_MOB*OFFSET))->dlc  = 8;  //Data length code
  mCanMessage[TX_MOB].msg.rtr            = 0;  // remote transmission request


  //Receive
  (&mChannelAddr->MOBCTRL+(RX_MOB*OFFSET))->am  = 0;  //Automatic mode 0
  (&mChannelAddr->MOBCTRL+(RX_MOB*OFFSET))->dir   = 0;  //Reception
  (&mChannelAddr->MOBCTRL+(RX_MOB*OFFSET))->dlc  = 8;  //Data length code
  mCanMessage[RX_MOB].msg.rtr            = 0;  // remote transmission request

  mChannelAddr->CANCFG.ovrm             = 1;  //Overrun mode disabled
  mChannelAddr->CANCFG.cmode             = 0;  //Operating mode = Normal mode
  mChannelAddr->CANCFG.sm             = 1;  //Sampling method
  mChannelAddr->CANCFG.sjw             = 1;  //Synchronization Jump Width
  mChannelAddr->CANCTRL.ovrq            = 1;  //Overload frame to provide extra delay between two messages

  mChannelAddr->canramb              = (long unsigned int)mCanMessage;
  mChannelAddr->CANCTRL.cen             = 1;  //Channel enable
  // CANSR.ces bit is set after 11 consecutive recessive bits (BUS-idle) are detected on Bus.
  while(!mChannelAddr->CANSR.ces){};            //wait for channel enable status
  // Initialization done.
  mChannelAddr->CANISCR.lsmob            = 0b111111;
  mChannelAddr->mober                = 1<<RX_MOB;  //Enable MOb1
  return true;
}

Hier die receive()-Methode

unsigned short CanTransceiverAvr32::receive(int *mode, uint32_t *id, uint8_t *canData,int *length) {

  mChannelAddr->mober   = 1<<RX_MOB;  //Enable MOb1
  if(mChannelAddr->CANSR.rs){
      while(!(&mChannelAddr->MOBSR+(RX_MOB*OFFSET))->rxok) {};
        *mode    = mCanMessage[RX_MOB].msg.ide;
        *id     = mCanMessage[RX_MOB].msg.id;
        *length   = (&mChannelAddr->MOBCTRL+(RX_MOB*OFFSET))->dlc;
        canData[0]   = mCanMessage[RX_MOB].msg.db0;
        canData[1]   = mCanMessage[RX_MOB].msg.db1;
        canData[2]   = mCanMessage[RX_MOB].msg.db2;
        canData[3]  = mCanMessage[RX_MOB].msg.db3;
        canData[4]   = mCanMessage[RX_MOB].msg.db4;
        canData[5]   = mCanMessage[RX_MOB].msg.db5;
        canData[6]   = mCanMessage[RX_MOB].msg.db6;
        canData[7]   = mCanMessage[RX_MOB].msg.db7;
        *length   = (&mChannelAddr->MOBCTRL+(RX_MOB*OFFSET))->dlc;

        (&mChannelAddr->MOBSCR+(RX_MOB*OFFSET))->rxok   = 1;
        mCanMessage[RX_MOB].msg.rtr            = 0;
        mChannelAddr->mober                  = 1<<RX_MOB; //enable MOb1
        return 1;
      }
  }
return 0;
}

Und hier die transmit()-Methode:

bool CanTransceiverAvr32::transmit(int mode, uint32_t id, uint8_t *canData,int length) {
  mCanMessage[TX_MOB].raw.data0          = 0;  //delete old data
  mCanMessage[TX_MOB].raw.data1          = 0;
  mCanMessage[TX_MOB].raw.idRaw          = 0;
  (&mChannelAddr->MOBSCR+(TX_MOB*OFFSET))->txok   = 1; // Reset TX_OK
  mChannelAddr->mober      = 0<<TX_MOB;  //disable MOb0
  (&mChannelAddr->MOBCTRL+(TX_MOB*OFFSET))->am  = 0;  // No automatic transmit
  (&mChannelAddr->MOBCTRL+(TX_MOB*OFFSET))->dir  = 0;  // No transmit
  mCanMessage[TX_MOB].msg.id            = id;
  mCanMessage[TX_MOB].msg.ide            = mode;
  mCanMessage[TX_MOB].msg.rtr            = 1;
  mCanMessage[TX_MOB].msg.undef1          = 0;
  mCanMessage[TX_MOB].msg.db0           = canData[0];
  mCanMessage[TX_MOB].msg.db1           = canData[1];
  mCanMessage[TX_MOB].msg.db2           = canData[2];
  mCanMessage[TX_MOB].msg.db3           = canData[3];
  mCanMessage[TX_MOB].msg.db4           = canData[4];
  mCanMessage[TX_MOB].msg.db5           = canData[5];
  mCanMessage[TX_MOB].msg.db6           = canData[6];
  mCanMessage[TX_MOB].msg.db7           = canData[7];

  // Once data is written in MOb-Area use MOBCTRL to take control of message
  (&mChannelAddr->MOBCTRL+(TX_MOB*OFFSET))->dlc  = length;
  (&mChannelAddr->MOBCTRL+(TX_MOB*OFFSET))->dir  = 1;  // Transmit
  mChannelAddr->mober                = 1<<TX_MOB;  //enable MOb0
                                  // MOb will be send if idle state is detected
                                  // (11 consecutive recessive bits)
  while(!mChannelAddr->CANSR.ts){};            //Transmission status
  if(!(&mChannelAddr->MOBSR+(TX_MOB*OFFSET))->txok) {
    return false;
  }
  else {
    (&mChannelAddr->MOBSCR+(TX_MOB*OFFSET))->txok = 1;
  }  return true;
}

Zum Schluß noch ein Auszug aus der main()

void main() {
...
    // canTr is a pointer to a CAN-Transceiver from the framwork.
    CanTransceiver   *canTr=can->GetTransceiver(0);
    canTr->open(125000);
      while(true){
         if(canTr->receive(&mode,&id,canData,&length)>0){
            canTr->transmit(mode,id+1,canData,length);
        }
    }

Interrupt getrieben ist das Ganze nicht! Da es sich um eine 
Testapplikation handelt polle ich den Nachrichtenempfang.

Ich empfange eine Nachricht in dem ich das RS-Register (reception state) 
abfrage. Ist es gesetzt polle ich auf RXOK (Es sind kein Flags im 
MASK-Register gesetzt), dann hole ich mir die Daten aus dem RAM, 
schreibe sie in das TX-MOb mit einer um eins erhöhten ID um die 
Nachrichten unterscheiden zu können und setze den entsprechenden 
TX-ENABLE zu senden. Wie gesagt, das Ganze funktioniert das erste Mal, 
wenn ich den canplayer erneut dieselben Daten senden lasse geht die 
erste Nachricht korrekt über den Bus, aber die letzte vom ersten 
Durchlauf kommt wieder zurück.

Ich hoffe es ist klar geworden, was für ein Problem ich habe. Ich 
versuche in den nächsten Tagen noch einen Screenshot vom wireshark an zu 
hängen.

Okay, ich habe gerade festgestellt, dass in diesem Beitrag noch nicht 
ein einziges Fragezeichen steht :-)

Hat jemand von Euch vielleicht eine Idee was ich bei der Initialisierung 
vergessen habe oder was am Konzept des Nachrichtenempfangs falsch ist? 
Evtl. irgendwas zu schnell? Delays sind nicht drin.

Danke im Vorraus

Skyfox

[Felix D. (skyfox)]

Hallo noch Mal.

Ich glaube, ich habe mittlerweile eine Lösung für mein Problem. 
Vielleicht hilft es nur, bis ich mit dem CAN tatsächlich unter Last 
arbeiten will, aber für meinen Test reicht es.

Ein Delay in der receive() Methode von 10ms hat geholfen. (Bei weiteren 
Problemen erde ich erst Mal daran schrauben.)

    ...
    while(!(&mChannelAddr->MOBSR+(RX_MOB*OFFSET))->rxok) {};
    delay_us(10000)
    ...
     }

Bei 16 MHz habe ich delay_us() mit dem COUNT Register (COUNT/16) in us 
implementiert.

Vielleicht hilft's ja jemandem weiter.

Schönan Gruß

Skyfox