CAN Datentransfer auf Basis von kreatives-chaos.com

[Hugo P. (portisch)]

Hallo,

ich arbeite nun schon etwas länger daran wie am besten mehr als 8 Byte 
Nutzdaten per CAN Bus überträgt.

Da ich nichts gefunden habe, habe ich mich an kreatives-chaos.com 
orientiert. Besser gesagt an deren CAN Bootloader:
http://www.kreatives-chaos.com/artikel/can-bootloader

Dazu vielen Dank an die Macher des Bootloaders und der can-lib!!

Ich habe mich für dieses Protokoll entschieden, da ich Slaves im 
Netzwerk über den CAN Bus updaten will. Somit kann das Protokoll für den 
Normalbetrieb und den Flashvorgang verwendet werden.

Im Normalbetrieb wird das Protokoll "abgespeckt" verwendet. D.h. z.B. 
der Message_Counter wird nicht verwendet. Auch fehlen dann AKN/NAKN da 
es sich bei mir im System um nicht so wichtige Daten handelt.

Der Source ist noch nicht 100%'ig und soll als Basis für andere dienen 
die mehr als 8 Bytes übertragen wollen.
Ich selber übertrage im Normalfall ca. 10-15 Bytes. Es sind Daten wie 
z.b. von einem DS2438 (Spannung & Temp) oder DS18S20 (Temp).
D.h. es werden die großen Distanzen mit CAN Bus überbrückt. Die OneWire 
Kabel sind dann eher kurz gehalten.

Flashen mache ich über V-USB. Ich sende 32 Byte Pakete an den 
CAN-Master. Dieser zerlegt sie in der SendCANMessage in die einzelnen 
CAN Nachrichten und leitet sie an die angegebene Slave NodeID.

Um einen Atmega168 mit MCP2515 ein ~12kB Flash zu übertragen brauche ich 
dann bei 10kbps ca. 72 Sekunden.

Wichtig ist noch bei can-lin:
In der "mcp2515_send_message" sollten am besten 2 TX Buffer deakiviert 
werden. Somit steht nur ein TX Buffer zur Verfügung und es entsteht 
Automatisch ein "Gänsemarsch" der CAN Nachrichten. Ansonsten dreht der 
MCP2515 die Nachrichten durcheinander und der Message_Counter kommt aus 
dem Takt.

Viel Spass damit!

Beispiel "WHO_IS_ONLINE" Request vom Master ans Netzwerk:

        can_transfer.Board_Identifier = CAN_NODE_NR;
        can_transfer.CAN_MessageID = CAN_WHO_IS_ONLINE;
        can_transfer.T_OR_C = WHO_IS_ONLINE | REQUEST;        
        SendCANMessage(&can_transfer, NULL, NULL, 0);

Einen bestimmten Slave reseten:

        can_transfer.Board_Identifier = slave_nodeid;
        can_transfer.CAN_MessageID = CAN_RESET_SLAVE;
        can_transfer.T_OR_C = RESET_SLAVE | REQUEST;        
        SendCANMessage(&can_transfer, NULL, NULL, 0);    
      
        ret = WaitforCANResponse(&can_transfer, NULL, NULL, NULL);

[canni (Gast)]

Was ist denn ein >> CAN-MAster << ?

[Hugo P. (portisch)]

Der CAN Master ist der mit der NodeID 0x00.
Slaves sind mit der NodeID 0x01-0xFF.

Ich habe nur einen Master der die Schnittstelle vom CAN Bus System nach 
"Aussen" ist. Die Slaves schicken ihre Daten an den Master, dieser gibt 
sie nach Aussen (z.B. über RS232, V-USB,...) ab.

[Leo (Gast)]

Hallo Hugo,

ich habe mir mal deinen Code angeschaut. Wo verwendest du diese Funktion 
"WaitforCANResponse" ? Könntest du eine Beispielapplikation für den 
Master hier reinposten ? Das wäre super. Danke.

[Hugo P. (portisch)]

Die "WaitforCANResponse" ist um auf ein AKN/NAKN zu warten.
Maximal 500ms. Er wartet auf eine Nachricht von der angegeben Node ID.
Andere Nachrichten die sich dazwischen schumeln werden in den Buffer 
geladen.

Auch habe ich noch eine neue Funktion hinzugefügt um zu überprüfen ob 
gerade ein Transfer aktiv ist: "CANTranserActive"

Ich habe im Master im Timer0 z.B. eine 1-Wire Devices Abfrage. Diese 
sollte aber nur durchgeführt werden wenn gerade kein CAN Transfer aktiv 
ist um Bufferüberlappungen zu verhindern.

Auch noch kurz zur Erklärung:
In der SendCANMessage wird die Message ID mit der Node Nummer "ver-ort".

D.h.
Master -> Slave:
CAN_NODE_NR = 0x00
aus 0x300 | CAN_NODE_NR = 0x300

Slave -> Master:
CAN_NODE_NR = 0x11
aus 0x300 | CAN_NODE_NR = 0x311

Das bedeutet, dass man durch die CAN_NODE_NR die Priorität der Slaves 
steuern kann. Der mit der CAN_NODE_NR = 0x01 hat auf dem CAN Bus 
gegenüber den Slave mit der CAN_NODE_NR = 0x02 Vorrang.

Der Filter ist bei den Slaves so eingestellt, dass nur Messages mit 
0xX00 und der WHO_IS_ONLINE empfangen werden. Also nur Nachrichten vom 
Master.
Die Slaves können sich nichts untereinander schicken. Das kann man aber 
durch andere Filtereinstellungen ändern.
Der Master filtert keine Nachrichten und bekommt alle Message IDs.

Kurze Beispiele:
Slave:

CAN_HEADER can_transfer;
uint8_t can_message_count;

// filter for:
// receive only messages with matching node id 0xX00 (Messages from CAN Master)
// receive onyl message CAN_WHO_IS_ONLINE for response
prog_uint8_t can_filter[] = {
  // Group 0
  MCP2515_FILTER(0x000),        // Filter 0
  MCP2515_FILTER(0x000),        // Filter 1
    
  // Group 1
  MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 2
  MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 3
  MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 4
  MCP2515_FILTER(CAN_WHO_IS_ONLINE),  // Filter 5
    
  MCP2515_FILTER(0x0FF),        // Mask 0 (for group 0)
  MCP2515_FILTER(0x7FF),        // Mask 1 (for group 1)
};

int main(void)
{
  uint8_t buffer[64];
  uint8_t len;
  
  cli();
  
  /* Even if you don't use the watchdog, turn it off here. On newer devices,
   * the status of the watchdog (on/off, period) is PRESERVED OVER RESET!
   */
  wdt_disable();                            // first disable watchdog
    
  wdt_enable(WDTO_4S);                        // enable again watchdog
  sei();                                // global interrupt enable
  
  // init can data:
  InitCANBus(BITRATE_10_KBPS, can_filter);    
    
  // send dummy message to signal to be online:
  can_transfer.Board_Identifier = CAN_NODE_NR;
  can_transfer.CAN_MessageID = CAN_WHO_IS_ONLINE;
  can_transfer.T_OR_C = WHO_IS_ONLINE | REQUEST;        
  SendCANMessage(&can_transfer, NULL, NULL, 0);
    
    while(1)
    {
    wdt_reset();
    
    // Check if a new message was received
    if (ReceiveCANMessage(&can_transfer, NULL, &buffer[0], &len))
    {  
              
      switch (can_transfer.T_OR_C & COMMAND_MASK)
      {
        // Online Request was received, send response
        case WHO_IS_ONLINE:  
          can_transfer.Board_Identifier = CAN_NODE_NR;
          can_transfer.CAN_MessageID = CAN_WHO_IS_ONLINE;
          can_transfer.T_OR_C = WHO_IS_ONLINE | REQUEST;        
          SendCANMessage(&can_transfer, NULL, NULL, 0);      
        break;            
        
        // Reset Slave was received, make watchdog reset    
        case RESET_SLAVE:          
          if (can_transfer.Board_Identifier == CAN_NODE_NR)
          {
            can_transfer.Board_Identifier = CAN_NODE_NR;
            can_transfer.CAN_MessageID = CAN_RESET_SLAVE;
            can_transfer.T_OR_C = RESET_SLAVE | SUCCESSFULL_RESPONSE;        
            SendCANMessage(&can_transfer, NULL, NULL, 0);            

            _delay_ms(50);
            for (;;);
          }            
        break;
      }      
            
    }
    }
}

Master:

CAN_HEADER can_transfer;
uint8_t can_message_count;

// filter for:
// receive all messages
prog_uint8_t can_filter[] = {
  // Group 0
  MCP2515_FILTER(CAN_NODE_NR),    // Filter 0
  MCP2515_FILTER(CAN_NODE_NR),    // Filter 1
    
  // Group 1
  MCP2515_FILTER(CAN_UPDATE_SLAVE_RESPONSE),  // Filter 2
  MCP2515_FILTER(CAN_UPDATE_SLAVE_RESPONSE),  // Filter 3
  MCP2515_FILTER(CAN_UPDATE_SLAVE_RESPONSE),  // Filter 4
  MCP2515_FILTER(CAN_UPDATE_SLAVE_RESPONSE),  // Filter 5
    
  MCP2515_FILTER(0),        // Mask 0 (for group 0)
  MCP2515_FILTER(0),        // Mask 1 (for group 1)
};

int main(void)
{
  uint8_t buffer[64];
  uint8_t len;
    
  cli();
  
  /* Even if you don't use the watchdog, turn it off here. On newer devices,
   * the status of the watchdog (on/off, period) is PRESERVED OVER RESET!
   */
  wdt_disable();                            // first disable watchdog
  
  wdt_enable(WDTO_4S);                        // enable again watchdog
  sei();                                // global interrupt enable  
  
  InitCANBus(BITRATE_10_KBPS, can_filter);    
  
  uart_put(WHO_IS_ONLINE, CAN_NODE_NR, NULL, 0);

    while(1)
    {
    wdt_reset();
    
      if (ReceiveCANMessage(&can_transfer, NULL, &buffer[0], &len))
      {      
        // CAN Message received, send it to rs232    
        uart_put(can_transfer.T_OR_C & COMMAND_MASK, can_transfer.Board_Identifier, &buffer[0], len);
        
        // also send it to USB host
        SendUSBInterrupt(NewDataAvailable, can_transfer.Board_Identifier,
          can_transfer.T_OR_C & COMMAND_MASK, &buffer[0], len);            
      }
    }
}

Die Steuerung der Slaves mache ich über V-USB. Kann aber per RS232 
(uart_getc) auch gemacht werden. Die Befehle IDENTIFY, START_APP, 
SET_ADDRESS und DATA werden nur für den echten CAN Bootloader für das 
Flashupdate benötigt.

Im "receive_buffer" stehen die USB Daten vom Host:
receive_buffer[0]: Report ID
receive_buffer[1]: Command
receive_buffer[2]: Command Parameter

Master -> Slave Handling:

/* usbFunctionWrite() is called when the host sends a chunk of data to the
 * device. For more information see the documentation in usbdrv/usbdrv.h.
 */
uchar usbFunctionWrite(uchar *data, uchar len)
{
  uint8_t ret;
  uint8_t rlen;
  uint8_t buffer[32];
  
    if(len > bytesRemaining)
        len = bytesRemaining;    
        
    bytesRemaining -= len;
  
  // store received data
  if (len > 0)
    memcpy(&receive_buffer[receive_data_len], &data[0], len);
      
  receive_data_len += len;  
  
    if(bytesRemaining == 0)
  {
    if ( DoWriteReport == USB_Command )
    {
      switch (receive_buffer[1])
      {
      // who is online in the network
      case WHO_IS_ONLINE:
        can_transfer.Board_Identifier = CAN_NODE_NR;
        can_transfer.CAN_MessageID = CAN_WHO_IS_ONLINE;
        can_transfer.T_OR_C = WHO_IS_ONLINE | REQUEST;        
        SendCANMessage(&can_transfer, NULL, NULL, 0);    
        break;
      // reset a specified slave node
      case RESET_SLAVE:
        can_transfer.Board_Identifier = receive_buffer[2];
        can_transfer.CAN_MessageID = CAN_RESET_SLAVE;
        can_transfer.T_OR_C = RESET_SLAVE | REQUEST;        
        SendCANMessage(&can_transfer, NULL, NULL, 0);    
      
        ret = WaitforCANResponse(&can_transfer, NULL, NULL, NULL);
        // send back response to the host
        SendUSBInterrupt(NewDataAvailable, receive_buffer[2], RESET_SLAVE | ret, NULL, 0);
        break;    
      // send identify to a specified slave node
      case IDENTIFY:
        // first disable onewire timer before start flashing
        // disable timer0:
        #ifdef ONEWIRE                    
        TCCR0B = 0;
        #endif
        
        can_transfer.Board_Identifier = receive_buffer[2];
        can_transfer.CAN_MessageID = CAN_UPDATE_SLAVE_FLASH;
        can_transfer.T_OR_C = IDENTIFY | REQUEST;  
      
        can_message_count = -1;      
        SendCANMessage(&can_transfer, &can_message_count, NULL, 0);      
  
        ret = WaitforCANResponse(&can_transfer, NULL, &buffer[0], &rlen);
        // send back response to the host
        SendUSBInterrupt(NewDataAvailable, receive_buffer[2], IDENTIFY | ret, &buffer[0], rlen);              
        break;    
      // send START_APP to a specified slave node
      case START_APP:
        can_transfer.Board_Identifier = receive_buffer[2];
        can_transfer.CAN_MessageID = CAN_UPDATE_SLAVE_FLASH;
        can_transfer.T_OR_C = START_APP | REQUEST;  
          
        SendCANMessage(&can_transfer, &can_message_count, NULL, 0);      
  
        ret = WaitforCANResponse(&can_transfer, NULL, &buffer[0], &rlen);
        // send back response to the host
        SendUSBInterrupt(NewDataAvailable, receive_buffer[2], START_APP | ret, &buffer[0], rlen);
        
        // flashing of slave is finished
        // restart timer if onewire is used
        #ifdef ONEWIRE
        TCCR0B = (1<<CS01);
        #endif                      
        break;              
      }    
    }
    else
    if ( DoWriteReport == USB_Bootloader_Data )
    {
      switch (receive_buffer[1])
      {
      // set address for slave
      case SET_ADDRESS:
        can_transfer.Board_Identifier = receive_buffer[2];
        can_transfer.CAN_MessageID = CAN_UPDATE_SLAVE_FLASH;
        can_transfer.T_OR_C = SET_ADDRESS | REQUEST;        
        SendCANMessage(&can_transfer, &can_message_count, &receive_buffer[3], 4);  
              
        ret = WaitforCANResponse(&can_transfer, NULL, &buffer[0], &rlen);
        // send back response to the host
        SendUSBInterrupt(NewDataAvailable, receive_buffer[2], SET_ADDRESS | ret, &buffer[0], rlen);    
      break;
    
      // send data to slave
      case DATA:
        can_transfer.Board_Identifier = receive_buffer[2];
        can_transfer.CAN_MessageID = CAN_UPDATE_SLAVE_FLASH;
        can_transfer.T_OR_C = DATA | REQUEST;        
        SendCANMessage(&can_transfer, &can_message_count, &receive_buffer[3], 32);  
              
        ret = WaitforCANResponse(&can_transfer, NULL, &buffer[0], &rlen);
        // send back response to the host
        SendUSBInterrupt(NewDataAvailable, receive_buffer[2], DATA | ret, &buffer[0], rlen);    
      break;    
      }            
    }          

    receive_data_len = 0;
        return 1;               /* end of transfer */
  }
  
    return bytesRemaining == 0;                               /* return 1 if this was the last chunk */
}

Man beachte auch, dass maximal 4 * 0x0F an Datalength möglich ist.
Also maximal 64 Bytes die mit einer SendCANMessage möglich sind.

Hier noch ein Beispiel wie ich im Slave im Timer0 überprüfe ob ein neuer 
IR-Code empfangen wurde. Die CAN Message ID IRMP_DECODED = 0x300.

void check_for_new_irmp_data(void)
{
  if (irmp_get_data (&irmp_data))    
  {
    if (!(irmp_data.flags & IRMP_FLAG_REPETITION))        // first check if the IR command is repeated
    {
      RepeatCounter = 0;                    // new command received, reset RepeatCounter
    }                                  
    else
    {  
      RepeatCounter++;                    // still the same command, inc RepeatCounter
    }    
      
    if ((RepeatCounter == 0) | ( RepeatCounter >= MinRepeats))  // only send interrupt if first command, or Repeatcounter >= MinRepeats
    {
      if (RepeatCounter >= MinRepeats)  
        RepeatCounter = MinRepeats;              // fix overflow for long key push

      // Send the new message
      // slave handling      
      can_transfer.Board_Identifier = CAN_NODE_NR;
      can_transfer.CAN_MessageID = CAN_IRMP_DECODED;
      can_transfer.T_OR_C = IRMP_DECODED | REQUEST;        
      SendCANMessage(&can_transfer, NULL, (uint8_t *)&irmp_data, sizeof(IRMP_DATA));              
    }      
  }
}

Anbei auch ein Bild wie ich dann die Daten per V-USB auf dem Windows PC 
auswerte.

Beispiel:
Device Data: USB AVR Device,          (USB Device Name)
ReportID: 0x01,                       (USB Report ID)
NodeID: 0x11,                         (CAN Node ID von wo die Daten 
kommen)
Command: 0x09,                        (CAN Command (Temperatur CMD))
Length: 0x0E,                         (Daten länge)
Data: 0x26F610550100002FE900F401A900  (eigentliche Daten)

{26}F61055010000[2F]                  ({DS2438 Family} Serial [CRC-8]])
E900                                  (Temperatur: 23,3°C)
F401                                  (Versorgungsspannung: 5,00V)
A900                                  (Sensorspannung: 1,69V)

[MarcusW (Gast)]

Kennst du das hier:

http://de.wikipedia.org/wiki/ISO_15765-2

Ansonsten natürlich immer gut, wenn man sich selber Gedanken macht und 
eine Lösung findet.

[Hugo P. (portisch)]

MarcusW schrieb:
> Kennst du das hier:
>
> http://de.wikipedia.org/wiki/ISO_15765-2
>
> Ansonsten natürlich immer gut, wenn man sich selber Gedanken macht und
> eine Lösung findet.

Danke für den Tipp!
Aber mein Ziel war es, dass ich ja von einem CAN Teilnehmer einen 
anderen per CAN (CAN Bootloader) updaten kann. Darum habe ich mich an 
das "Protokoll" von kreatives-chaos.com gehalten.

[Leo (Gast)]

Hallo Huga,

erstamal danke für den Code. Was mir noch aufgefallen ist, das die 
FUnktion WaitforCANResponse nicht in der Master Applikation verwendet 
wird. Eigentlich müsste ein Timeout im Master implementiert werden. Beim 
Slave macht es keinen Sinn! Wenn der Master nach einer gewissen Zeit 
kein Response vom Slave bekommt dann sollte der Timeout zuschlagen.

[Hugo P. (portisch)]

Leo schrieb:
> Hallo Huga,
>
> erstamal danke für den Code. Was mir noch aufgefallen ist, das die
> FUnktion WaitforCANResponse nicht in der Master Applikation verwendet
> wird. Eigentlich müsste ein Timeout im Master implementiert werden. Beim
> Slave macht es keinen Sinn! Wenn der Master nach einer gewissen Zeit
> kein Response vom Slave bekommt dann sollte der Timeout zuschlagen.

Die WaitforCANResponse verwende ich nur in der usbFunctionWrite.
Also im Master. Hauptsächlich nur wegen den originalen CAN Bootloader.
Die WaitforCANResponse überprüft ca. 500ms lang ob eine passende 
Nachricht empfangen wird.

z.b. im switch case IDENTIFY schicke ich eine CAN Message vom Master an 
den Slave. Danach wird auf einen Response von dem Slave gewartet.

Im normalen Datentransfer zwischen den CAN Nodes verzichte ich auf eine 
Bestätigung.

[Frank Bockwurst (Gast)]

Sucht mal im Netz unter BOSCH CAN_FD bzw. CAN Flexible Datarate.

Hier geht mehr Datenrate und mehr Payload. Es wird aber noch dauern, bis 
die Chips verfügbar sein werden...

[Entwickler (Gast)]

Hallo Huga,

mich würde mal ibnteressieren, ob dein CAN Transportprotokoll auch dann 
noch funktioniert, wenn niederpriore CAN Nachrichten auf dem Bus 
vorhanden sind.

[Hugo P. (portisch)]

Durchgetestet habe ich es noch nicht zu 100%.

Aber als Beispiel:
Der "Master" empfängt einen Datentransfer von 5 Nachrichten mit der 
MSGID 0x302.
Jetzt kommt aber dazwischen ein anderer auf die Idee einen Transfer mit 
der MSGID 0x301 auf den Weg zu schicken.
Somit schummelt sich die 0x301 zwischen den 0x302 Nachrichten.

Der "Master" weis aber, dass der angefangen Transfer von der 0x302 noch 
nicht fertig ist und buffert somit automatisch die 0x301 Nachrichten. 
Erst wenn der Transfer mit der 0x302 vorbei ist wird der Buffer mit den 
0x301 Nachrichten abgearbeitet.

Das Priority/Kollision Handling wird von MCP2515 selber erledigt.