Serielle Schnittstelle Auslesen

Liebe Arduino - Gemeinde,

mein Display wandelt meine Integren Ganzzahlen in einen HEX Wert um. So wird aus einem Druck-Befehl, der wiederum durch das Drücken auf einen Buttons ausgelöst wird.
print 23
print 125
print 77
am Ende: 17 00 00 00 7D 00 00 00 4D 00 00 00

Was ich möchte sind am Ende wieder Ganzzahlen, in einer Variablen. So das mir immer 3 Variablen mit drei Ganzzahlen bei jedem Druck auf einen Button zur Verfügung stehen.

Einfache Codefetzen wie so was aussieht bringt mich in der Regel am besten Voran.

Lieben Dank für Eure Hilfe

Hallo
Zeige deinen Sketch, damit das Ganze ein bißchen klarer wird was dein Plan ist.

Sorry, aber ich verstehe kein Wort, was Da da willst. Du musst dein Projekt schon etwas besser beschreiben. Und poste Links zu den verwendeten Kompoinenten. Was ist das für ein Display, das Ganzzahlen in HEX umwandelt? Und was hat das Ganze mit 'Serielle Schnittstelle auslesen' zu tun?

Sorry ich dachte die Fragestellung sei klar. Ich möchte aus dem HEX Wert der übertragen wurde die drei Ganzzahlen extrahieren. So das ich am Ende 3 Variablen vom Typ int habe, in dem diese 3 Ganzzahlen stehen.
Ich kann mir vorstellen das Ihr hierfür sicherlich eine Lösung habt. Das Display und meine Fehlversuche an Sketche werden dabei weniger helfen.

Jedoch kann ich gerne sagen was ich damit bezwecke. Ich möchte im Programmcode ohne lange Abfrage über drei Ebenen schnell ans Ziel. Will heißen bei 5000 Knöpfen sollen nicht 5000 Möglichkeiten abgefragt werden sondern erst einmal 70 Kategorien in denen wiederum die 5000 Knöpfe aufgeteilt sind. Es wäre schön wenn das hier nicht zum Aufhänger für eine Diskussion wird und man es so stehen lassen könnte. :slight_smile: Mir geht es mehr um den Lösungsansatz.

Hallo,
Bitte beachte die Regeln des Forums.
Zeige uns einen guten Schaltplan der Schaltung.
Zeige uns ein gutes Bild der 'tatsächlichen' Verdrahtung.
Gebe alle Links zu den Komponenten an.
Bilder posten:
https://forum.arduino.cc/index.php?topic=519037.0
Verwende CTRL T, um den Code zu formatieren.
Fügen die 'vollständige' Skizze zwischen den Code-Tags ein.

Fügen Sie Ihre Skizze hier ein

Bedenke: wir können weder in deinen Kopf, noch auf deinen Basteltisch schauen. Wo wird was in welcher Form übertragen? HEX-Werte als ASCII-Zeichen? binär? Beschreibe genau was, da übertragen wird. 'HEX' und 'Ganzzahlen' sind da etwas zu global. Wenn Du so willst, sind HEX-Werte Ganzzahlen. Was willst Du also wirklich 'extrahieren'. Und was sind dann die drei Ganzzahlen?

ardubeginner2020:
Es wäre schön wenn das hier nicht zum Aufhänger für eine Diskussion wird und man es so stehen lassen könnte. :slight_smile: Mir geht es mehr um den Lösungsansatz.

Lösungsansatz - schön. Aber wenn ich das Problem nicht verstehe kann es auch keinen Lösungsansatz geben. Und was deine Ursprungsfrage mit den 5000 Knöpfen zu tun hat, kann ich mir auch nur sehr nebulös vorstellen.
Also nochmal beschreibe genau was wo übertragen/empfangen wird, und was Du daraus extrahieren willst.
Am besten anhand eines nachvollziehbaren Beispiels.

0d23 = 0x17
0d125 = 0x7D
0d77= 0x4D

was willst du nun genau?

Welche Variable hast du?
Was steht in der Variable?
Was willst du auf wohin ausgeben?

Mach einen kompilierbaren Sketch den wir verwenden können.

noiasca:
0d23 = 0x17
0d125 = 0x7D
0d77= 0x4D

was willst du nun genau?

Welche Variable hast du?
Was steht in der Variable?
Was willst du auf wohin ausgeben?

Mach einen kompilierbaren Sketch den wir verwenden können.

42

Ich kenne eigentlich kein Display das irgendwas was es bekommt in HEX Format ausgibt. Da ist immer etwas das die Werte in Hex-Strings Umwandelt und dann zum Darstellen verschickt.

@ardubeginner2020
Wir brauchen einige INFOS:

Welches Displa hast Du. Welche Hardware (Arduino oder ähnliches). Wie ist das Display angeschlossen.

Wenigstens Teilsketch damit wir sehen was Du versendest.

Am einfachsten wäre es, wenn Du einen kurzen Sketch schreibst wo Du eine Zahl auf das Display schreibst und das Problem auftritt. Ein Foto von dem was auf dem Display zu sehen ist wäre auch schön.

Grüße Uwe

Ich glaube, ich habe eine Idee davon was da vor sich geht - siehe Bild aus meinem Nextion-Simulator.

Wenn der Beginner das bestätigt, könnte ich mich vielleicht zu einem Codefetzen hinreißen lassen.
Da kommen ja als Zeichenkette die vier Byte eines int32_t (little Endian). Wenn man die jetzt richtig herum anordnet, jeweils eine '\0' dranhängt und mit sscanf( "%X") ausliest, ist die Zahl fertig.

Ich korrigiere:
Die Werte kommen schon binär auf der Schnittstelle an.
Dann ist der Code trivial (getestet auf ESP32):

    union
    {
        char buf[12];
        struct 
        {
            int32_t value1;
            int32_t value2;
            int32_t value3;
        } values;
    } receiveData;
    
    // Das ist meine Funktion, die buf mit den 12 Byte füllt (wird von einem echten Nextion gelesen).
    disp.getReceiveBuffer(receiveData.buf, 0, 12);

    Serial.print(F("wert 1: "));
    Serial.println(receiveData.values.value1);
    Serial.print(F("wert 2: "));
    Serial.println(receiveData.values.value2);
    Serial.print(F("wert 3: "));
    Serial.println(receiveData.values.value3);

Und die Ausgabe - wie erwartet:

wert 1: 23
wert 2: 125
wert 3: 77

Danke für die Rückmeldungen und ich bitte um Verzeihung wenn mir die Regeln des Forums nicht korrekt befolgt habe.
Walter oder wno158 hat es genau auf den Punkt gebracht. Hier liegt mein Problem mit dem Nextion Display und der sich ergebenden HEX Werten.

Es geht um den Weg Rückwerts wieder zu den Zahlen die im print Befehl angegeben waren.

Da kommen ja als Zeichenkette die vier Byte eines int32_t (little Endian). Wenn man die jetzt richtig herum anordnet, jeweils eine '\0' dranhängt und mit sscanf( "%X") ausliest, ist die Zahl fertig.

Leider kann ich mit den hier aufgezeigten Angaben noch recht wenig anfangen. Könnte mir das jemand in einem Beispielcode veranschaulichen?

Nee, ich hatte mich geirrt. Als ich es ausprobiert hatte, habe ich meinen Beitrag nochmal geändert. Da ist dann auch die passende Datenstruktur angegeben.

Du musst nur den Buffer mit den empfangenen Bytes füllen.

Erst einmal recht herzlichen Dank für Deine Antwort!

Ich möchte versuchen den Code zu dokumentieren, da ich noch nicht weis ob ich alles halbwegs richtig verstanden habe.
Vorab bin ich jedoch über deine Aussage gestolpert:
// Das ist meine Funktion, die buf mit den 12 Byte füllt (wird von einem echten Nextion gelesen).[/color][/quote]
es ist ein original Nextion, doch lesen soll das ganze der Arduino 2560.

    union // Eine mir unbekannte Funktion (bin kein C++ Profi)
    {
        char buf[12]; // Definition des char array  mit dem Namen "buf" und der Größe des Array
        struct // Eine mir unbekannte Funktion wird wohl mit dem Strukturaufbau der Daten zusammenhängen
        {
            int32_t value1; //3 x Definition einer Variablen Namens "value" + Ziffer des Typs int32_t vermutlich 32 Bit pro Datensatz
            int32_t value2;
            int32_t value3;
        } values; //Mutter der drei Variablen "value" 
    } receiveData; // Funktion zum aufrufen der Inhalte - Namen änderbar?? [/color]
   
    // Das ist meine Funktion, die buf mit den 12 Byte füllt (wird von einem echten Nextion gelesen).
    disp.getReceiveBuffer(receiveData.buf, 0, 12); // Ich gehe davon aus das hier die Daten eingelesen werden im Nextion

//Folgend die Ausgabe von Text und dem Inhalt der Variablen
    Serial.print(F("wert 1: "));
    Serial.println(receiveData.values.value1);
    Serial.print(F("wert 2: "));
    Serial.println(receiveData.values.value2);
    Serial.print(F("wert 3: "));
    Serial.println(receiveData.values.value3);

Ich hoffe das ich es zumindest in groben Zügen verstanden habe. 
Als ich das versucht habe in der Arduino IDE nachzubauen kam die erste Fehlermeldung mit der Variablen "buf" da diese nur lokal ist. Ich habe keine Ahnung wie ich die mit 
[code]buf[12] = Serial1.read();
füttern kann wenn ich sie erst gar nicht erreiche. Ist es nicht so das wenn ich diese Variable global erstelle, sie dennoch nicht die gleiche ist wie die lokale?

Gruß Stefan

Schmeiß bitte den color-Müll aus Deinem Code!

ardubeginner2020:

    union // Eine mir unbekannte Funktion (bin kein C++ Profi)

Hier steckt Dein Problem oder Nichtwissen. Lies bitte daher erstmal Data structures und dann Unions.

Hab den unnötigen Code entfernt.
Ich finde es schade dass Du mir mit Deinem geballten wissen nur einen Verweis auf das Thema gibst anstelle eines anschaulichen und gut kommentierten Code. Für Anfänger, wie ich es bin oder für Menschen die nach dem Thema suchen, wäre das sicherlich sehr viel hilfreicher.

ardubeginner2020:
Ich finde es schade dass Du mir mit Deinem geballten wissen nur einen Verweis auf das Thema gibst anstelle eines anschaulichen und gut kommentierten Code. Für Anfänger, wie ich es bin oder für Menschen die nach dem Thema suchen, wäre das sicherlich sehr viel hilfreicher.

Warum sollen wir dir alles vorkauen, wenn du es selbst lernen sollst.
Zudem bertifft das Ändern deines Sketches das rauslöschen der Farbcodierung, die deinen Sketch unleserlich machen. Wozu brauchst du da noch weiter Tipps ?

Moin Stefan,
sieht so aus als wäre der Fetzen doch zu klein gewesen ;).

Hardware:
Wir haben ein Nextion und einen Rechner (bei Dir Arduino Mega, bei mir ESP32 - egal). Unser Setup ist also äquivalent.
Die sind verbunden über eine serielle Schnittstelle, auf der Anweisungen zum Display (z.B. "page 1" FF FF FF) gesendet werden oder Daten vom Display empfangen werden (das, was Du mit 'print' auf die Reise schickst).

Software:

disp.getReceiveBuffer(receiveData.buf, 0, 12); // Ich gehe davon aus das hier die Daten eingelesen werden im Nextion

Nein, nicht im Nextion, sondern vom Nextion.

Ich habe an anderer Stelle einen geheimen Puffer, in den ich die vom Display kommenden Daten zeichenweise einlese (der Code ist gerade 25km entfernt). Da man nicht erwarten kann, bei einem Aufruf alle Daten schon in einem Rutsch zu bekommen, muss man sich auf teilweises Lesen einstellen und erst dann mit den Daten weiterarbeiten wenn alles komplett ist.

Wenn genug Futter da ist, hole ich mir die mit getReceiveBuffer() ab. Dahinter verbirgt sich eigentlich nur ein memcpy() vom Geheimpuffer ab einer bestimmten Stelle (0) mit einer gewissen Länge (12).

Wenn Du inzwischen ein wenig über 'union' gelesen hast:
Die Variable, in die die Daten eingelesen werden, heißt receiveData. Das ist halt kein einfacher Datentyp, sondern unwesentlich komplizierter aufgebaut - am Ende ist es aber eigentlich nur eine Variablendefinition wie jede andere auch. Die kannst Du lokal in einer Funktion oder global aufführen.

union {...} receiveData;

Auf den davon belegten Speicherplatz kannst Du entweder über buf (Array aus 12 char) oder aber über die Struktur values mit ihren drei einzelnen, jeweils vier Byte langen Integern zugreifen.
Das erste verwende ich beim Abholen der Daten, der volle Name ist dann receiveData.buf.
Das zweite nutze ich beim Schreiben der Werte. Die drei Variablen, die Du Dir im Eingangspost gewünscht hast, heißen dann receiveData.values.value1 (bis 3).

ardubeginner2020:
Sorry ich habe keine Ahnung wie ich einen Post nachträglich ändern kann.

Rechts unter deinem Post findest Du 'quick edit' und 'more'. Bei Quickedit bekommst Du einen ganz einfachen Texteditor direkt im Fenster des Posts. Bei 'more' kannst Du auswählen, ob Du den Text im normalen Editor ( wie bei der Ersterstellung ) bearbeiten willst, oder ob Du ihn löschen willst.