Problem: AT90CAN zu AT90CAN digitales CAN Signal

[Max M. (centech)]

Hallo,

ich versuche seit Wochen eine CAN Kommunikation zwischen 2 AT90CAN MC 
herzustellen. Dazu habe ich schon diverse Codebeispiele (auch hier aus 
diesem Forum) ausprobiert und Datenblätter gewälzt. Mein Problem bisher:

Scheinbar sendet ein MC ein Signal, bekommt aber kein ACK, bzw erkennt 
der Empfänger das CAN Package nicht.

Ich bin gerade am überlegen ob es ein Hardware (Denk-) Fehler sein kann, 
ich habe einfach die CAN TX Leitung des einen AT90 mit der CAN RX 
Leitung verbunden und umgekehrt (GND natürlich auch). Ist mir hier schon 
ein Fehler unterlaufen? Ich bin davon ausgegangen, dass man das Digitale 
Signal nicht terminieren muss.

Anbei auch mein Code, ich würde mich über Hilfe sehr freuen! Vielen 
Dank.


main.c

/*
 * Main Modul
 * Author: Max
 */ 

//#define F_CPU 1600000UL
#include <avr/io.h>
#include <avr/delay.h>

#include "uart.h"
#include "can.h"
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

//#define Sender
//#define FakeCan 



int main(void)
{
  
  cli();
  // initialisieren des at90can
  #ifndef FakeCan
    can_init();
    struct MOb mymsg;     
    mymsg.id=1;
    mymsg.data[0]="H";
    mymsg.data[1]="a";
    mymsg.data[2]="l";
    mymsg.data[3]="l";
    mymsg.data[4]="o";
    mymsg.data[5]="!";
    mymsg.data[6]="!";
    mymsg.data[7]="!";
  #else
  //FakeCan
  DDRD |= 1 << PD5; // Can Output
  PORTD |= ( 1 << PD5 );
  #endif
  // enable interrupts
  sei();
    
  
  DDRE |= 1 << PE5; // LED Output
  PORTE |= 1 << PE5; // LED start an
  
  DDRE |= 1 << PE6; // LED Output
  
  uart_init();
  uart_print("======================\n");
  uart_print("Programm Start\n");
  #ifdef Sender
  uart_print("Ich bin Sender\n");
  PORTE &=~ 1 << PE6; // LED start aus
  _delay_ms(2000*16);
  #else // empfänger
  uart_print("Ich bin Empfaenger\n");
  PORTE |= 1 << PE6; // LED start an
  PORTE &=~ 1 << PE5; // LED start aus
  _delay_ms(1000*16);
  #endif
  #ifdef FakeCan
  uart_print("!!!!! FAKE CAN ACTIVATED!!!!!\n");
  #endif
  uart_print("======================\n\n");


  uart_print("Schleifeneingang\n");
    while(1)
    {
  #ifdef FakeCan
  _delay_us(10*16);
  PORTD ^= ( 1 << PD5 ); // toggle CAN Signal  
  #else  
    #ifdef Sender
    _delay_ms(1000*16);
    PORTE ^= ( 1 << PE5 );
    can_tx(mymsg);
    uart_print("Sende!!\n");
    #else // empfänger
    // Check if a new message was received (via can interrupt)
    #endif
  #endif // fakecan ende  
    
     
    }
}

can.h

#ifndef CAN_H
#define CAN_H

#include <avr/io.h>
#include <avr/signal.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <string.h>

struct MOb
{
  unsigned long id;
  unsigned char data [8];
};

void can_init (void);
void can_tx (struct MOb msg);

#endif

can.c

#include "can.h"


/*******************************************************************
CAN initialization:
Mailbox 0: Receive  --> interrupt
Mailbox 1: Transmit --> polling
*******************************************************************/
void can_init (void)
{
  CANGCON |= (1<<SWRES);            //reset CAN interface
  
  //reset all MObs
  for (unsigned char i=0; i<15; i++)
  {
    CANPAGE = (i<<4);            //select MOb
    CANCDMOB = 0;              //disable MOb
    CANSTMOB = 0;              //clear status
    CANIDT1 = 0;              //clear ID
    CANIDT2 = 0;
    CANIDT3 = 0;
    CANIDT4 = 0;
    CANIDM1 = 0;              //clear mask
    CANIDM2 = 0;
    CANIDM3 = 0;
    CANIDM4 = 0;
    for (unsigned char j=0; j<8; j++)
      CANMSG = 0;              //clear data
  }

  //bit timing -> datasheet page 260 (check table)
  CANBT1 = 0xC6; //500kBits/s  // 0x12;    //  100 kBit/s  0xC6;    //  10 kBit/s
  CANBT2 = 0x0C;//0x04;
  CANBT3 = 0x37;//0x13;
  

  
  CANGCON = (1<<ENASTB);            //start CAN interface
  
  //configure MOb0
  CANPAGE = (0<<4);
  CANIDT1 = 0;                //ID
  CANIDT2 = 0;
  CANIDT3 = 0;
  CANIDT4 = 0;
  CANIDM1 = 0;                //get all messages
  CANIDM2 = 0;                //1 = check bit
  CANIDM3 = 0;                //0 = ignore bit
  CANIDM4 = (1<<IDEMSK);
  CANCDMOB = (1<<CONMOB1) | (1<<IDE);    //reception, ext. ID
  
  //interrupts
  CANGIE = (1<<ENIT) | (1<<ENRX) | (1<<ENERR) | (1<<ENERG); //enable receive interrupt  //(1<<ENERR) | (1<<ENERG);    //enable error interrupt
  CANIE1 = 0;
  CANIE2 = (1<<IEMOB0); //Set MOB for which Interrupts are enabled
  CANSIT1 = 0;
  CANSIT2 = 0;
  
  while (!(CANGSTA & (1<<ENFG)));      //wait until module ready
}

/*******************************************************************
CAN transmission via mailbox 1 (polling)
*******************************************************************/
void can_tx (struct MOb msg)
{  
  //enable MOb1, auto increment index, start with index = 0
  CANPAGE = (1<<4);
  
  CANCDMOB = (1<<IDE) | (8<<DLC0);      //set IDE bit, length = 8
  
  msg.id <<= 3;                //write 29 Bit identifier
  CANIDT4 = (unsigned char) (msg.id&0xF8);
  CANIDT3 = (unsigned char) (msg.id>>8);
  CANIDT2 = (unsigned char) (msg.id>>16);
  CANIDT1 = (unsigned char) (msg.id>>24);
  
  for (unsigned char i=0; i<8; i++)    //put data in mailbox
    CANMSG = msg.data [i];
  
  CANCDMOB |= (1<<CONMOB0);          //enable transmission
  uart_print("wait for TXOK...!\n");
  while (!(CANSTMOB & (1<<TXOK)));      //wait until complete
  uart_print("...got it!\n");
  CANSTMOB &= ~(1<<TXOK);          //reset flag
}

/*******************************************************************
CAN receive interrupt service routine (mailbox 0)
*******************************************************************/
SIGNAL (SIG_CAN_INTERRUPT1)            //receive interrupt
{
  
  PORTE |= 1 << PE6; // LED start an
  PORTE |= 1 << PE5; // LED start an
  uart_print("\n\nCAN INTERRUPT!\n");
  unsigned char temp = CANPAGE;        //save CANPAGE
  struct MOb msg;
  
  CANPAGE = 0x00;                //select MOb0
  CANSTMOB &= ~(1<<RXOK);          //clear interrupt flag
  
  for (unsigned char i=0; i<8; i++)    //get data
    msg.data [i] = CANMSG;
  
  msg.id = 0;
  msg.id |= ((unsigned long) CANIDT1<<24);  //get identifier
  msg.id |= ((unsigned long) CANIDT2<<16);
  msg.id |= ((unsigned long) CANIDT3<<8);
  msg.id |= (CANIDT4&0xF8);
  msg.id >>= 3;
  
  uart_print("id: "+msg.id);
  uart_print("\n");
  uart_print("data: "+msg.data[0]+msg.data[1]+msg.data[2]+msg.data[3]+msg.data[4]+msg.data[5]+msg.data[6]+msg.data[7]);
  uart_print("\n");
//   printf ("ID: 0x%04X%04X\r\n", (unsigned int) (msg.id>>16), (unsigned int) (msg.id&0xFFFF));
//   
//   printf ("Data: 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\r\n",
//       msg.data [0], msg.data [1], msg.data [2], msg.data [3],
//       msg.data [4], msg.data [5], msg.data [6], msg.data [7]);
  
  CANCDMOB = (1<<CONMOB1) | (1<<IDE);    //reconfig mailbox
  
  CANPAGE = temp;                //restore CANPAGE
}

[EMV (Gast)]

Normalerweise braucht man dafür einen Transiver oder zumindest 
Pullup/Pulldown-Widerstände..
Ich bin nicht ganz sicher, aber einfach RX/TX verbringen funktioniert 
vermutlich nicht sauber. Stichwort "dominant" und "recessive" bits.

Ein Fehlendes ACK könnte auch ein Baudrate-Mismatch sein.

[Rudolph (Gast)]

Die CAN-Transceiver bilden eine Schleife, das Signal das rausgeht kommt 
immer auch wieder rein.
Die beiden Controler direkt zu verbinden funktioniert doch nicht?

[Test (Gast)]

Du brauchst die can transceiver, da can mit csma/ca arbeitet und jeder 
Controller sein eigenes Signal für die aribitrierung überwachen muss. Dh 
2 transceiver und ein oder 2 abschlusswiderstände

[ich (Gast)]

Du mußt an die TX/RX-Pins des Controllers noch jeweils einen 
CAN-Transceiver anschließen. Schau dir mal den PCA82C251 an, der ist bei 
mir seit Jahren im Einsatz und hat sich bewährt. Gibt aber auch noch 
viele andere. Der Transceiver bringt dann deine eigentliche 
CAN-Schnittstelle mit CAN-High und CAN-Low. Direkt mit dem µC wird das 
nix.

[Max M. (centech)]

Danke für eure schnelle Hilfe.

Das war mir so nicht bewusst, dachte die Transceiver machen einfach nur 
das digitale Signal zu einem differenziellen und umgekehrt.

Gut dann werde ich mir noch die Transceiver besorgen.


Danke!

[gggast (Gast)]

Max M. schrieb:
> Danke für eure schnelle Hilfe.
>
> Das war mir so nicht bewusst, dachte die Transceiver machen einfach nur
> das digitale Signal zu einem differenziellen und umgekehrt.
>
> Gut dann werde ich mir noch die Transceiver besorgen.
>
> Danke!

machen sie auch... dadurch, dass die rückleitung zu deinem µC bei 
angeschossenem tranceiver immer mithochrechen kann was auf dem bus 
gerade abgeht funktioniert das csma cr verfahren. wenn du die signale 
einfach nur kreuzt sieht dein µC nur sein gegenüber und erkenn 
einenfehler, da es passieren kann, dass bei dominanten pegel 
einrezessiverauf rx gesehen wird... etc.
THEORETISCH,wenn du dafür sorgst, dass die beiden auf keien fall 
gleichzeitig senden, könnte es gehen wenn du zusätzlichzu deinen 
verbindungenen noch rx und tx von deinen controllern brückst. it zwar 
überhaupt nict sinn der sache, würde mich aber mal interessieren, ob das 
wirklch geht...

[CAN (Gast)]

Das könnte gehen wenn die TX Ausgänge OpenDrain wären. Ansonsten musst 
du einen Widerstand und 2 Dioden opfern.

[Max M. (centech)]

Ja jetzt im Nachhinein habe ich sogar ne AP von Siemens dazu gefunden,
dort ist auch erklärt wie man das ganze ohne Transeiver machen kann.

http://www.mikrocontroller.net/attachment/28831/siemens_AP2921.pdf

ist mir aber zu "bastelig" werd mir den MAX3051 Transeiver 
besorgen.(http://www.farnell.com/datasheets/663306.pdf)