Leonardo & Can Bus Shield Watterott

Guten Tag,

ich bin gerade dabei meinen Leonardo in Kombination mit einem Can Bus Shield von Watterott in Gebrauch zu nehmen. Ich habe auch schon viele Beiträge hier aus dem Forum und im ganzen Netz gelesen.

Nun bin ich aber eher mehr verwirrt wie aufgeklärt. Deswegen hoffe ich auf eure Hilfe !

Hier das Shield: http://www.watterott.com/de/Arduino-CANdiy-Shield

Eine Beispielanwendung: https://code.google.com/p/mechanic/

Und vorerst der Beispielsketch:

// demo: CAN-BUS Shield, receive data with check mode
// send data coming to fast, such as less than 10ms, you can use this way
// loovee, 2014-6-13


#include <SPI.h>
#include "mcp_can.h"


unsigned char Flag_Recv = 0;
unsigned char len = 0;
unsigned char buf[8];
char str[20];


MCP_CAN CAN(10);                                            // Set CS to pin 10

void setup()
{
    Serial.begin(115200);

START_INIT:

    if(CAN_OK == CAN.begin(CAN_500KBPS))                   // init can bus : baudrate = 500k
    {
        Serial.println("CAN BUS Shield init ok!");
    }
    else
    {
        Serial.println("CAN BUS Shield init fail");
        Serial.println("Init CAN BUS Shield again");
        delay(100);
        goto START_INIT;
    }
}


void loop()
{
    if(CAN_MSGAVAIL == CAN.checkReceive())            // check if data coming
    {
        CAN.readMsgBuf(&len, buf);    // read data,  len: data length, buf: data buf

        for(int i = 0; i<len; i++)    // print the data
        {
            Serial.print(buf[i]);Serial.print("\t");
        }
        Serial.println();
    }
}

/*********************************************************************************************************
  END FILE
*********************************************************************************************************/

Nun zu meinen Fragen.

In dem Beispiel steht geschrieben das unbedingt der ICSP Bus angelötet sein muss. Auf den Bildern sind die Pins vorhanden aber trotzdem ist dort nichts angeschlossen ?!

Im Prinzip möchte ich erstmal etwas empfangen und nur lesen.
Dies sollte ja mit dem obigen Sketch probelemlos funktionieren wenn die richtige Baudrate gewählt wird.

Ich habe mir auch schon einen Stecker zusammengebastelt der von der Netzwerkbuchse auf den OBD2 Stecker geht.
Wenn jetzt im Sketch Pin 10 to CS deklariert wird ist damit der Pin 10 am Rand des Boards gemeint und oder gleichzeitig der Pin 10 am Netzwerkstecker. ( Den es ja gar nicht gibt )

Wie Ihr schon merkt bin ich echt durcheinander was die Verkabelung des Ganzen angeht, ich möchte gern das OBD2 Kabel verwenden wie im Beispiel auch.

Ich hoffe Ihr könnt mir erstmal auf die Beine helfen. Wenn euch noch Informationen fehlen reiche ich die gerne nach.

Danke im vorraus und einen schönen Tag gewünscht.

CrazyRider

Der SPI Bus geht über den ICSP Stecker. Darum muss dieser Stecker auf dem Shield angelötet werden.

Wenn jetzt im Sketch Pin 10 to CS deklariert wird ist damit der Pin 10 am Rand des Boards gemeint und oder gleichzeitig der Pin 10 am Netzwerkstecker. ( Den es ja gar nicht gibt )

Der Pin 10 des Arduino Boards. Auch dort stellt ein angelöteter Stecker des Shields die Verbindung her.

Mein Board und Shield sehen zusammen aus wie auf dem Bild unten links http://www.watterott.com/de/Arduino-CANdiy-Shield

Somit ist der Pin 10 des Arduino schon mit dem Shield verbunden.

Bisher fehlt aber noch der ISCP Stecker auf dem Shield.

Ich verstehe schon das der Bus dann auch über den dafür vorgesehenen Stecker läuft. Aber wenn der sowieso frei bleibt macht das für mich keinen Unterschied. Oder muss das Arduino über den Bus mit dem Shield verbunden werden?

Mein Board und Shield sehen zusammen aus wie auf dem Bild unten links

Auf dem Bild unten links ist der Stecker auf dem Shield angelötet. Also alles richtig.

Oder muss das Arduino über den Bus mit dem Shield verbunden werden?

Über welchen Bus? den CAN Bus? NEIN! Über den SPI Bus? Wird er doch automatisch, wenn du das Shield auf den Arduino steckst.

Aber wenn der sowieso frei bleibt macht das für mich keinen Unterschied.

Da wird erstmal nichts drauf gesteckt. Aber frei bleibt er nicht, er ist nach unten mit dem Arduino verbunden.

Somit ist der Pin 10 des Arduino schon mit dem Shield verbunden.

Ja.

Super ! Danke für die Aufklärung.

Es reicht also wenn der SPI Bus nach unten hin eine Verbindung durch "Kontakt" hat ?

Ich wollte das Shield ungern an mein Arduino löten. Oder gibts da bestimmte "Mama" Stecker?

Wie?
Bahnhof!

Auf dem linken Foto ist der Stecker richtig montiert.

Auf dem rechten Foto liegt der Stecker noch daneben.
(ganz rechte Reihe, unterster Stecker)

Ja das man da nichtmehr weiss was gemeint ist ist klar. Sorry dafür.

Da stand grad ein Elefant aufm Schlauch.

Habs jetzt gerallt ;) - Ich schieb´s einfach mal auf den Montag.

Danke !

Vortrefflich!

:sunglasses: Dann sind ja jetzt alle Klarheiten beseitigt! :sunglasses:

So nachdem dies soweit dann endlich geklappt hat, habe ich das Board mit folgendem Sketch versucht zum laufen zu bringen. Bekomme aber immer die Fehlermeldung das er die Initialisierung nicht korrekt durchführt.

Muss dazu das Board schon am Can Bus Netz hängen?

// demo: CAN-BUS Shield, receive data with check mode
// send data coming to fast, such as less than 10ms, you can use this way
// loovee, 2014-6-13


#include <SPI.h>
#include "mcp_can.h"


unsigned char Flag_Recv = 0;
unsigned char len = 0;
unsigned char buf[8]; 
char str[20];


MCP_CAN CAN(9);                                            // Set CS to pin 10

void setup()
{
    Serial.begin(115200);

START_INIT:

    if(CAN_OK == CAN.begin(CAN_500KBPS))                   // init can bus : baudrate = 500k
    {
        Serial.println("CAN BUS Shield init ok!");
    }
    else
    {
        Serial.println("CAN BUS Shield init fail");
        Serial.println("Init CAN BUS Shield again");
        delay(100);
        goto START_INIT;
    }
}


void loop()
{
    if(CAN_MSGAVAIL == CAN.checkReceive())            // check if data coming
    {
        CAN.readMsgBuf(&len, buf);    // read data,  len: data length, buf: data buf

        for(int i = 0; i<len; i++)    // print the data
        {
            Serial.print(buf[i]);Serial.print("\t");
        }
        Serial.println();
    }
}

/*********************************************************************************************************
  END FILE
*********************************************************************************************************/

Kann leider nicht testen....

Aber dieses sieht doch komisch aus:

MCP_CAN CAN(9); // Set CS to pin 10

Bei einem Mega Board muss zusätzlich pin53 auf OUTPUT gestellt werden.

Das hat aber seine Richtigkeit. Das Board wurde überholt und der Pin auf 9 gelegt.

Und welche Version hast du genau?

Wenn man sich die Schaltpläne und Boards der verschiedenen Versionen anschaut sieht man das Pin 9 nirgendwo benutzt wird.

https://github.com/watterott/CANdiy-Shield/blob/master/pcb/CANdiy-Shield_v20.pdf

Hast du das Shield mal testweise auf einen Uno gesteckt?

Also ich habe die Version 2.0 Lasse ich den Pin 10 aber belegt bekomme ich nichtmal die Kommunikation über den Seriellen Monitor. Erst wenn ich den Pin 9 anstelle schalte klappt das.

Habe eben mal die Möglichkeit gehabt ein ein OBD 2 fähiges FZG zu gehen nur leider auch ohne weiteren Erfolg.

Dann liegt dein Problem ja woanders. Belegst du Pin 0 und 1 mit irgendwas?

edit: Oder sobald über den CS Pin eingeschaltet wird bricht deine Spannungsversorgung aus irgendeinem Grund zusammen. Benutzt du eine externe Spannungsversorung?

Nein, ich habe nur das Shield auf dem Arduino stecken. Weiter ist nix angeschlossen. Kein Display oder ähnliches.

Spannungsversorgung?

Über ein OBD 2 Stecker auf Netzwerkstecker.

Arduino über USB.

Wenn der OBD Stecker nicht im Auto eingesteckt ist kann er auch keine Spannung liefern. Versuchs mal mit einer externen Spannungsquelle für den Arduino

Hallo Crazy Rider,.

hab das gleiche Shield wie du. Habe auch diesen Sketch und andere Versionen davon ausprobiert und es sieht so aus als würde es mit diesem Shield nicht funktionieren. Soweit ich weiss, funktioniert das Sparkfun damit auch nicht. Bin mir jetzt aber nicht 100% sicher.

Dieser Sketch funktioniert sehr gut mit diesem Board http://www.exp-tech.de/seeed-studio-can-bus-shield?XTCsid=792d5d6442bb206cde5dbc00567d0e9f. Man muss aber die Lötstelle beim Jumper 1 lösen oder sowas. Erst dann werden die Daten empfangen. Versuch einfach mal diesen Sketch:

/* CAN communications example
 
  Topic: Receive Messages using read(CAN *message) function
  Author: Pedro Cevallos
  Created: 05/07/14
 
  Example shows how to receive messages using MCP2515 CAN controller
  This example uses Serial Monitor to display received messages
 
  As per wiki information:
  "CAN bus is a message-based protocol, designed specifically for automotive applications 
  but now also used in other areas such as aerospace, maritime, industrial automation and medical equipment."
  For more info http://en.wikipedia.org/wiki/Controller_area_network
 
  CAN bit rate:  10 kpbs; 20 kpbs; 50 kbps; 100 kbps; 125 kbps; 250 kbps; 500 kbps; 1000 kbps
  CAN modes: NORMAL, LISTEN,SLEEP,CONFIG, LOOPBACK
 
 */

#include <can.h> 
#include <SPI.h> 


// First we define our CAN mode and rate. 

#define mode NORMAL // define CAN mode
#define bitrate 500 // define CAN speed (bitrate)

/* 
  Second we create CAN1 object (CAN channel) and select SPI CS Pin. Do not use "CAN" by itself as it will cause compile errors. 
  Needs to be CAN0, CAN1, CAN2, or whatever name you want to give that channel. This can also allow us to create more channels 
  using more MCP2515s as long as we use different SPI CS to control data.
 */

MCP CAN1(10); //Create CAN Channel
CAN message; // Create message object to use CAN message structure 


void setup(){

  Serial.begin(115200);                                          // Initialize Serial communications with computer to use serial monitor

  //Set CAN mode and speed. Note: Speed is now 500kbit/s so adjust your CAN monitor

  CAN1.begin(mode, bitrate);
  
  delay(4000);                                                   // Delay added just so we can have time to open up Serial Monitor and CAN bus monitor. It can be removed later...
  
 if ((CAN1.readMode () == mode) && (CAN1.readRate() == bitrate)) // Check to see if we set the Mode and speed correctly. For debugging purposes only.
  {
    Serial.println("CAN Initialization complete");
    Serial.print ("CAN speed set to:  ");
    Serial.print (bitrate);
    Serial.println ("kbit/s");
  }
  else
  {
    Serial.println("CAN Initialization failed");
    Serial.println("CAN speed failed");
  }
}


// Create a function to read message and display it through Serial Monitor

void readMessage(){
 
if (CAN1.msgAvailable() == true){                               // Check to see if a valid message has been received.

    CAN1.read(&message);                                        //read message, it will follow the CAN structure of ID,RTR, legnth, data. Allows both Extended or Standard

    Serial.print("ID");
    Serial.print(" | ");
    Serial.print(message.ID,HEX);                               //display message ID
    Serial.print(" | ");
    Serial.print("RTR");
    Serial.print(" | ");
    Serial.print(message.rtr,HEX);                              //display message RTR
   if (message.rtr == 1){
     Serial.print(" REMOTE REQUEST MESSAGE ");                  //technically if its RTR frame/message it will not have data So display this
   }else {
    Serial.print(" | ");
    Serial.print("Length");
    Serial.print(" | ");
    Serial.print(message.length,HEX);                            //display message length
    Serial.print(" | ");
    Serial.print("Data");
    for (byte i=0;i<message.length;i++) {
      Serial.print(" | ");
      if(message.data[i] <0x10)
      {
        Serial.print("0");
      }
      Serial.print(message.data[i],HEX);                          //display data based on length
    }
   }
    Serial.println();
}   
}
    

// Finally arduino loop to execute above function with a 150ms delay

void loop(){

  readMessage();
  delay(150);

}

Klappt bei mir Wunderbar und es ist auch recht übersichtlich aufgebaut im Monitor. Hier ist noch eine aktuelle Version davon:
CAN-Library

CrazyRider: Über ein OBD 2 Stecker auf Netzwerkstecker.

Arduino über USB.

Du versorgst Arduino + Shield doppelt mit Strom???? Ich dachte es reicht nur wenn man den Arduino versorgt, das Shield kriegt dann automatisch was ab oder Irre ich mich da??? Warum gehtst du über den OBD 2 Stecker an den BUS? Willst du solche Sachen wie RPM, Speed oder Tankinhalt rausbekommen?