Alpha-Bus zu RS232 Adapter (1 bidirektionale Datenleitung)

[Simon S. (simschmid)]

Liebe Community

Ich experimentiere hier mit einer Gorba LCD Anzeige (Fahrzielazeige in 
einem Bus) herum. Diese wird per Alpha-Bus angesteuert.

Was ich weiss, ist dass die Datenleitung bidirektional ist und mit 19200 
Baud, 8N2 angesteuert wird. Ich kann auch schon erste Erfolge mit einem 
Python Script erzielen.

Nun die Krux: Die Datenleitung ist idle auf 24V. Ich habe mir nun einen 
Schaltung zusammengebastelt, die via Optokoppler und Transistor die 5V 
vom FTDI Chip an die 24V der Anzeige anpasst. Das funktioniert soweit. 
Um die Antwort der Anzeige zu empfangen habe ich das Signal via 
Optokoppler an die 5V angeglichen. Achtung, es ist ein Gebastel 
funktioniert soweit für erste Kommunikation.

Nun das Problem: Sende ich auf TX, so kommt das gleich im RX wieder an 
(da ja die Anzeige nur eine Datenleitung hat). Ich muss also beim Senden 
das TX Signal auf der RX Leitung unterdrücken.

Ich dachte, ich könne dies mit einem 7400 NAND erledigen (den habe ich 
rumliegend und verwende diesen bereits im RX Pfad um das Signal nach dem 
Optokoppler zu invertieren). Doch der 7400 erzeugt auch ein Delay, somit 
geht das nicht. Ich weiss, 7400 ist keine schlaue Wahl.

Was gäbe es hier für einfachere Lösungen?
Ev. Kann ich dies auch softwaremöäsig lösen, doch dafür sind meine 
Python Kenntnisse wohl zu mager. Und die Telegramme der Kommunikation 
sind unterschiedlich lange und haben als Start- und Stopbyte jeweils 
0x7E.

[Flip B. (frickelfreak)]

das lokale echo von der datenleitung ist eigentlich sogar zu bevorzugen, 
einfach vor jeder erwarteten antwort den rx fifo flushen und ggf später 
die integrität der selbst gesendeten signale prüfen. eine 
empfangsunterdrückung klappt dann ggf mit höherer kabelkapazität nicht 
mehr richtig bzw unterdrückt auch korrekte signale.

[Mario M. (thelonging)]

Man könnte ja über die Steuersignale des FTDI vor Sendebeginn den 
zweiten Eingang des 7400 auf low ziehen und nach dem Stopbit letzten 
Zeichens wieder auf high legen.

[Schorsch X. (bastelschorsch)]

Du kannst doch die Antwort entsprechend in deinem Programm einfach 
"verschlucken" ? Du weisst ja, was du gesendet hast. Überspring diesen 
Teil der Antwort.

[Hmmm (Gast)]

Simon S. schrieb:
> Ev. Kann ich dies auch softwaremöäsig lösen, doch dafür sind meine
> Python Kenntnisse wohl zu mager.

Einfach nach jedem gesendeten Paket die gleiche Anzahl Bytes empfangen.

Tritt dabei ein Timeout auf oder weichen die Daten ab, wirfst Du eine 
Fehlermeldung aus, dass etwas mit dem Bus nicht stimmt.

[Simon S. (simschmid)]

Danke für die bisherigen Antworten, dieses Forum ist einfach so toll. 
Auch wenn ich mich nur alle Schaltjahre hierbewege, die werstschätzende 
Unterstützung und Lösungsideen aus der Community kommen sofort. 
Herzliche Dank.

Fürs erste möchte ich die Idee von Schorsch X. weiterverfolgen.

Schorsch X. schrieb:
> Du kannst doch die Antwort entsprechend in deinem Programm einfach
> "verschlucken" ? Du weisst ja, was du gesendet hast. Überspring diesen
> Teil der Antwort.

Da ich wirklich Python Beginner bin, stelle ich hier mal meinen Code 
ein. Wie könnte ich das anpassen, dass bei der Antwort, die gesendeten 
Pakete "verschluckt" werden?

import serial
import time

ser = serial.Serial('/dev/cu.usbserial-A400C24C',
    baudrate=19200,
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_TWO,
    bytesize=serial.EIGHTBITS,
    timeout=0
    )

tx_1 = [0x7E, 0x81, 0x7D, 0x5E, 0x7E]
tx_2 = [0x7E, 0x91, 0x04, 0x02, 0x68, 0x7E] 

# Initialisierung senden
print ("Sende Initialisierung " + ''.join(format(x, '02x') for x in tx_1))
ser.write(serial.to_bytes(tx_1))

print ("\nWarte auf Antwort ...")
time.sleep(0.007)
ser.flushInput()

while 1:
    # Bytes einlesen
    hexData= ser.read(50).hex()
    #Auf Antwort warten
    if (hexData):
        print("Empfange: " + hexData)

        if (hexData == "7e817d5e7e7e014c4d01563135ac7e"):
            print ("    rx_1")
            print ("    Sende Antwort " + ''.join(format(x, '02x') for x in tx_2))
            ser.write(serial.to_bytes(tx_2))
        else:
            print ("    Daten unbekannt")

        print ("\nWarte auf Antwort ...")

ser.close()

Obiger COde funktionert so weit. Unschön daran ist, dass ich den String

"hexData == "7e817d5e7e7e014c4d01563135ac7e"

 manuell generiert habe.
Die Variable tx_1 würde "7e817d5e7e" enthalten. Wie müsste ich das 
anpassen, damit dies von hexData "subtrahiert" wird?

[Simon S. (simschmid)]

Flip B. schrieb:
> das lokale echo von der datenleitung ist eigentlich sogar zu bevorzugen,
> einfach vor jeder erwarteten antwort den rx fifo flushen und ggf später
> die integrität der selbst gesendeten signale prüfen. eine
> empfangsunterdrückung klappt dann ggf mit höherer kabelkapazität nicht
> mehr richtig bzw unterdrückt auch korrekte signale.

Kannst du mir beim Code oben helfen, wie ich diese umsetzen könnte? Das 
mit dem ser.flushInput() direkt nach dem Senden habe ich bereits 
probiert. Das hat leider nichts genützt.

[Simon S. (simschmid)]

Hurrah, ich konnte den Code wie von euch empfohlen anpassen. Dabei kann 
ich mit dem Python Befehl "replace()" die gesendeten Bytes von den 
Empfangenen abziehen:

# Bytes einlesen
hexData = ser.read(100).hex()
# Antwort bereinigen
rxData = hexData.replace(''.join(format(x, '02x') for x in txData), "", 1)

Nun kann ich auch die Anzeige ansteuern mit den Befehlen, die ich 
gesnifft habe. Ich mache mich nun daran, die Bytes den einzelnen Pixeln 
der Anzeige zuzuordnen.

Nun muss ich aber erst mal herausfinden, wie die Checksumme berechnet 
wird. Was ich soweit sehe:

Startbyte und Endbyte sind jeweils "0x7E". Kann mir jemand anhand der 
Daten helfen, wie die Checksumme berechnet wird?

Hier ein paar Telegramme:

tx_301 = [0x7E,0x82,0x7D,0x5D,0x7E]
tx_302 = [0x7E,0x83,0x7C,0x7E]
tx_303 = [0x7E,0x84,0x7B,0x7E]
tx_304 = [0x7E,0x85,0x7A,0x7E]
tx_305 = [0x7E,0x86,0x79,0x7E]
tx_306 = [0x7E,0x87,0x78,0x7E]
tx_307 = [0x7E,0x88,0x77,0x7E]
tx_308 = [0x7E,0x89,0x76,0x7E]
tx_309 = [0x7E,0x8A,0x75,0x7E]
tx_310 = [0x7E,0x8B,0x74,0x7E]
tx_311 = [0x7E,0x8C,0x73,0x7E]
tx_312 = [0x7E,0x8D,0x72,0x7E]
tx_313 = [0x7E,0x8E,0x7D,0x5E,0x7E,0x00,0x00]
tx_314 = [0x7E,0x81,0x7D,0x5E,0x7E]
row_24 = [0x7E,0xA1,0x24,0x90,0x00,0x00,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0xEA,0x7E]
row_23 = [0x7E,0xA1,0x23,0x90,0x00,0x00,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0xED,0x7E]
row_22 = [0x7E,0xA1,0x22,0x90,0x00,0x00,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x00,0x00,0xEC,0x7E]

[Simon S. (simschmid)]

Die Checksumme ist gefunden: Es ist XORen der einzelnen Bytes (ohne 
Startbyte) und dann von 0xFF abziehen. In Python habe ich das mit 
folgender Funktion lösen können:

def checksum(data):
    xorval = 0
    for el in data:
        xorval ^= el
    return 255 - xorval

Die Bitmaps können nun verändert werden. Nächste Hürde wird nun sein, 
die Pixel eines Bildes den Pixeln auf der Anzeige zuordnen zu können. 
Dies wird spannend, da in zwei Halbbildern übertragen wird.