CPR CAN-Bus Projekt

Guten Morgen zusammen,
ich bin aktuell in einem Technikerprojekt verwickelt.
Mein Part beeinhaltet, dass ich von der Firma "Commonplace Robotics" den Mover 4 (ein Roboterarm" per CAN-Bus ansteuer.
Der Hersteller war mir schon sehr hilfreich, indem er mir schon Beispielprogramme zur Ansteurung gab. Jedoch alle nur per Windows. Mit Arduino bzw. Raspberry PI hat er keine Erfahrung, meint aber das es definitiv geht, da er den Roboterarm auch über CAN ansteuert.

Das wäre das grobe zum Projekt, jetzt kommen die Probleme:
Ich besitze zwei Arduino Nanos und einen Arduino Mega 2560 von Funduino.
Für die CAN-Kommunikation habe ich mir zwei CAN-Bus Shields gekauft:
Aptotec CAN-BUS Shield
NiRen Can-Bus-SPI-MCP2515-CAN-Transceiver

Leider bekomme ich aber mit beiden Shields keine Verbindung mit meinen Arduinos.
Es kommt im Seriellen Monitor immer "INIT faild".
Ich hab schon versucht die Shields über die ICSP-Pins zu verbinden und per selbst verdrahtung.
Leider Hilft nichts, ich bekomme einfach keine Verbindung mit den Shields.
Erst dachte ich es liegt am Endwiederstand, jedoch wenn ich 60 Ohm an H und L-CAN anschließe bzw. zwei 120 Ohm Widerstände Parallel auh H und L-CAN ändert sich auch nichts.

Mit Hilfe vom Debug-Mode kommt dann folgende Meldung zusätzlich "Enter setting mode fail".
Quasi der Anfang funktioniert schon nicht :smiley:

weiß jemand zufällig einen Rad?
Hab ich die falschen Shields sollte ich ein anderes ausprobieren?

Da ein CAN-Shield für den Arduino Uno gedacht ist, hab ich mir jetzt vorhin einen bestellt vlt funktioniert es dann :confused:

Danke schon einmal für eure Hilfe!

Gruß,
Andreas

weiß jemand zufällig einen Rad?

Räder sind gerade knapp...
U.A, weil Schaltplan und Code geheim bleiben müssen.

Aber einen Tipp, habe ich...
Zumindest eins der Boards hat einen 8MHz Quarz.
Üblich ist 16MHz
Da muss die erzeugung der Baudrate Values angepasst werden, denn die meisten Libs gehen von 16MHz aus.

Hallo,

wir hatten hier schon mal ein paar Fragen zu anderen CAN-Shields. Da die alle mit dem MCP2515 arbeiten, werden die alle über SPI angesteuert. Diese Init-Fehler kommen normalerweise durch falsche SPI-Verdrahtung, der Sketch kann beim Starten die Register des MCP nicht beschreiben.

Wenn man eh in der Größe eines Nano arbeiten will, könnte man auch gleich zum Teensy 3.2 greifen, der hat eine eingebaute CAN-Schnittstelle und braucht nur ein 8 pol. IC als Pegelwandler.

Das Aptotec Shield sollte auf deinem Mega funktionieren, sieht mir nach einer abgespeckten Version eines
CAN-BUS Shield V1.2 | Seeed Studio Wiki aus (besser dokumentiert).

ArduFE:
Wenn man eh in der Größe eines Nano arbeiten will, könnte man auch gleich zum Teensy 3.2 greifen, der hat eine eingebaute CAN-Schnittstelle und braucht nur ein 8 pol. IC als Pegelwandler.

Das gilt für den Teensy 3.5 und 3.6 auch. :slight_smile:

PS: ich habe keinerlei praktische Erfahrung mit CAN.

Whandall:
Das gilt für den Teensy 3.5 und 3.6 auch. :slight_smile:

Um das zu schreiben, war ich gerade zu faul. :slight_smile:

Ja, aus Preis/Leistungsgründen wäre der Teensy 3.5 eine gute Wahl, für ein paar Euro mehr bekommt man mehr MHz, RAM, Flash, einen Micro-SD Steckplatz und eine bestückte RTC, beim 3.2 müsste man den Uhrenquarz nachlöten.

Der 3.6 hätte sogar zweimal CAN, man ist aber bei den Transceiver ICs auf Typen mit 3,3 V Schnittstelle angewiesen.

Guten Morgen,

danke für die vielen Antworten :slight_smile:

Ihr habt was von einem Teensy 3.6 geschrieben.
Meint ihr es wäre klug auf ihn umzusteigen (aus zeitlicher Sicht gesehen?)

@Whandall: Die Libary benutze ich schon, nur das ich halt unter dem Board keine Lötbrücken habe. Daran dachte ich ja auch schon, dass dort vlt noch etwas verändert werden müsste aber ich kann nichts ändern :confused:

Allgemein:
Das NiRen CAN kennt sich jemand damit aus?
Sonst würde ich das zurückschicken, weil irgendwie ist mir das nicht so gehäuer. Auch wenn es den MCP2525, TJA1050 und eine 8 MHz (der ist falsch oder?) Quarz drauf hat und CAN ja nicht viel mehr braucht.

Gruß,
Andreas

Der Quartz auf dem Shield ist für den MCP, der hat nichts mit dem Arduino Takt zu tun. Er wird gebraucht, um die CAN Baudrate exakt einzuhalten.

Der TJA1050 ist die Art von Transceiver IC, wie sie auch noch beim Teensy benötigt würde. Da gibt es fast 50 verschiedene, alle mehr oder weniger mit der gleichen Pinbelegung, für 3.3 oder 5V.

Der Sprung von einem Mega auf einen Teensy 3.6 wäre ein großer. Kommt drauf an, was da sonst noch passieren soll. Nur um ein paar wenige CAN-Messages zu senden, wäre ein 180 MHz Controller doch etwas oversized. (Wenn es richtig viele CAN-Messages wären, z.B. von einem Auto, dann wäre das anders.)

Leider kenne ich mich mit CAN selber auch nicht wirklich aus, ich versuche es jetzt halt nach und nach alles zu verstehen/lernen.
Vom Hersteller gibt es folgende PDF:
http://www.cpr-robots.com/download/CAN/UserGuide_ProtocolCPRCAN_V04.pdf

Zusätzlich soll die Microcontroller dann noch 6 Messungen machen, verschiedenster Art von Kommunikation (Temp über I2C; PH über Seriell; Digitalen Ausgang setzen; Analogen Spannungseingang messen) aber soweit ich es gesehen habe kann der Teensy 3.6 dies alles.

Programmiertechnisch braucht man zu CAN nicht wirklich viel wissen, es funktioniert auf dem Arduino ähnlich wie Serial. Man kann senden und empfangen, allerdings keine einzelnen Bytes, sondern Botschaften.

Die sehen auf dem Teensy z.B. so aus

typedef struct CAN_message_t {
  uint32_t id; // can identifier
  uint8_t ext; // identifier is extended
  uint8_t len; // length of data
  uint16_t timeout; // milliseconds, zero will disable waiting
  uint8_t buf[8];
} CAN_message_t;

Wichtig sind dabei hauptsächlich die ID und die Daten (in len steht die Anzahl der Bytes und in buf deren Inhalte).

In diesem Beispiel aus der Arduino IDE spricht ein Teensy 3.6 mit sich selbst

// -------------------------------------------------------------
// CANtest for Teensy 3.6 dual CAN bus
// by Collin Kidder, Based on CANTest by Pawelsky (based on CANtest by teachop)
//
// Both buses are left at default 250k speed and the second bus sends frames to the first
// to do this properly you should have the two buses linked together. This sketch
// also assumes that you need to set enable pins active. Comment out if not using
// enable pins or set them to your correct pins.
//
// This sketch tests both buses as well as interrupt driven Rx and Tx. There are only
// two Tx buffers by default so sending 5 at a time forces the interrupt driven system
// to buffer the final three and send them via interrupts. All the while all Rx frames
// are internally saved to a software buffer by the interrupt handler.
//

#include <FlexCAN.h>

#ifndef __MK66FX1M0__
  #error "Teensy 3.6 with dual CAN bus is required to run this example"
#endif

static CAN_message_t msg;
static uint8_t hex[17] = "0123456789abcdef";

// -------------------------------------------------------------
static void hexDump(uint8_t dumpLen, uint8_t *bytePtr)
{
  uint8_t working;
  while( dumpLen-- ) {
    working = *bytePtr++;
    Serial.write( hex[ working>>4 ] );
    Serial.write( hex[ working&15 ] );
  }
  Serial.write('\r');
  Serial.write('\n');
}


// -------------------------------------------------------------
void setup(void)
{
  delay(1000);
  Serial.println(F("Hello Teensy 3.6 dual CAN Test."));

  Can0.begin();  
  Can1.begin();

  //if using enable pins on a transceiver they need to be set on
  pinMode(2, OUTPUT);
  pinMode(35, OUTPUT);

  digitalWrite(2, HIGH);
  digitalWrite(35, HIGH);

  msg.ext = 0;
  msg.id = 0x100;
  msg.len = 8;
  msg.buf[0] = 10;
  msg.buf[1] = 20;
  msg.buf[2] = 0;
  msg.buf[3] = 100;
  msg.buf[4] = 128;
  msg.buf[5] = 64;
  msg.buf[6] = 32;
  msg.buf[7] = 16;
}


// -------------------------------------------------------------
void loop(void)
{
  CAN_message_t inMsg;
  while (Can0.available()) 
  {
    Can0.read(inMsg);
    Serial.print("CAN bus 0: "); hexDump(8, inMsg.buf);
  }
  msg.buf[0]++;
  Can1.write(msg);
  msg.buf[0]++;
  Can1.write(msg);
  msg.buf[0]++;
  Can1.write(msg);
  msg.buf[0]++;
  Can1.write(msg);
  msg.buf[0]++;
  Can1.write(msg);  
  delay(20);
}

Man kann also auf unterster Ebene mit der Lib Messages senden und empfangen. Das sollte für deine Anwendung eigentlich reichen. Wenn der Windows Code so ähnlich arbeitet, kann man den entsprechend anpassen.

Den Teensy kriegt man in die Arduino IDE in dem man das hier installiert
https://www.pjrc.com/teensy/td_download.html
Das Installationsprogramm fragt auch, ob allerlei Libraries mit installiert werden sollen. Wenn man da "Alle" wählt, hat man die CAN Library für den Teensy mit dabei. Sonst muss man an der Stelle sehen, dass "FlexCAN" mit ausgewählt ist.

Wichtiger Hinweis: Teensy 3.2 und 3.5 sind an vielen Pins 5 V tolerant, d.h. sie gehen nicht kaput, wenn man an einen Eingang ein 5 V Signal anschliesst. Den 3.6 kann man danach wegschmeissen, der ist nur für 3.3 V Anwendungen, also ähnlich wie die IOs beim Raspi.

Hier auf dem Bild oben auf der Seite ist ein CAN-Bus zwischen zwei Teensy 3.1 auf einer Steckplatine aufgebaut
http://rummanwaqar.com/can-bus-with-teensy-3-1/

Als Transceiver sind hier zwei MCP2551 verbaut, das ist neben dem MCP2561 die einzige Transceiver Variante, die es im DIP Gehäuse gibt. Funktioniert ähnlich wie der TJA1050, hat aber noch diesen Widerstand gegen Masse, den es beim TJA nicht gibt.

Hinweis zum Codebeispiel da: Der benutzt eine ältere Version der FlexCAN-Library. Ist möglicherweise nicht 100% kompatibel zu dem Beispiel oben.

Moin,
erst einmal danke für die Antwort und Hilfe :slight_smile:
Ich hab mir den Teensy 3.6 bestellt.
Funktioniert da der MCP2551?
Würde mir den dann auch bestellen mit DIP-Sockel.
Die Widerstände hab ich selber noch.

Ich versuch es dann mal damit und melde mich :slight_smile:

Versendet jedes CAN Gerät immer wieder seine CAN-ID oder warten sie generell auf Signale und antworten dann erst?

Sorry für die "dämlichen" Fragen...

Andreas

Delta6400:
Funktioniert da der MCP2551?

Nein der arbeitet mit 5V, geht nur mit Teensy 3.2 und 3.5.

Für den Teensy 3.6 brauchst du, genau wie beim Arduino Due, einen Transceiver mit 3.3 V Schnittstelle.

Entweder sowas wie den TJA1051T/3, der braucht 3,3 V und 5 V Versorgungsspannung, dafür kostet er weniger als einen Euro.

Oder einen mit nur 3,3 V Anschluss wie den SN65HVD230QD, der kostet aber um die 4 Euro.

Da es die 3,3 V Typen nur als SMD gibt, braucht man für die Steckplatine noch eine kleine Adapterplatine zum IC auflöten, gibt es z.B. bei Conrad.

Ach und die IDs gehören nicht zum Gerät. Eine ID kann im Auto z.B. "Licht an" bedeuten. Damit kann es dann viele Lichtschalter und Lampen am Bus geben. Ein Schalter sendet "Licht an" oder "Licht aus", die Lampen lesen das und gehen entsprechend an oder aus.

So schalten z.B. alle Geräte in den Nachtmodus, wenn man das Abblendlicht einschaltet. Einfach in dem sie das mitlesen.

Ok, danke.
Also ich hab jetzt den Teensy 3.5 und den MCP2551 bei Reichelt bestellt (war zu dem jetzigen Zeitpunkt am günstigsten). Somit müsste es dann mit der Schaltung von oben funktionieren.

Mit der ID das Thema habe ich noch nicht so ganz verstanden.
Der Hersteller hat eine Liste welcher Motor auf was Reagiert (0X10= Motor1; 0X20= Motor2; 0X30=Motor3).
Also zusammengefasst ist bei CAN nicht festgelegt, das jeder Teilnehmer eine eindeutige ID hat, sonern jeder alles mithört und erst dann reagiert, wenn er sein Code-Schnipsel findet den er für sich braucht?
Etwas komisch erklärt von mir :smiley:

Danke nochmal für deine Geduld und Hilfe!

Kleiner Tipp: Teensy 3.5 und 3.6 sind noch recht neu, Du mußt also damit rechnen, daß nicht alle Programmbibliotheken wie erwartet funktionieren und gelegentlich nach Updates schauen. Die Bibliothek für CAN scheint aber recht aktuell zu sein.

agmue:
Kleiner Tipp: Teensy 3.5 und 3.6 sind noch recht neu, Du mußt also damit rechnen, daß nicht alle Programmbibliotheken wie erwartet funktionieren und gelegentlich nach Updates schauen. Die Bibliothek für CAN scheint aber recht aktuell zu sein.

Einmal das und außerdem ist die Hardware ja eine andere als AVR. Manche Sachen gehen auf den Kinetis Controllern anders, z.B. Timer.

Bei anderen Dingen wie z.B. I2C gibt es die normale Wire Bibliothek entsprechend Arduino und eine alternative Lib, die mehr Funktionen hat.

Also zusammengefasst ist bei CAN nicht festgelegt, das jeder Teilnehmer eine eindeutige ID hat, sonern jeder alles mithört

Ja, bei CAN kann man nicht "an jemand senden". Jeder bekommt erstmal alles. CAN Empfänger haben aber die Möglichkeit Filter zu setzen, dann lässt die Empfangshardware nur Messages mit bestimmten IDs rein.

Moin,

da hab ich mir was angetan :smiley:

Ich stöber mal ne runde im Internet herum und schau mal.
Vlt ist es einfacher als gedacht.

Ich denke, da die Teensy allgemein nicht nagelneu auf dem Markt sind werden bestimmt dazu auch ein paar Tutorials dazu geben.
Ich versuch erst mal die Grundsachen, damit ich das Handling verstehe und dann versuch ich mich mal ans CAN-Problem.

Danke schon mal!