Großes SJA1000 Problem. Weiß nicht mehr weiter

[Christian L. (quadratqualle)]

Hallo,

ich hab den SJA1000 so wie auf dem Schaltplan zu sehen an den Atmega8 
angeschlossen. Ich konnte den Controller erfolgreich initialisieren. 
Sprich ich hab die Register, die ich geschrieben hab am Ende ausgelesen 
und die Werte verglichen. Außerdem ist auf dem ersten Logic Analysator 
auschnitt gut zu sehen, dass der Controller nach dem Reset die Clock am 
Clock Pin auschaltet. So wie ich es wollte. Nun mein Problem sobald ich 
eine Can Nachricht senden möchte kommt nur Mist auf dem Bus an. Ich hab 
die Nachrticht mal auf dem 3. Bild rangezoomt. Es ist einfach keine 
richtig CAN Nachricht.

Ich bin mittlerweile total am verzweifeln und weiß einfach nicht wo mein 
Fehler liegt.
Ich bin über jede Hilfe dankbar.

Gruß
Christian

[Markus M. (Firma: EleLa - www.elela.de) (mmvisual)]

Einen CAN Empfänger hast Du aber schon dran ?

Um zu schauen ob CAN tut braucht es immer auch einen Empfänger der die 
CAN Nachricht quittiert (ACK Bit).

[Hugo (Gast)]

Ohne den Source wird Dir keiner helfen können.

[crazy horse (Gast)]

Ausserdem einen Transceiver-Baustein, damit der SJA auch seine eigene 
Botschaft mitlesen kann.
Hardware unvollständig, Software nicht vorhanden -> Hilfe unmöglich.

[Christian L. (quadratqualle)]

Danke für die schnellen antworten.

Als Source hab ich die CAN Lib verwendet und auf SJA1000 gestellt. Hab 
da jetzt auch schon alles möglich versucht zu ändern. Brauchte alles 
kein Erfolg. Ich poste die Ausschnitt gleich mal. Als CAN Tranceiver 
nutze ich den MCP2551. Der SJA1000 bekommt seine nachricht auch über den 
RX Pin zurück. Das is auf dem 3. Bild gut zu sehen. Channel 2 ist TX und 
Channel 4 is RX.
Müsste ich nicht trotzdem eine vernünftige Nachricht sehen, auch wen 
kein Empfänger dran ist. Dann müsste doch nur das ACK Bit nicht gesetzt 
werden? Der Rest müsste ja trotzdem stimmen?

[Christian L. (quadratqualle)]

Entschuldigung ich hab den MCP auf dem SChaltplan total vergessen.
Also hier der Code.

Initialisierung:

void sja1000_write(uint8_t address, uint8_t data)
{
  // set address
  SET(SJA1000_ALE);
  PORT(SJA1000_DATA) = address;
  _NOP();
  RESET(SJA1000_ALE);
  
  // write data
  PORT(SJA1000_DATA) = data;
  RESET(SJA1000_WR);
  _NOP();
  SET(SJA1000_WR);
}

uint8_t sja1000_read(uint8_t address)
{
  uint8_t data;
  
  // set address
  SET(SJA1000_ALE);
  PORT(SJA1000_DATA) = address;
  _NOP();
  RESET(SJA1000_ALE);
  DDR(SJA1000_DATA) = 0;
  
  // read data
  RESET(SJA1000_RD);
  _NOP();
  data = PIN(SJA1000_DATA);
  SET(SJA1000_RD);
  DDR(SJA1000_DATA) = 0xff;
  
  return data;
}
#endif

// ----------------------------------------------------------------------------
// useable can-bitrates (for calculation see http://www.kvaser.com/index.htm)

prog_char _sja1000_cnf[8][2] = {
  // 10 kbps
  {  0xe7,
    0x4d
  },
  // 20 kbps
  {  0xd3,
    0x4d
  },
  // 50 kbps
  {  0xc7,
    0x4d
  },
  // 100 kbps
  {  0xc3,
    0x4d
  },
  // 125 kbps
  {  (1<<_SJW0)|(1<<_BRP1)|(1<<_BRP0),
    (1<<TSEG13)|(1<<TSEG12)|(1<<TSEG20)
  },
  // 250 kbps
  {  (1<<_SJW0)|(1<<_BRP0),
    (1<<TSEG13)|(1<<TSEG12)|(1<<TSEG20)
  },
  // 500 kbps
  {  (1<<_SJW0),
    (1<<TSEG13)|(1<<TSEG12)|(1<<TSEG20)
  },
  // 1 Mbps
  {  (1<<_SJW0),
    (1<<TSEG12)|(1<<TSEG20)
  }
};

// ----------------------------------------------------------------------------
// init sja1000-interface

bool sja1000_init(uint8_t bitrate)
{
  if (bitrate >= 8)
    return false;
  
  #if !SJA1000_MEMORY_MAPPED
    SET(SJA1000_WR);
    SET(SJA1000_RD);
    RESET(SJA1000_ALE);
    RESET(SJA1000_CS);
    
    SET_OUTPUT(SJA1000_WR);
    SET_OUTPUT(SJA1000_RD);
    SET_OUTPUT(SJA1000_ALE);

    SET_OUTPUT(SJA1000_CS);
    DDR(SJA1000_DATA) = 0xff;
  #endif
  
  // enter reset mode
  sja1000_write(MOD, (1<<RM)|(1<<AFM));
  
  // choose PeliCAN-Mode
  sja1000_write(CDR, (1<<CANMODE) | SJA1000_CLOCK_REGISTER);
  
  // select the bitrate configuration
  sja1000_write(BTR0, pgm_read_byte(&_sja1000_cnf[bitrate][0]));
  sja1000_write(BTR1, pgm_read_byte(&_sja1000_cnf[bitrate][1]));
  
  // filter are not practical useable, so we disable them
  sja1000_write(AMR0, 0xff);
  sja1000_write(AMR1, 0xff);
  sja1000_write(AMR2, 0xff);
  sja1000_write(AMR3, 0xff);
  
  // set output driver configuration
  sja1000_write(OCR, (1<<OCTP0)|(1<<OCTN0)|(1<<OCMODE1));
  
  // enable receive interrupt
  sja1000_write(IER, (1<<RIE));
  
  // leave reset-mode
  sja1000_write(MOD, (1<<AFM));
  
  return true;
}

Nachricht senden:

uint8_t sja1000_send_message(const can_t *msg)
{
  uint8_t frame_info;
  uint8_t address;
  
  if (!sja1000_check_free_buffer() || (msg->length > 8))
    return FALSE;
  
  frame_info = msg->length | ((msg->flags.rtr) ? (1<<RTR) : 0);
  
  if (msg->flags.extended)
  {
    // write frame info
    sja1000_write(TX_INFO, frame_info | (1<<FF));
    
    // write extended identifier
    sja1000_write(20, msg->id << 3);
    sja1000_write(19, msg->id >> 5);
    sja1000_write(18, msg->id >> 13);
    sja1000_write(17, msg->id >> 21);
    
    address = 21;
  }
  else
  {
    // write frame info
    sja1000_write(TX_INFO, frame_info);
    
    const uint32_t *ptr32 = &msg->id;    // used to supress a compiler warning
    uint16_t *ptr = (uint16_t *) ptr32;
    
    // write standard identifier
    sja1000_write(18, *ptr << 5);
    sja1000_write(17, *ptr >> 3);
    
    address = 19;
  }
  
  if (!msg->flags.rtr)
  {
    for (uint8_t i = 0;i < msg->length; i++) {
      sja1000_write(address + i, msg->data[i]);
    }
  }
  
  // send buffer
  sja1000_write(CMR, (1<<TR));
  
  CAN_INDICATE_TX_TRAFFIC_FUNCTION;
  
  return TRUE;
}

[Markus M. (Firma: EleLa - www.elela.de) (mmvisual)]

Nein ohne irgend ein Empfänger sendet der CAN-Chip nicht die ganze 
Message!
Das ACK ist obligatorisch.

Auch wenn man einen zweiten SJA dran hätte und der im ListenOnly Mode 
betrieben wird, klappt das nicht.

[crazy horse (Gast)]

Markus Müller schrieb:
> Nein ohne irgend ein Empfänger sendet der CAN-Chip nicht die ganze
> Message!
> Das ACK ist obligatorisch.
>
> Auch wenn man einen zweiten SJA dran hätte und der im ListenOnly Mode
> betrieben wird, klappt das nicht.

Das stimmt so nicht. Der SJA wird schon mehrfach versuchen, die message 
zu senden. Da kein ack kommt, wird er irgendwann das Senden einstellen.

[Christoph (Gast)]

wobei ich meine, dass der SJA ohne Gegenstück den CAN-Bus "vollballert", 
er hört meines Wissens nach auch nicht auf mit senden auf sondern 
wiederholt so lange bis ein ACK-Bit gesetzt wird!

das kann man sehr schön am Oszi sehen!

[Christian L. (quadratqualle)]

Bei mir sendet der SJA1000 die komische Nachircht nur einmal, danach 
kommt nix mehr.
Ich hab als Gegenstück jetzt einen CAN Analsyer dran gehangen. Was 
allerdings keine Besserung brauchte. Außer das dieser nach der Nachricht 
vom SJA1000 Error Frame meldet.