Kommunikation zwischen CAN-Knoten und Raspberry

Hallo Forum,

ich tüftel gerade an meiner Kommunikation zwischen dem Raspberry Pi und meinem CAN-Knoten über UART.
Der Plan ist, dass ich einen Befehl über eine Webseite eingebe und dieser per UART an mein Pi gesendet wird. Der CAN-Knoten antwortet dann und der Text soll auf der Webseite ausgegeben werden.
Die Kommunikation zwischen Webseite und Knoten funktioniert bereits. Sprich ich kann was auf der Webseite eingeben und das wird dann an den CAN-Knoten gesendet. Die Antwort von meinem Knoten kann ich dann mittels TeraTerm verfolgen.
Nur wie schaffe ich es das das Raspberry Pi eine ganze Nachricht von meinem Knoten über UART einließt und dann auf einer Website darstellt?
Danke für die Hilfe :)

Ich nutze dafür eine temporäre Datei. Diese wird dann bei jedem Aufruf der php Seite ausgelesen und deren Inhalt auf der Webpage angezeigt.

php Code:

Code:

---

    if (file_exists ("/tmp/ausgabe.txt" )){
        $userdatei = fopen("/tmp/ausgabe.txt","r");
        while(!feof($userdatei))
          {
          $zeile = fgets($userdatei);
          echo "<br>";
          echo $zeile;
          }
        fclose($userdatei);
    } else{
        echo "<br>Keine Ausgabe";
    }

---

Geht bestimmt auch eleganter (Javascript, Ajax) mir reicht es aber beim Aufruf der Seite. Die Seite kann sich auch per "reload Meta" selbst alle paar Sekunden aktualisieren.

Hey,

danke für die Antwort.
Und wie sorgst du dafür, dass alles was per UART empfangen wird in der Temporären Datei landet?
Und wie schalte ich es ab das der gesamte Bootvorgang über das Terminal gesendet wird? Hab eben gesehen, dass dasselbe was per SSH an Putty gesendet wird auch über den UART ausgegeben wird. Und das bringt meinen Controller komplett durcheinander.

Das ist einfach eine Anpassung von meinem Internetradio Die Kernsachen stehen auch im zugehörigen Wiki. Im 'auswerten' Sub einfach die Datei zum Schreiben öffnen und rein mit dem Text. Wenn viele / ständig Daten kommen, würde ich diese hintereinander in eine Datei schreiben, damit nichts verlorengeht.

In Datei schreiben:

Code:

---

    int fd1;   
    fd1 = open ("/tmp/ausgabe.txt", O_WRONLY|O_CREAT|O_TRUNC); //O_APPEND zum Anhängen
    if (fd1 == -1)
        exit (-1);
    write (fd1, eingang, strlen(eingang));
    close (fd1);
    system("chmod 644 /tmp/ausgabe.txt");

---

Ah ok.
Nur die nächste Frage ist, wie stelle ich das ab das das Raspberry Pi die komplette Bootsequenz über UART ausgibt?

Ja, das steht in dem von mir verlinkten Post.

Zitat:

---

Hinweis:
Ich nutze die UART auf der Stiftleiste. Für einen USB-Seriell Adapter sind folgende Schritte nicht notwendig!
Damit die UART frei ist, müssen 2 Dateien angepasst werden. Achtung: Vorher sichern. Wenn was schief geht, kann ich die SD-Karte in meinem NAS mounten und die Sicherungen zurückspielen...
/boot/cmdline.txt:

Code:

---

dwc_otg.lpm_enable=0 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

---

/ect/inittab: Folgende Zeile auskommentieren

Code:

---

T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

---

zu

Code:

---

#T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

---

Und natürlich auch alle anderen Zeilen, welche auf ttyAMA0 zugreifen wollen.

---

Super :)
Ich schau mal ob ich es morgen hin bekomme :D

mmh seitdem ich das gemacht habe, wird vor eine Ausgabe im Terminal immer sowas gesetzt:

Bild hier  


Ich habe das schon zurück verfolgt bis zur Konsoleneingabe. Die letzten Ausgaben stammen von dieser Eingabe:

Code:

---

echo  >> /dev/ttyAMA0

---

Ich habe mal mit Hex-Term drüber geschaut. Das ist ein F8 was da zuviel gesendet wird. Aber in meinen Codes finde ich nichts in der Richtung.
UART.c

Code:

---

// Compile with: gcc /Programme/UART.c -o /Programme/UART
 
//#include <iostream>
//using namespace std;
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>


#define BAUDRATE B115200                                                                                    // Baudrate


char MODEMDEVICE[]= "/dev/ttyAMA0";                                                                            // Device zum Senden 
struct termios newtio={};                                                                                    // Variable für "termios.h"
int fd;                                                                                                        // File descriptor


void Send_UART(char *c)                                                                                        // Gibt ein einzelnes Zeichen über UART (als fd geöffnet) aus.
{
    int res;
    char LineEnd[] = "\r\n";
   
    res = write(fd, c, strlen(c));
    write(fd, LineEnd, 2);
}


int UART_Init()                                                                                                // Schnittstelle öffnen und parametrieren
{
    // O_RDONLY, O_WRONLY or O_RDWR -
    // O_NDELAY (geht weiter, wenn keine Daten da sind und gibt "-1" zurueck)
    // man 2 open fuer mehr Infos - see "man 2 open" for more info
    // O_NOCTTY No ControllTeleType
    fd = open(MODEMDEVICE, O_WRONLY | O_NOCTTY);
   
    if (fd < 0)
    {
        printf("Fehler beim öffnen von %s\n", MODEMDEVICE);
        exit(-1);
    }
   
    memset(&newtio, 0, sizeof(newtio));
    newtio.c_cflag = BAUDRATE | CS8 | CLOCAL | CREAD;                                                        // Setzt die neuen Porteinstellungen
    newtio.c_iflag = IGNPAR;
    newtio.c_oflag = 0;
    newtio.c_lflag = 0;        /* set input mode (non-canonical, no echo, ...) */
    newtio.c_cc[VTIME] = 0;    /* inter-character timer unused */
    newtio.c_cc[VMIN] = 1;    /* blocking read until 1 chars received */


    tcflush(fd, TCIFLUSH);
    tcsetattr(fd, TCSANOW, &newtio);
    return fd;
}




int main(int argc, char** argv)                                                                              // Programmstart
{
    // Variablen für das Hauptprogramm
    char LineEnd[] = "\r\n";
    int res;
   
    UART_Init();                                                                                                // Schnittstelle öffnen und parametrieren
   
    if (argc >= 1)                                                   
    {
        res = write(fd, argv[1], strlen(argv[1]));
        write(fd, LineEnd, 2);
    }
   
    printf("Text empfangen\n");                                                                                // Empfangsbestätigung senden
    //Send_UART("Hallo");
   
    close (fd);
    return 0;
}

---

UART.php

Code:

---

<html>
<head>
<title>
Raspberry Pi Webserver
</title>
</head>


<h1>
<font color="red">
Raspberry Pi Webserver
</font>
</h1>


<body>
<div id="nav"><a href="index.php">Hauptseite</a>


<h2>
Raspberry Pi UART
</h2>


<?php


if (isset($_POST["Eingabe"]))
{
      $befehl="sudo /Programme/UART ".$_POST["Eingabe"];
      $output = shell_exec($befehl);
};


echo "<form method='post' action='UART.php'>";
echo "<input type='text' maxlength='40' size='40' id='1' name='Eingabe' value='Ich'>";
echo "<input type='submit' value='Senden'>";
echo "<br>";
echo "<br>";
echo "Antwort:";
echo "<br>";
echo "$output";
echo "</form>";


?>
</div>
</body>
</html>

---

Weißt du evtl. was das sein könnte?

Lass den UART mal offen. Meiner sendet auch immer ein Zeichen beim Öffnen (oder Schließen? weiß nicht mehr so genau) des ttyAMA0. Lasse ich ihn offen, kommt nur das, was auch gesendet werden soll. Müsste ich aber auch schon irgendwo erwähnt haben. Ich lasse ihn geöffnet, indem mein Empfangen Programm ständig lauscht.

Da das gesendete Zeichen abhängig von der Baudrate ist, gehe ich von einem "ungewollten" Bitwackeln beim Öffnen der Schnittstelle aus.

Bei einem USB-Seriell Wandler habe ich diese Wirkung übrigens nicht.

Ich verwende auch einen USB-Seriell Wandler.
Mit dem offen lassen probiere ich mal. Aber anscheinend habe ich das Problem beim empfangen nicht, da nichts dergleichen in der Datei steht.
Kann ich auch zwei C-Programme gleichzeitig laufen lassen?
Weil dann wollte ich das Prinzip übernehmen. Dann habe ich ein C-Programm zum Senden/Auswerten und eins zum Empfangen.

Also ich kann den Fehler nun reproduzieren.
Jedesmal wenn ich die inittab und die cmdline.txt umändere taucht der Fehler auf.

Kann sein das AT-Befehle gesendet werden. Warum kann ich allerdings auch nicht sagen, das ich kein Pi habe.

Ich konnte es nun weiter eingrenzen. Es tritt erst auf sobald ich die Inittab bearbeite.
Wenn ich nur den Teil aus der cmdline.txt entferne passiert das nicht.

Also hier werden die Änderungen noch einmal komplett beschrieben.

Danke für den Link.
Ich folge der Anleitung mal und probier es nochmal.....
Vielleicht habe ich auch einfach nur irgendwo was übersehen (wovon ich ausgehe ^.^)

Edit:
Wird immer noch mit gesendet.

Mit USB-Seriell Wandler habe ich überhaupt keine Probleme. Stimmt denn die Polarität? Nicht, dass einer von beiden invertiert. Allerdings habe ich mein Raspbian wegen "Never Change a running System" schon lange nicht mehr aktualisiert. Ich nutze generell 2 C-Programme. Je eines zum Empfangen und eines zum Senden. So wie ich es im Internetradio Wiki beschrieben habe, mache ich es auch bei meinen anderen Projekten. Das Empfangen Programm läuft ständig und das Senden beendet sich nach dem Senden gleich wieder. Der Vorteil ist, dass es auch vorherige Instanzen berücksichtigt und so der Uhrzeitcronjob nicht den anderen Programmen dazwischenfunkt.

Hey,
also der USB Wandler invertiert nicht.....zumindest weiß nichts davon. Außerdem müssten dann ja auch mehr Zeichen falsch sein oder?
Und rufst du die beiden Programme ineinander auf oder laufen die wirklich paralell? Wenn ja wie mach ich sowas? Ich arbeite nämlich zur Zeit immer nur mit Programmaufrufen innerhalb von Programmen (UART, I2C, EMail).
Aber es liegt definitiv an der inittab.....sobald ich die Änderungen rückgängig mache funktioniert alles wie normal.....außer das beim Booten noch der Anmeldeprompt kommt.
Ist im Zweifelsfall besser als das zusätzliche Zeichen.....dann mache ich den String noch beim AVR mit rein und gut ist.....aber optimal wäre es wenn beides weg ist.

Der Empfänger wird aus der rc.local gestartet und bleibt dann im Hintergrund am laufen. Der Sender wird jedesmal beim Senden mit zu sendendem String als Parameter aufgerufen und beendet sich anschließend wieder. Alles so, wie ich es im Internetradio Thema + Wiki beschrieben habe.

Nutze ich einen USB-Seriell Wandler, dann wird die Konsole da nicht automatisch geöffnet. Diesen konfiguriere ich nur beim Start in der rc.local

Zitat:

---

stty 38400 -F /dev/ttyUSB0

---

und gut ist.

Mal eine andere Frage. Hast du schon mal versucht den MCP2551 bei 3,3V zu betreiben? Also um mit dem RasPi einen eigenen Knoten zu kreieren?

Hey,

ja ich hab schon drüber nachgedacht und sowas ist schon in Planung :)

Frage nur, weil im Datenblatt für den Transreceiver 4,5-5,5V als Versorgungsspannung angegeben sind. Theoretisch könnte man ja Rx und Tx mit Levelschiftern versehen und den MCP2551 mit 5V von Pi versorgen.

Ja muss mal schauen wie ich das mache.
Eine Aufsteckplatine ist bereits in Planung......nur der UART nervt mich noch ein bischen.
Auf der Platine befindet sich dann ein Mega128 als Slave der Befehle per UART bekommt.
Aber das ist im Moment erstmal nur eine Idee auf Papier :)

Hmm, ich hab mir jetzt erst einmal einen CAN-Transceiver von Maxim bestellt. Der arbeitet auch beim 3,3V. Mit einem Gedanken bzgl. Slave habe ich auch gespielt, allerdings braucht man dazu ja auch kein RasPi sondern da täte es ja auch jeder beliebige Rechner.

Wollte eher im Userspace per Daemon, Daten via CAN und Funk einsammeln/verschicken und entweder mit dem Pi dann als Webinterface darstellen oder via Socket nach draußen pusten. Mal sehen eventuell auch beides.

Ja genau sowas habe ich mir auch vorgestellt.
Das Pi soll dann halt als Zentrale für die Knoten dienen und ein Webinterface usw. bereit stellen.

Wenn am Anfang und / oder am Ende der Übertragung Raspi<>AVR Murks ankommt, in der Mitte der Übertragung die Daten jedoch komplett sind, hilft als Workaround auch ein eigenes Protokoll. Z.B. Zum Start mehrmals ein CHR(8) senden, welche die Gegenstelle immer als "Jetzt kommen neue Daten" versteht und am Ende der Übertragung ein CHR(9) und der Empfänger weiß dann: Datensatz vollständig und verarbeitet diesen und ignoriert alles, bis zum nächsten CHR(8).

Messwerte müssten dann halt z.B. als String übertragen werden.

Z.B. so (nicht getesteter angepasster Code meiner Empfangsroutine):

Code:

---

// Compile with: gcc /var/scripte/empfangen.c -o /var/scripte/empfangen

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>


#define BAUDRATE B19200
char MODEMDEVICE[]= "/dev/ttyAMA0";                        // Schnittstelle
char eingang[255]="";                //Empfangenes
int anzahl=0;                    //Anzahl Einträge in der Senderliste
int laenge=0;                    //Anzahl empfangener Zeichen
int    fd;                            // UART File descriptor
struct    termios newtio={};
char WEBDEVICE[]="/tmp/webif.daten"; //Datei, wo die Empfangenen Daten abgespeichert werden, um sie dann per php auszulesen


unsigned char eingangleer()        //Eingang nullen
{
    int i;
    for(i=0; i < laenge; i++){
        eingang[i] = 0;
    }
    strcpy(eingang,"");
    laenge==0;
    c=0;
}


unsigned char receive()                                    //Zeichen empfangen
{
    int res;
    unsigned char buffer;

    res = read(fd, &buffer, 1);
    return buffer;
}


unsigned char auswerten()
{ int fd1;
  char ret;
 
    if ((strcmp(eingang,"resetreset") ==0 )){
        system("reboot");
        }else{
  /* Zum Schreiben öffnen */
        if (laenge > 0){                              // F
          fd1 = open (WEBDEVICE, O_WRONLY|O_CREAT|O_TRUNC); //|O_TRUNC, S_IRUSR|S_IWUSR
          if (fd1 == -1)
            exit (-1);
         
          write (fd1, eingang, laenge);
          close (fd1);
          system("chmod 644 /tmp/webif.daten");
        }
    }
 }

int init()
{
    /*** Init ***/
   
    //O_RDONLY, O_WRONLY or O_RDWR -
    //O_NDELAY (geht weiter, wenn keine Daten da sind und gibt "-1" zurueck)
    // man 2 open fuer mehr Infos - see "man 2 open" for more info
    // O_NOCTTY No ControllTeleType
    /*fd1 = open(FILEDEVICE, O_WRONLY);
    if (fd1 < 0){
        printf("Fehler beim oeffnen von %s\n", FILEDEVICE);
        exit(-1);
    }*/
   
    fd = open(MODEMDEVICE, O_RDONLY | O_NOCTTY);
    if (fd < 0){
        printf("Fehler beim oeffnen von %s\n", MODEMDEVICE);
        exit(-1);
    }
    memset(&newtio, 0, sizeof(newtio));
    newtio.c_cflag = BAUDRATE | CS8 | CLOCAL | CREAD;    //setzt die neuen Porteinstellungen
    newtio.c_iflag = IGNPAR;
    newtio.c_oflag = 0;
    newtio.c_lflag = 0;        /* set input mode (non-canonical, no echo, ...) */
    newtio.c_cc[VTIME] = 0;    /* inter-character timer unused */
    newtio.c_cc[VMIN] = 1;    /* blocking read until 1 chars received */

    tcflush(fd, TCIFLUSH);
    tcsetattr(fd, TCSANOW, &newtio);
    return fd;
}

int main(int argc, char** argv)
{
    char c;
    int empfang=0;
    init();

    while (1)
        {
        c=receive();

        if(c==8){                                        //Init-Zeichen >>    Neuer Befehl trifft ein
            strcpy(eingang,"");
            eingangleer();
            empfang=1;
        }   

        if (empfang==1){                               
            if((c==9)){                                    //Ende-Zeichen >> Datensatz fertig >> Auswerten
                auswerten();
                empfang=0;
                eingangleer();
            }else if(c>13&&c<128&&laenge<255){                        //Keine Sonderzeichen nur ASCII Standard
                eingang[laenge]=c;                        //empfangenes Zeichen anhängen
                laenge++;   
            }
        }
    }
    close (fd);
    return 0;
}

---

Den Gegenpart Raspi>>AVR kann man genauso lösen. Da weiß ich aber nicht, welche Programmiersprache du nutzt.

Hey,

danke für den Tipp.
Ich denke mal um sowas werde ich auch nicht herum kommen. Ich finde einfach nicht die Ursache für das Problem....
Aber im Moment habe ich sowieso keine Zeit/Lust daran weiter zu basteln.... :(

- - - Aktualisiert - - -

Hey,

ich habe das Problem mit dem UART gelöst....ich habe heute mal die Baudraten durchprobiert und festgestellt, dass es bei 9600 Baud nicht mehr auftritt.
Damit ist die Ausgabe langer Texte zwar zu langsam, aber für meinen CAN-Adapter für das Raspberry Pi habe ich mir eh einen Mega128 ausgeguckt und der hat 2x UART....dann nehme ich einmal einen mit 9600 Baud für die Kommunikation mit dem Pi, wo ich dann nur kurze Befehle sende und den anderen mit 115200 Baud für die Kommunikation mit dem PC....sollte denk ich mal so klappen :/

Heyho,

meine Versuche mit dem Empfangen über UART klappen schon mal ganz gut (dank dem Beispiel von Peterfido).
Ich benutze zum Öffnen der temporäre Datei nun diesen Befehl:

File1 = open(FILEDEVICE, O_WRONLY | O_CREAT | O_APPEND);

Dadurch wird bei einem Enter der Text ans Ende der Datei angehängt, da die UART Ausgabe meines Knotens mehrere CRs besitzt.
Wie bekomme ich es nun hin, dass das CR + LF auch in der Textdatei erscheint?
Muss ich da einfach nur ein CR + LF in die Datei schreiben?

Kleiner Edit:
Die Kommunikation zwischen Pi und CAN-Bus klappt. Das Empfangsprogramm wird nun bei jedem Bootvorgang gestartet, lauscht und per Web kann das Empfangene ausgelesen werden (allerdings stimmt die Formatierung noch nicht ^.^).

Zitat:

---

Zitat von Kampi

Kleiner Edit:
Die Kommunikation zwischen Pi und CAN-Bus klappt. Das Empfangsprogramm wird nun bei jedem Bootvorgang gestartet, lauscht und per Web kann das Empfangene ausgelesen werden (allerdings stimmt die Formatierung noch nicht ^.^).

---

Soll heißen, dass sich die Frage mit dem CR+LF erledigt hat? Hab letzte Woche Freitag auch mein Pi bekommen. Momentan funkt es mit einem RFM12-Modul (per Mega328 und USB/RS232-Wandler). Pustet mir die Daten auch via Ethernet raus und ich kann von jedem PC im Heimnetz die Daten auslesen. ;)

Nein die Frage mit dem CR+LF hat sich noch nicht erledigt :)
Aber ein Funkmodul an dem Pi ist auch ne tolle Idee.....ich hab noch ein Bluetoothmodul hier rumliegen :)
Hab auch schon ein bisschen an meiner Adapterplatine rumdesigned und da packe ich glaube ich auch noch ein BTM222 drauf ^.^
Muss nur gucken wie ich das mit der Pegelwandlung mache.....im Grunde kommuniziert der Mega128 Slave nur über UART mit dem Pi. Von daher brauche ich ja nur zwei Pins auf einen höheren Pegel bringen.....naja mal schauen ^.^

Edit:
Ok das mit dem CR + LF hat sich nun erledigt.
Das ganze sieht nun so aus (ist nur noch ein LF zuviel drin):

Bild hier  


Die Frage ist jetzt nur warum kann ich durch einen Klick auf "Löschen" nicht die Datei löschen?
Der PHP Code sieht so aus:

Code:

---

if (isset($_REQUEST["Löschen"]))
{
    shell_exec("sudo rm /tmp/UART_Empfang.txt");
};

---

Und weißt du wie ich das Textfeld auf der PHP Seite fixieren kann? Im Moment kann ich das Feld noch auseinander ziehen. Nur das würde ich gerne anders lösen.

hmm BTM ist langweilig ;) Da kannst du auch gleich nen USB-Dongle nehmen. Wenn du den Mega128 mit 5V betreiben willst, könnte die Pegelwandlung wie bei dem BTM-Mini-S von robotrack realisieren. Ansonsten halt 3,3V und nen CAN-Transceiver von Maxim nehmen. Die können mit 3,3V und CAN-Pegel von 5 und 12 V verarbeiten. Liegen bei mir auf Arbeit in der Post ;).

Hey,

die CAN-Transreciever habe ich auch noch hier rumliegen.
Wobei das Funkmodul auch nett aussieht :)
Mal schauen was ich nehme. Die Platine werde ich eh nicht mehr dieses Jahr machen.....hast du vielleicht die Layoutmaße von der neuen Version vom Raspberry Pi zur Hand? Ich finde die irgendwie nicht und ich würde gerne ein Befestigungsloch mit in die Platine einbringen, sodass ich eine Abstandssäule dran machen kann.
Die Bluetoothplatine sieht nett aus.....ich habe mich mal für eine registriert :)
Aber ich denke ich nehme lieber 5V Pegel.....aber wie gesagt muss ich nochmal genauer schauen.....

Bzgl. CR+LF entweder lässt nur das CR, dann können vernünftige Editoren das auch lesen oder du hängst bei jeder Zeile das LF noch dran. Aber das braucht ja nur Windows. ;)

Bei mir ist momentan eher die Frage, ob ich alles via UART mach, oder ob ich die Pins des Pi nehme. Bei letzterem ist der Aufwand beim Layout größer. Bei der ersten Variante muss ich für Intelligenz in Form eines µCs sorgen und den programmieren. Bin da auch noch unschlüssig. Jedenfalls sind da momentan folgende Randbedingungen gesetzt :

• CAN
• RTC
• RFM12
• eventuell ein paar Sensoren (sind aber nicht so wichtig, da alles via CAN-Nodes oder Funk reinkommt)

Wegen den Layoutmaßen muss ich mal schauen. Hatte aber bisher nicht danach gesucht, da erst einmal ein Prototyp her muss. Atmega128 hab ich auch noch welche. Hatte die mal irgendwo mitbestellt und nicht darauf geachtet, dass die nur 5V können. Würde also tauschen gegen die L-Variante, wenn das hier jemand liest. :)

Einen µC wollte ich eh auf die Platine machen, da auf die Platine noch ein LCD kommen soll + noch ein paar Sachen und weil ich die Pins vom Pi nicht "verschwenden" will ^.^
Aber ich denke ich bleibe lieber bei 5V.....wenn ich das auf der Platine berücksichtige gibt es da auch keine Probleme und ich kann nicht aus versehen zwei verschiedene Pegel miteinander verbinden.

Hmm, na im Prinzip ist es auch Wurscht. :) HAb gerade festgestellt, dass das Pi nach einer Weile einfriert. Im RaspberryPi-Forum schrieb jmd., dass es an dem FTDI liegen könnte. Also schnell Server geschrieben, der einen Knoten emuliert, mal gucken wie lange der läuft.

Ja, in der Tat habe auch ich Probleme in Verbindung mit FTDI USB-Seriell Wandler beobachtet. Seit ich statt des FTDI die Siemens Datenkabel (ebay: ORIGINAL USB DATENKABEL für SIEMENS DCA-510 S55 / SL55) nutze, läuft es stabil durch. Einfach den Stecker zum Handy entfernen und die Adern an die Platine des Mikrocontrollers löten.

Der Nachteil an denen ist leider, dass diese keine Seriennummer haben, so dass ich mehrere nicht eindeutig identifizieren kann. Was ich jetzt durch die Mikrocontroller abfange. Diese senden auf Anfrage jetzt ihren Namen, welcher dann wie die Seriennummer des FTDI eine eindeutige Zuordnung zulässt. Allerdings habe ich zwei bisher nur in der Entwicklungsphase angeschlossen gehabt. Funktioniert aber.

Diese Lösung nutze ich bisher nur für externe Geräte (z.B. große LED Uhr im Wohnzimmer und externes Display zum Basteln im Arbeitszimmer). Intern nutze ich per Pegelwandler die RX und TX des Raspbi.

Ein FDTI zusammen mit dem Siemens Kabel bringt den Raspbi (Raspbian) durcheinander. Da wurde bei mir der FDTI irgendwann ignoriert und die Ausgabe kam dann komischerweise auf dem Siemens Kabel an. Das war mit der Juli Version vom Raspbian. Unter der Version vom 18.09. habe ich diese Tests nicht wiederholt.

Hab es jetzt erst einmal mit einem Firmware-Update versucht. Soll wohl einigen Nutzern Besserungen bringen, mal schauen. Test läuft erst 6 Stunden.

Code:

---

sudo /opt/vc/bin/vcgencmd version

---

Code:

---

Nov 22 2012 18:12:01
Copyright (c) 2012 Broadcom
version 352766 (release)

---

Hallo,

meine USB-CAN Adapter (Tiny-CAN) unterstützen inzwischen auch das Raspberry Pi Board.
Meine Hardware geht nicht den Umweg über SocketCAN und wird auch nicht durch eine umständliche SPI <-> CAN Controller Kommunikation aus gebremst.
Schaut mal: http://www.mhs-elektronik.de/index.php?news=4813&l=1

Grüße
Klaus

PS: Alles Open Source :-)