Raspberry Pi + Easy

[Spellbreaker]

Moin moin!

Da ja nun das Release des Raspberry Pi kurz bevor steht, und ja mit rund 30 Euro extrem günstig ist, frage ich mich natürlich ob es eine Möglichkeit gibt zusammen mit ner EASY-209-SE das Teil als eine Art Datenlogger zu nutzen.

Gibt es auch eine Andere Möglichkeit als über die DLL mit der Easy zu kommunizieren? Auf dem Raspberry läuft ein Linux System (ARM Prozessor).

Hat sich da mal jemand Gedanken drüber gemacht? Ist nur so ein Gedankenspiel....

Gruß,

Nico Blanke

[Peter_Pig]

Hi Nico!

deine Nachricht ist schon ein Jahr alt... Mann, wie die Zeit vergeht

Ich finde auch, dass sich das Raspi geradezu anbieten würde, um neben einer Easy auf der Schiene zu hängen, und einen wunderbaren Web-Bedienoberflächen-Server hergeben täte.

Leider wird uns kein Linux-Treiber gegönnt.

Ich bin dennoch so begeistert von der Idee, dass Ich mir ein Haufen dicker Bücher und einen Raspi gegönnt habe. Einen USB sniffler habe ich auch bereits. Aber voraussichtlich nicht genügend Grips, und das kann man nirgends kaufen  

Eine extrem dilettantische, aber sehr spaßige Lösung hätte ich noch als Alternative für die ( wenn auch langsame und unwirtschaftliche) Kommunikation Raspi - Easy:

Mit zwei Easy Ausgängen und zwei Easy Eingängen eine Art serielle Kommunikation an GPIO basteln.  

Lächerlich?

Ich werde berichten.

Gr5uss,

Peter  

P.S.: ich entdeckte gerade den SP Baustein (Serielles Protokoll). Leider funktioniert es nur in einer Richtung (raus) ... und ist sehr Speicherplatz-intensiv: man benötigt pro "Datensatz" einen SP- und einen D- (Text) Baustein.

Ein USB Datenlogger müsste sich damit aber realisieren lassen: Wenn ich es richtig verstanden habe, kann man, pro SP&D Paar, 4 werte übertragen (falls gewünscht mit Zeitstempel!)

[Spellbreaker]

Wie schon in deinem anderen Posting geschrieben ist die Kommunikation mit der von Eaton zur Verfügung gestellten Spezifikation über USB völlig unproblematisch

[arnenrw]

Netterweise gibts eine Protokollbeschreibung für die Serielle Kommunikation.
USB ist auch nichts anderes.

ftp://ftp.moeller.net/EASY/TOOLS/Index.html

Im Besonderen die CPP Anwendung sollte da weiterhelfen
EASY_COM_V250\Demo.cpp

SORRY ist anscheinend nur für Windofs mit DLL

Viel Glück

Arne

[arnenrw]

Hab mich mal näher mit befasst und die serielle Schnittstelle mit einem Monitor (Free Serial Port Monitor serial-port-monitor[punkt]com) überwacht.

Folgender Datenmüll ist bei 4800 Baud entstanden (Hexadezimal):
Art   ;   Bitmuster Bit 16……1   ;   PC -> SPS   ;   SPS -> PC
Eingänge   ;   oooooooo;   C1 81 08 0C 00 95   ;   C0 14 08 00 00 00 00 00 00 00 00 1C
Eingänge   ;   ooooooox   ;   C1 81 08 0C 00 95    ;   C0 14 08 01 00 00 00 00 00 00 00 1D
Eingänge   ;   xooooooo   ;   C1 81 08 0C 00 95    ;   C0 14 08 80 00 00 00 00 00 00 00 9C
Eingänge   ;   xxxxxxxx   ;   C1 81 08 0C 00 95   ;   C0 14 08 FF 00 00 00 00 00 00 00 1C
P-Taste   ;   ooox           ;   C1 81 08 0C 00 95    ;   C0 14 08 80 00 00 01 00 00 00 00 9D
P-Taste   ;   ooxo           ;   C1 81 08 0C 00 95    ;   C0 14 08 80 00 00 02 00 00 00 00 9E
Merker   ;   oooooooo xxxxxxxx    ;   C1 81 07 14 00 9C    ;   C0 14 07 FF 00 00 00 00 00 00 1B
Merker   ;   oooooooo oooooooo;   C1 81 07 14 00 9C   ;   C0 14 07 00 00 00 00 00 00 00 1B
Merker   ;   oooooooo ooooxxxx;   C1 81 07 14 00 9C   ;   C0 14 07 0F 00 00 00 00 00 00 2A
Merker   ;   ooooxxxx oooooooo;   C1 81 07 14 00 9C   ;   C0 14 07 00 0F 00 00 00 00 00 2A 
Merker   ;   xxxxoooo oooooooo;   C1 81 07 14 00 9C   ;   C0 14 07 00 F0 00 00 00 00 00 0C
Ausgang   ;   ooooxxxx   ;   C1 81 07 14 00 9C   ;   C0 14 07 00 00 0F 00 00 00 00 2A
Ausgang   ;   oooooooo;   C1 81 07 14 00 9C   ;   C0 14 07 00 00 00 00 00 00 00 1B
Ausgang   ;   ooooooox   ;   C1 81 07 14 00 9C   ;   C0 14 07 00 00 01 00 00 00 00 1C
Ausgang   ;   ooooxooo   ;   C1 81 07 14 00 9C   ;   C0 14 07 00 00 08 00 00 00 00 23
   ;      ;      ;   
Analog   ;   I7=10V   ;   C1 81 02 09 00 8C    ;   C0 14 02 64 03 7D
Analog   ;   I7=5V   ;   C1 81 02 09 00 8C    ;   C0 14 02 32 03 4B
Analog   ;   I7=0,4V   ;   C1 81 02 09 00 8C    ;   C0 14 02 04 03 1D
Analog   ;   I8=0,3V   ;   C1 81 02 09 00 8C    ;   C0 14 02 03 03 1C
Analog   ;   I8=5V   ;   C1 81 02 09 00 8C    ;   C0 14 02 04 31 4B
Analog   ;   I8=10V   ;   C1 81 02 09 00 8C    ;   C0 14 02 04 64 7E

Wenn ich weiter forsche kann ich auch die restlichen Gerätedaten auslesen. Ist halt aufwändig. Wenn jmd eine Klasse in C oder VB schreiben will, kann ich gerne den Rest rausfinden.

Gruß Arne

[Spellbreaker]

Wozu der Aufwand?

Nochmal: Einfach bei Eaton anrufen bzw. hinschreiben, und man erhält eine NDA, und wenn man diese unterschreibt, erhält man eine komplette und vollständige Protokollspezifikation.

Ausserdem glaube ich nicht das so ein öffentliches reverse-engineering gerne gesehen ist. Zumal es völlig unnötig ist.

lg,

Spellbreaker

[arnenrw]

letzte Aussage von Eaton war leider eindeutig NEIN zu der Herausgabe des Protokolls. Wenns jmd geschafft hat kann er es gerne mitteilen.

[Spellbreaker]

Ich habs hier doch liegen.
"easyCom Kommunikationsprotokoll easy800/MFD, easy500/700 und easySafety". Abteilung IAB-PDSE erstellt am 08.11.2011 .

War kein Problem das zu bekommen, wie gesagt NDA musste unterschrieben werden.

[Peter_Pig]

Hallo Spellbreaker und Arne!

ich habe gar nicht gemerkt, dass hier was los war ...

Bis jetzt war mein Problem viel weniger das Protokoll, als überhaupt eine Verbindung zwischen Raspi (unter Wheezy Raspbian) und Easy800, mittels USB-CAB zu erreichen.

Gleichzeitig habe ich versucht zu lernen, mit einer Linux Maschine klar zu kommen (nicht leicht für einen unterdurchschnittlich begabten MS-Office-User).

Aber es macht einfach Spaß mit Linux  

Einen Einblick in irgendwelche Moeller Protokollbeschreibung oder Quellcode finde ich zur Zeit für mich nicht wünschenswert, da jede Zeile die ich in diesem Sinne schreiben würde, unter Verdacht stehen könnte, dass ich mich nicht an das "Non Disclosure Agreement" gehalten habe.

Ich finde: lieber "Grauzone" fahren als "Dunkelgrauzone" fahren.

Wie Spellbreaker angedeutet hat, ist alles - bis jetzt - ziemlich einfach.

Bis jetzt habe ich folgendes rausgefunden:

In meinem Fall (Easy800 + USB-CAB) habe ich, auf dem Raspberry Pi, pySerial installieren müssen, da ddas USB-CAB auf einem Silicon-Labs CP2102 chip basiert, also eigentlich kein schlichtes USB Kabel ist, sondern ein USB-Serial Umwandler... das ist auch besser, weil Serielle Kommunikation einfacher ist als USB. (ausserdem ist Python für mich erträglicher als C)

Jedenfalls, ich muss nicht die Easy ansprechen, sondern einen Silabs Chip am anderen Ende des Kabels...

Der CP210x Treiber ist auch seit langem auf Debian standardmäßig vorhanden (Bingo!).

Der Treiber hört leider nicht auf die IDs vom EASY USB-CAB (188A:3001) und lässt sich auch nicht durch die Parameter, die an "modprobe" übergeben werden (vendor=xxxx product=xxxx), beeinflussen.

Aus Norwegen bekam ich einen entscheidenden Tipp ( http://www.ha19.no/usb/  danke Jon!):

Easy einstöpseln und als „root“ eingeben:

echo 188A 3001 > /sys/bus/usb-serial/drivers/cp210x/new_id

Voilá! Schon wird der Treiber meinem Kabel zugewiesen! (oder umgekehrt?) und ich habe ein neues Port "/dev/ttyUSB0" (Windoze würde es "COMsonstwas" nennen)

 

Um ehrlich zu sein : weit habe ich es seitdem noch nicht bekommen...

Bisher (vor einigen Stunden) habe ich nur einen Merker (und zwar nur M09) schreiben können, dank dieses Mittschnitts aus der Windoze USB Kommunikation (merke: USB ... nicht Seriell)

Wann immer die Easy-Com.dll den M09 mit "1" beschrieb, hatte ich einen Bulk-Transfer mit folgender Payload :

0x45 0x08 0x20 0x00 0x04 0x08 0x00 0x01 0xCF 0x92

Das habe ich dann einfach auf mein neues "/dev/ttyUSB0" Port geschrieben

Dafür war mein Python "test_1.py":

import serial

s =serial.Serial('/dev/ttyUSB0', baudrate = 9600, timeout = 0)

d = '\x45\x08\x20\x00\x04\x08\x00\x01\xCF\x92'

Nicht die Welt: Ganz schlichte pySerial default-Verbindung

Dann habe ich in die  Python Shell eingegeben :

>>> s.write(d)

Antwort >>> 10

... d.h.: 10 byte geschrieben, nicht zu verwechseln mit : "Easy hat 10 byte gelesen und verstanden"

aber

>>> s.read(10)

gab exakt dieselbe Antwort wie das Windoze Vorbild... und tatsächlich! M09 war auf "1" gesetzt  

Übrigens, das erste Byte in der Folge beim Schreiben ist 0x45 .... also "E"
das erste Byte beim Lesen ist 0x65 ... also "e"

  ... na, wenn das nicht bedeuten will, dass ich auf dem richtigen weg bin ...

Ich hoffe, das hilft beim Basteln!

Gruß

Peter


P.S.:

Nicht dass jemand denkt, ich hätte die Welt erfunden oder irgendwelche Schutzmaßnahmen umgangen. Für dieses Bastel-Projekt habe ich mir einen Extra-Reiter in der M$IE Favoritenliste angelegt, und der ist nach einigen Wochen hiermit populiert (vielen Dank an diese Leute!):

http://easycalculation.com/hex-converter.php
http://pyusb.sourceforge.net/docs/1.0/tutorial.html
http://wiki.ubuntuusers.de/Kernelmodule
http://www.raspberrypi.org/phpBB3//viewtopic.php?f=31&t=25356
http://pyserial.sourceforge.net/
http://www.usbmadesimple.co.uk/ums_4.htm
http://www.ha19.no/usb/
http://learn.adafruit.com/hacking-the-kinect/command-number-1-and-2-led-blinky
http://www.etheus.net/CP210x_Linux_Driver
https://sppyqt.googlecode.com/files/Python%20for%20Serial%20Communication.pdf
http://stackoverflow.com/questions/16633868/sending-binary-data-over-a-serial-connection-with-pyserial/16635275#16635275
http://elinux.org/Serial_port_programming
http://stackoverflow.com/questions/11763295/sending-command-parameters-to-serial-port-using-python?rq=1

  Manches davon ist ein Überbleibsel von der Zeit, als ich dachte, dass ich über USB an "das Ding" kommen könnte. Gelöscht habe ich auf jeden fall Links zu Forum einträgen wie folgendes:

<Frage> (...) weiss jemand wie man Binäre Daten über pySerial überträgt?
<Antwort> Ja

  Na, klasse!!!

[arnenrw]

Ich hab immer noch keine Antwort von Moeller und das schon seit 2 Wochen. Naja vlt schlafen die zur Zeit oder sind im Urlaub ;-)

Da ich das Protokoll auseinandergeflückt habe und jetzt eine Visualisierungsumgebung suche, bin ich auf pvbrowser (punkt) de gestossen.
Hier müsste man nur noch den seriellen Teil des Modbus Dienst umstricken (läuft Seriell oder über TCP) und schon könnte es losgehen.
Wenn jetzt noch genügend Zeit übrig wäre ;-)

Achja ich nutze die VM Emulation des Raspy, so geht die Entwicklung wesendlich schneller

[Peter_Pig]

Arne,

also, wenn Du das Easy Protokoll wirklich "auseinandergepflückt" hast, dann gratuliere ich, und hoffe, dass dich kein NDA daran hindert, deine Erkentnisse mit uns zu teilen.
 
Ich bin in den letzten Tagen nicht besoders weit gekommen...  

Ich kann zwar unter Windoze "geschnüffeltes" mit Erfolg wiederholen, komme aber nicht dahinter, wie ich beliebige Anweisungen selbst zusammensetzen kann.

Mein Aufbau besteht aus Easy800 + Easy USB-CAB. Das ist vielleicht anders als Deiner...

Um einen bestimmten Merker zu setzen, weiss ich, dass ich folgende Sequenz schreiben müsste

0x45 (oder "E") ..... möglicherweise als Ankündigung einer Übertragung an Easy (?)
0x08 ... Länge der darauf folgenden Bytes
0x20 ... bedeutet wohl, dass ich auf das Prozzessabbild der Easy schreiben will (0x00 dass ich lesen will)
0x00 ... ist vielleicht der Teilnehmer (kann ich nicht überprüfen)
0x04 ... bedeutet, ich will einen einzelnen Bit schreiben (.object)
0x00 ... ist der Index des Merkers (Basis 0, also hier M1)
0x00 ... hat bei .object 0x04 keine bedeutung <--- Falsch (ist der zweite Byte des Index)
0x01 ... bool 1 (0x00 dann bool 0)

  dann sind aber noch zwei bytes nötig (in diesem Fall 0xCF und 0x92) die meiner Meinung nach rechnerisch ermittelt werden müssten. Wenn diese zwei Bytes nich stimmen, verhält sich Easy wie ein Taubstummer.

Muss wohl ein barockes checksum sein, oder irgend ein Schlüssel.

Ich jedenfalls, kann es nicht knacken

Gruss

Peter

[Peter_Pig]

  Okay, die letzten 2 Bytes der Übertragung sind tatsächlich ein CRC-16 Prüfwert, und zwar ziemlich ähnlich erzeugt wie der MODBUS CRC (nur mit 0xa200 als "initial value") <---- FALSCH (siehe nächsten Beitrag!)
Jetzt müsste man nur noch schlau genug sein, um solche Schlüssel selber zu generieren...  

Ich mach mich mal schlau.

Wenn jemand helfen will ... http://de.wikipedia.org/wiki/Zyklische_Redundanzpr%C3%BCfung

Gruss,

Peter


P.S.: Lieber Admin: Das Thema hat sich wieder einmal sehr von dem Ursprungs-Thread entfernt. Vielleicht könnte man ja uns Bastlern irgendwo ein Thema "Raspberry Pi (Linux) und Easy Kommunikation" stiften.

Des Weiteren wäre es mir lieb zu wissen, ob man solche Sachen hier überhaupt besprechen darf, oder   ob es unerwünscht ist.

[Spellbreaker]

Moin!

ich benutze dazu entsprechende boost Library:

Code: [Auswählen]

boost::crc_optimal<16, 0x8005, 0,0,true,true> crc;

Und dann kann man den CRC Bilden wie man möchte. Z.B. jedes Byte einzeln:

Code: [Auswählen]

crc.process_byte(byte);

Die Summe erhält man dann folgendermaßen:

Code: [Auswählen]

crc.checksum();



Lg,

Spellbreaker

[Peter_Pig]

Hi Spellbreaker!

danke für den Tipp. Es bestätigt unter Anderem, dass ich wieder mal falsch lag und alles viel komplizierter scheint als es ist.

In meiner vorherigen Nachricht habe ich ein falsches Algorithmus angewandt.

Ich sagte es wäre ein abgewandeltes Modbus CRC (jedoch mit 0xA200 als Anfangswert)

Das funktioniert zwar, ist aber eine dumme "Verkomplizierung" des Ganzen.

Greg Cook (http://regregex.bbcmicro.net/) klärte mich großzügigerweise auf:

Man muss nur das erste Byte des Pakets aus der Berechnung weglassen und ein stinknormales standard Algorithmus verwenden : ARC (CRC-16, CRC-IBM, CRC-16/ARC, CRC-16/LHA)

Das erste Byte ist bei der Easy nur ein Header (0x45 "E" wenn der Host schreibt, 0x65 "e" wenn Easy schreibt)

Dann funktioniert auch Dein Beispiel bei mir  

Vielen Dank nochmal!

Und frohes Schaffen!

Peter

P.S.: von Greg Cook stammt auch die Liste der parametrisierten CRC Algorithmen
und das RevEng CRC multi-tool

[Peter_Pig]

Ich hab mir da ein flinkes, tabellenbasiertes CRC-16 Programm aus dem Internet umgeschrieben.

Die Bytes des CRC sind leider vertauscht, ich muss später aber sowieso ein bisschen struct.jonglieren, allso bleibt es vorerst so (es sei denn, jemand weiss und sagt  was ich falsch gemacht habe).

Code: [Auswählen]

# as seen on http://www.digi.com/wiki/developer/index.php/Python_CRC16_Modbus_DF1
# shortened functionality for ease of use : just call getCRC(sting)


table = (
    0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241,
    0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440,
    0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40,
    0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841,
    0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40,
    0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41,
    0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641,
    0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040,
    0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240,
    0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441,
    0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41,
    0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840,
    0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41,
    0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40,
    0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640,
    0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041,
    0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240,
    0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441,
    0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41,
    0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840,
    0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41,
    0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40,
    0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640,
    0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041,
    0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241,
    0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440,
    0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40,
    0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841,
    0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40,
    0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41,
    0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641,
    0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040 )

def getCRC( st ):

    crc = 0x0000

    for ch in st:
       
        crc = (crc >> 8) ^ table[(crc ^ ord(ch)) & 0xFF]

    return crc
Gruß,

Peter