Serielle Kommunikation mit Hterm

Hallo,

ich möchte über RS232 an einen Arduino Daten senden. Jedes Byte soll in einer Variable gespeichert werden. Davon gibt es 65 stück.

zum Testen möchte ich mir die Variablen per RS232 zurück schicken lassen.

Wenn ich den Seriellen Monitor nutze, empfange ich die Daten... Nutze Ich aber HTerm, scheint die serielle Kommunikation beim Arduino deaktiviert zu sein. Die RX und TX LEDs leuchten gar nicht, obwohl er ständig senden müsste...

Baudrate und co habe ich alles passend eingestellt. Warum sendet er nur, wenn ich den seriellen monitor starte?

Der serielle Monitor resettet beim Öffnen der Verbindung automatisch den Arduino. Bei HTerm musst du dazu auf "DTR" klicken. Kann auch an was anderem liegen. Der Reset ist auch nicht unbedingt nötig.

Versuche mal DTR bei HTerm zu aktivieren - bei mir ist das ein Button in der Sektion "Input Control / Input Options" (hängt aber möglicherweise von der Version von HTerm ab, die du benutzt).

Und ich gehe mal davon aus, dass du die "Verbindungs-Dings" alle richtig eingestellt hast, also Port, Baud, Data, Stop, Parity.

Zum Hintergrund: Durch das DTR-Signal wird der Arduino resettet, wenn der serielle Port geöffnet wird. Beim seriellen Monitor der Arduino-IDE geschieht dies automatisch, bei HTerm kann man sich aussuchen ob ein DTR-Signal geschickt wird oder nicht.

Edit: und Serenifly war schneller :)

Hallo,

ich muß nichts reseten. Ich bin auch froh das er mit hterm eben nicht resetet wird.
Man muß nur aufpassen das man sich wieder disconnected.
Ich gebe dir mal mein Configfile. Müßtest nur die Baudrate und COM Port ändern.
Dann auf Connect drücken und später eben wieder Disconnect.

Edit:
Moment, wenn die TX/RX Led überhaupt nicht zucken, dann sendet der µC auch nichts.
Dann wird im Sketch irgendwas nicht stimmen. TX zuckt/leuchtet auch wenn man die Daten nicht ab nimmt.

Arduino_COM4_38400.zip (1.6 KB)

Mit dem DTR geht es... ich empfange die Daten. aber senden klappt noch nicht :-(

Vielen Danke schonmal.

Das Senden geht doch, habe grade das Beispiel gestestet…

Es ist also ein Problem mit dem Sketch

Hier ein Teil daraus:

void loop() {
if (Serial.available()) 
    Buttonset;
}

void Buttonset(){
  uppi = Serial.read();
  Serial.println(uppi);      
  ripi = Serial.read();      
  Serial.println(ripi);
  dopi = Serial.read();  
  Serial.println(dopi);  
...
...
...
...

Da stehen jetzt 65 mal [VARIABLE] = Serial.read(); Serial.println([VARIABLE]);

Genau diese 65 Bytes sollen übertragen werden, jede Variable ein Byte in der richtigen Reihenfolge eingespeichert werden und danach gesendet werden…

Das senden ist nur zum schauen ob es funktioniert hat…

gibt es eine funktionierende oder sogar elegantere Variante?

Das macht nichts:

Buttonset;

Warnungen einschalten, dann sollte das auch angemeckert werden

Dein Code ist außerdem fehlerhaft, weil du nicht beachtest wie langsam Serial ist. Wenn Serial.available() wahr ist ist nur 1 Zeichen im Eingangspuffer. Das nächste kommt erst einige Zeit später.

Wesentlich besser ist es die Variablen in eine union aus einem Array and einem struct zu packen. Dann eine Funktion wie readBytes() verwenden, der man die Adresse des Arrays übergibt:

union Data
{
  byte data[3];

  struct
  {
    byte var1;
    byte var2;
    byte var3;
  };
};

Data data;

void setup() 
{
  Serial.begin(9600);

}

void loop() 
{
  if (Serial.available())
  {
    Serial.readBytes(data.data, sizeof(data.data));

    Serial.println(data.var1);
    Serial.println(data.var2);
    Serial.println(data.var3);
    Serial.println("---");
    for (unsigned int i = 0; i < sizeof(data.data); i++)
      Serial.println(data.data[i]);
    Serial.println();
  }
}

Dann kann man die Variablen sowohl als Array als auch einzeln per Namen ansprechen. Alternativ könnte man auf die Union auch verzichten und einfach die Adresse des structs auf byte* casten.

Das funktioniert weil readBytes() blockierend ist.

Und für nicht-ASCII Bytes, wie Binär-Daten sollte man eher write() statt print() verwenden

Oh ja danke, so funktioniert es… aber mein Code sieht mittlweweile so schlimm aus:-/

Ich denke, dass dort noch einiges anders gemacht werden kann, aber das problem ist, dass ich nicht alles in arrays schreiben kann…

Naja ich mach mal feierabend, aber hier noch der Code:

#include<SPI.h>
#include<Wire.h>
#include<Adafruit_GFX.h>
#include<Adafruit_SSD1306.h>
#include"Adafruit_MCP23017.h"
Adafruit_SSD1306display(4);
Adafruit_MCP23017mca;
Adafruit_MCP23017mcb;
Adafruit_MCP23017mcc;
Adafruit_MCP23017mcd;
Adafruit_MCP23017mce;

charredpi;
chargreenpi;
charbluepi;
charredpii;
chargreenpii;
charbluepii;
charuppi;
charripi;
chardopi;
charlepi;
charuppii;
charripii;
chardopii;
charlepii;
charbtnapi;
chardspapi;
charbtnbpi;
chardspbpi;
charbtncpi;
chardspcpi;
charbtndpi;
chardspdpi;
charbtnepi;
chardspepi;
charbtnfpi;
chardspfpi;
charbtngpi;
chardspgpi;
charbtnapii;
chardspapii;
charbtnbpii;
chardspbpii;
charbtncpii;
chardspcpii;
charbtndpii;
chardspdpii;
charbtnepii;
chardspepii;
charbtnfpii;
chardspfpii;
charbtngpii;
chardspgpii;
charbtnaglb;
chardspaglb;
charbtnbglb;
chardspbglb;
charbtncglb;
chardspcglb;
charbtndglb;
chardspdglb;
charbtneglb;
chardspeglb;
charbtnfglb;
chardspfglb;
charbtngglb;
chardspgglb;
charbtnhglb;
chardsphglb;
charbtniglb;
chardspiglb;
charbtnjglb;
chardspjglb;
charbtnkglb;
charbtnlglb;
charway;

unionData
{
bytedata[65];

struct
{
bytevar1;
bytevar2;
bytevar3;
bytevar4;
bytevar5;
bytevar6;
bytevar7;
bytevar8;
bytevar9;
bytevar10;
bytevar11;
bytevar12;
bytevar13;
bytevar14;
bytevar15;
bytevar16;
bytevar17;
bytevar18;
bytevar19;
bytevar20;
bytevar21;
bytevar22;
bytevar23;
bytevar24;
bytevar25;
bytevar26;
bytevar27;
bytevar28;
bytevar29;
bytevar30;
bytevar31;
bytevar32;
bytevar33;
bytevar34;
bytevar35;
bytevar36;
bytevar37;
bytevar38;
bytevar39;
bytevar40;
bytevar41;
bytevar42;
bytevar43;
bytevar44;
bytevar45;
bytevar46;
bytevar47;
bytevar48;
bytevar49;
bytevar50;
bytevar51;
bytevar52;
bytevar53;
bytevar54;
bytevar55;
bytevar56;
bytevar57;
bytevar58;
bytevar59;
bytevar60;
bytevar61;
bytevar62;
bytevar63;
bytevar64;
bytevar65;
};
};

Datadata;

voidsetup(){
//startserialportat9600bps:
Serial.begin(9600);
display.begin(SSD1306_SWITCHCAPVCC,0x3C);
display.clearDisplay();
display.setTextColor(WHITE);
display.setTextSize(5);
mca.begin(0);
mcb.begin(1);
mcc.begin(2);
mcd.begin(3);
mce.begin(4);
//PinsEinstellen
mca.pinMode(0,INPUT);
mca.pullUp(0,HIGH);
mca.pinMode(1,INPUT);
mca.pullUp(1,HIGH);
mca.pinMode(2,INPUT);
mca.pullUp(2,HIGH);
mca.pinMode(3,INPUT);
mca.pullUp(3,HIGH);
mca.pinMode(4,INPUT);
mca.pullUp(4,HIGH);
mca.pinMode(5,INPUT);
mca.pullUp(5,HIGH);
mca.pinMode(6,INPUT);
mca.pullUp(6,HIGH);
mca.pinMode(7,INPUT);
mca.pullUp(7,HIGH);
mca.pinMode(8,INPUT);
mca.pullUp(8,HIGH);
mca.pinMode(9,INPUT);
mca.pullUp(9,HIGH);
mca.pinMode(10,INPUT);
mca.pullUp(10,HIGH);
mca.pinMode(11,INPUT);
mca.pullUp(11,HIGH);
mca.pinMode(12,INPUT);
mca.pullUp(12,HIGH);
mca.pinMode(13,INPUT);
mca.pullUp(13,HIGH);
mca.pinMode(14,INPUT);
mca.pullUp(14,HIGH);
mca.pinMode(15,INPUT);
mca.pullUp(15,HIGH);
mca.pinMode(0,INPUT);
mca.pullUp(0,HIGH);
mcb.pinMode(1,INPUT);
mcb.pullUp(1,HIGH);
mcb.pinMode(2,INPUT);
mcb.pullUp(2,HIGH);
mcb.pinMode(3,INPUT);
mcb.pullUp(3,HIGH);
mcb.pinMode(4,INPUT);
mcb.pullUp(4,HIGH);
mcb.pinMode(5,INPUT);
mcb.pullUp(5,HIGH);
mcb.pinMode(6,INPUT);
mcb.pullUp(6,HIGH);
mcb.pinMode(7,INPUT);
mcb.pullUp(7,HIGH);
mcb.pinMode(8,INPUT);
mcb.pullUp(8,HIGH);
mcb.pinMode(9,INPUT);
mcb.pullUp(9,HIGH);
mcb.pinMode(10,INPUT);
mcb.pullUp(10,HIGH);
mcb.pinMode(11,INPUT);
mcb.pullUp(11,HIGH);
mcb.pinMode(12,INPUT);
mcb.pullUp(12,HIGH);
mcb.pinMode(13,INPUT);
mcb.pullUp(13,HIGH);
mcb.pinMode(14,INPUT);
mcb.pullUp(14,HIGH);
mcb.pinMode(15,INPUT);
mcb.pullUp(15,HIGH);
mca.pinMode(0,INPUT);
mca.pullUp(0,HIGH);
mcc.pinMode(1,INPUT);
mcc.pullUp(1,HIGH);
mcc.pinMode(2,INPUT);
mcc.pullUp(2,HIGH);
mcc.pinMode(3,INPUT);
mcc.pullUp(3,HIGH);
mcc.pinMode(4,INPUT);
mcc.pullUp(4,HIGH);
mcc.pinMode(5,INPUT);
mcc.pullUp(5,HIGH);
mcc.pinMode(6,INPUT);
mcc.pullUp(6,HIGH);
mcc.pinMode(7,INPUT);
mcc.pullUp(7,HIGH);
mcc.pinMode(8,OUTPUT);
mcc.pinMode(9,OUTPUT);
mcc.pinMode(10,OUTPUT);
mcc.pinMode(11,OUTPUT);
mcc.pinMode(12,OUTPUT);
mcc.pinMode(13,OUTPUT);
mcc.pinMode(14,OUTPUT);
mcc.pinMode(15,OUTPUT);
mcd.pinMode(0,OUTPUT);
mcd.pinMode(1,OUTPUT);
mcd.pinMode(2,OUTPUT);
mcd.pinMode(3,OUTPUT);
mcd.pinMode(4,OUTPUT);
mcd.pinMode(5,OUTPUT);
mcd.pinMode(6,OUTPUT);
mcd.pinMode(7,OUTPUT);
mcd.pinMode(8,OUTPUT);
mcd.pinMode(9,OUTPUT);
mcd.pinMode(10,OUTPUT);
mcd.pinMode(11,OUTPUT);
mcd.pinMode(12,OUTPUT);
mcd.pinMode(13,OUTPUT);
mcd.pinMode(14,OUTPUT);
mcd.pinMode(15,OUTPUT);
mce.pinMode(0,OUTPUT);
mce.pinMode(1,OUTPUT);
mce.pinMode(2,OUTPUT);
mce.pinMode(3,OUTPUT);
mce.pinMode(4,OUTPUT);
mce.pinMode(5,OUTPUT);
mce.pinMode(6,OUTPUT);
mce.pinMode(7,OUTPUT);
mce.pinMode(8,OUTPUT);
mce.pinMode(9,OUTPUT);
mce.pinMode(10,OUTPUT);
mce.pinMode(11,OUTPUT);
mce.pinMode(12,OUTPUT);
mce.pinMode(13,OUTPUT);
mce.pinMode(14,OUTPUT);
mce.pinMode(15,OUTPUT);
pinMode(13,OUTPUT);

}

voidloop(){
if(Serial.available())
{
Serial.readBytes(data.data,sizeof(data.data));
knopfe();
}

}




voidknopfe(void){
inti=0;
redpi=data.data[i];i++;
analogWrite(13,(int)redpi);
Serial.println(redpi);
greenpi=data.data[i];i++;
analogWrite(5,greenpi);
bluepi=data.data[i];i++;
analogWrite(6,bluepi);
redpii=data.data[i];i++;
analogWrite(9,redpii);
greenpii=data.data[i];i++;
analogWrite(10,greenpii);
bluepii=data.data[i];i++;
analogWrite(11,bluepii);


uppi=data.data[i];i++;
Serial.println(uppi);
ripi=data.data[i];i++;
Serial.println(ripi);
dopi=data.data[i];i++;
Serial.println(dopi);
lepi=data.data[i];i++;
Serial.println(lepi);
uppii=data.data[i];i++;
Serial.println(uppii);
ripii=data.data[i];i++;
Serial.println(ripii);
dopii=data.data[i];i++;
Serial.println(dopii);
lepii=data.data[i];i++;
Serial.println(lepii);
btnapi=data.data[i];i++;
Serial.println(btnapi);
dspapi=data.data[i];i++;
Serial.println(dspapi);
btnbpi=data.data[i];i++;
Serial.println(btnbpi);
dspbpi=data.data[i];i++;
Serial.println(dspbpi);
btncpi=data.data[i];i++;
Serial.println(btncpi);
dspcpi=data.data[i];i++;
Serial.println(dspcpi);
btndpi=data.data[i];i++;
Serial.println(btndpi);
dspdpi=data.data[i];i++;
Serial.println(dspdpi);
btnepi=data.data[i];i++;
Serial.println(btnepi);
dspepi=data.data[i];i++;
Serial.println(dspepi);
btnfpi=data.data[i];i++;
Serial.println(btnfpi);
dspfpi=data.data[i];i++;
Serial.println(dspfpi);
btngpi=data.data[i];i++;
Serial.println(btngpi);
dspgpi=data.data[i];i++;
Serial.println(dspgpi);
btnapii=data.data[i];i++;
Serial.println(btnapii);
dspapii=data.data[i];i++;
Serial.println(dspapii);
btnbpii=data.data[i];i++;
Serial.println(btnbpii);
dspbpii=data.data[i];i++;
Serial.println(dspbpii);
btncpii=data.data[i];i++;
Serial.println(btncpii);
dspcpii=data.data[i];i++;
Serial.println(dspcpii);
btndpii=data.data[i];i++;
Serial.println(btndpii);
dspdpii=data.data[i];i++;
Serial.println(dspdpii);
btnepii=data.data[i];i++;
Serial.println(btnepii);
dspepii=data.data[i];i++;
Serial.println(dspepii);
btnfpii=data.data[i];i++;
Serial.println(btnfpii);
dspfpii=data.data[i];i++;
Serial.println(dspfpii);
btngpii=data.data[i];i++;
Serial.println(btngpii);
dspgpii=data.data[i];i++;
Serial.println(dspgpii);
btnaglb=data.data[i];i++;
Serial.println(btnaglb);
dspaglb=data.data[i];i++;
Serial.println(dspaglb);
btnbglb=data.data[i];i++;
Serial.println(btnbglb);
dspbglb=data.data[i];i++;
Serial.println(dspbglb);
btncglb=data.data[i];i++;
Serial.println(btncglb);
dspcglb=data.data[i];i++;
Serial.println(dspcglb);
btndglb=data.data[i];i++;
Serial.println(btndglb);
dspdglb=data.data[i];i++;
Serial.println(dspdglb);
btneglb=data.data[i];i++;
Serial.println(btneglb);
dspeglb=data.data[i];i++;
Serial.println(dspeglb);
btnfglb=data.data[i];i++;
Serial.println(btnfglb);
dspfglb=data.data[i];i++;
Serial.println(dspfglb);
btngglb=data.data[i];i++;
Serial.println(btngglb);
dspgglb=data.data[i];i++;
Serial.println(dspgglb);
btnhglb=data.data[i];i++;
Serial.println(btnhglb);
dsphglb=data.data[i];i++;
Serial.println(dsphglb);
btniglb=data.data[i];i++;
Serial.println(btniglb);
dspiglb=data.data[i];i++;
Serial.println(dspiglb);
btnjglb=data.data[i];i++;
Serial.println(btnjglb);
dspjglb=data.data[i];i++;
Serial.println(dspjglb);
btnkglb=data.data[i];i++;
Serial.println(btnkglb);
btnlglb=data.data[i];i++;
Serial.println(btnlglb);
way=data.data[i];i++;
Serial.println(way);


}

for-Schleifen sind dein Freund! Auch für das setzten der Pins in setup(). Pin Definitionen in Arrays und darüber iterieren

Außerdem kannst du auch einfach sowas schreiben:

greenpii=data.data[i++];

Post-Inkrement gibt erst den Wert zurück und inkrementiert danach

Aber es war so gedacht dass du charbtnfpii, etc. in das struct schreibst! Also die sprechenden Namen. Das oben war nur ein Beispiel. Deshalb die allgemeinen Namen. Wieso das nochmal extra umkopieren?

Falls das nicht klar ist: bei einer Union belegen das Array und das struct den gleichen Speicher! Wenn du also per readBytes() die Daten in das Array liest, stehen sie danach automatisch im struct

Was du machst ist völliger Blödsinn und macht den ganzen Sinn der union/struct Idee kaputt :( Schau dir meinen Code nochmal genau an! Ich lese die Daten ein und gebe sie dann zweimal aus. Einmal direkt über die Namen (ohne irgendwas zu kopieren!). Und einmal per for-Schleife mit dem Array. Es geht so oder so.

Ja, ich habe einfach mal drauf los programmiert, wollte die variablen passend benennen, aber bei dem Umfang denke ich stricke das komplett um und mach daraus Arrays

Ja, Arrays sind für sowas übersichtlicher, da man alles auf einmal auslesen kann und mit einer for-Schleife bearbeiten kann.

Aber mit Unions geht eben beides auf einmal. Wie gesagt in einer Union belegen alle Bestandteile den gleichen Speicher. Und alles im struct gehört zusammen. Also entspricht das Array genau den Variablen. Das wird heutzutage nicht mehr so oft gemacht, da Unions auf modernen Computern Probleme mit der Speicherausrichtung haben, aber in low level Treiber Code in C sieht man das immer noch. Und auf einem 8 Bit Prozessor ist es überhaupt kein Problem.

So, habe alles passend umgestrickt…

Ich habe aber noch ein Problem, der Arduino scheint damit nicht zurecht zu kommen:

  void displays(void){
  String text[256];
  text[0]=" ";
  text[1]="JMP";
  text[2]="RUN";
  text[3]="PUNCH";
  text[4]="KICK";
  text[5]="SHOT";
  text[6]="SHOT2";
  text[7]="DUCK";
  text[8]="BLOCK";
  text[9]="QUIT";
  text[10]="1P";
  text[11]="2P";
  text[12]="3P";
  text[13]="4P";
  text[14]="LEFT";
  text[15]="RIGHT";
  text[16]="UP";
  text[17]="DOWN";
  text[18]="NEXT";
  text[19]="LAST";
  text[20]="ENTER";
  text[21]="MAP";
  text[22]="MARK";
  text[23]="USE";
  text[24]=" ";
  text[25]=" ";
  text[26]=" ";
  text[27]=" ";
  text[28]=" ";
  text[29]=" ";
  text[30]=" ";
  text[31]=" ";
  text[32]=" ";
  text[33]=" ";
  text[34]=" ";
  text[35]=" ";
  text[36]=" ";
  text[37]=" ";
  text[38]=" ";
  text[39]=" ";
  text[40]=" ";
  text[41]=" ";
  text[42]=" ";
  text[43]=" ";
  text[44]=" ";
  text[45]=" ";
  text[46]=" ";
  text[47]=" ";
  text[48]=" ";
for(i=15;i<=29;i+2)
    tcaselect(((i-15)/2));
    display.begin(SSD1306_SWITCHCAPVCC, 0x3C);           
    display.clearDisplay();
    display.println(text[Panel[i]]);
    display.display();

Er springt nichtmal in die for schleife Lade ich das Array falsch?

Ok,

die geschweiften klammern habe ich mittlerweile selbst entdeckt,

aber das war es nicht

Habs,

String Array mit 256 Feldern scheint zu groß zu sein… mit 100 gehts

Das ist trotzdem der falsche Weg. So viele String Objekte ins RAM zu schreiben ist Irrsinn. Bei sowas verwendet man C Strings, schreibt diese per PROGMEM ins Flash (davon ist genug da) und kopiert jeweils nur den aktuellen String in RAM:

//Strings ins Flash schreiben
const char text0[] PROGMEM = " ";
const char text1[] PROGMEM = "JMP";
const char text2[] PROGMEM = "RUN";
const char text3[] PROGMEM = "PUNCH";
const char text4[] PROGMEM = "KICK";
const char text5[] PROGMEM = "SHOT";
const char text6[] PROGMEM = "SHOT2";
const char text7[] PROGMEM = "DUCK";

//Zeiger auf die Strings ebenfalls in Flash. Jeder davon braucht 2 Bytes!
const char* const textArray[] PROGMEM =
{
  text0, text1, text2, text3, text4, text5, text6, text7
};

char textBuffer[16]; //Puffer im RAM für aktuellen String. Muss mindestens Platz für längsten String + 1 haben
const int NUM_OF_STRINGS = sizeof(textArray) / sizeof(textArray[0]);     //Anzahl der Strings automatich berechnen


void setup()
{
  Serial.begin(9600);

  for (unsigned int i = 0; i < NUM_OF_STRINGS ; i++)
  {
    //String aus Flash ins RAM kopieren. Dabei wird erst der Zeiger per pgm_read_word() kopiert und mit diesem dann der eigentliche String
    strncpy_P(textBuffer, (const char*)pgm_read_word(&textArray[i]), sizeof(textBuffer));

    Serial.println(textBuffer);
  }
}

void loop()
{
}

Und schon brauchst du für das alles nur 16 Bytes RAM (weniger geht auch bei kürzeren Strings)

Die PROGMEM Definition müssen aber unbedingt global sein. Nicht in einer Funktion!

Ok, muss ich mir mal verinnerlichen, aber speicher habe ich genug, bin jetzt grade erst bei 60%.

Naja man merkt halt, es ist bei mir learning by doing. habe alles nur mit tutorials und beispielen gelernt…

ich habe noch ein Problem mit dem Code:

if (Serial.available())
  {
    j=Serial.readBytes(Panel, 65);
    for(i=0;i<=j;i++)
    Serial.println(Panel[i]);
    }

Das scheint nicht zu funktionieren:

Es sollte das gleiche empfangen werden wie gesendet

Ok, muss ich mir mal verinnerlichen, aber speicher habe ich genug, bin jetzt grade erst bei 60%.

Wenn du mit dynamischem Speicher arbeitest ist dass was in der IDE angezeigt wird nicht unbedingt was tatsächlich belegt wird. Was du beschrieben hast ist definitiv ein Speicher-Problem

Hier ist was die String Klasse intern als Variablen verwaltet:

    char *buffer;           // the actual char array
    unsigned int capacity;  // the array length minus one (for the '\0')
    unsigned int len;       // the String length (not counting the '\0')

Für jedes Objekt! Ohne den eigentlichen String. Wie gesagt, hunderte String Objekte anzulegen ist Irrsinn.

aja man merkt halt, es ist bei mir learning by doing. habe alles nur mit tutorials und beispielen gelernt

Man sieht es. Du musst dich dringend mal etwas mit den Hintergründen befassen

Mach sicher dass in HTerm die Eingabe richtig eingestellt ist!! ASCII wenn ASCII möchtest und DEC oder HEX wenn es Zahlen sein sollen. Das ist ganz, ganz wichtig. Wenn du "45" eintippst und du ASC sendest, ist das was ganz anderes. Ich kann auf dem Screenshot nicht erkennen was du machst, da er nicht vergrößerbar ist.

Was auch auffällt ist dass du println() machst, aber HTerm scheinbar nicht so eingestellt hast dass es die Zeilenumbrüche auch anzeigt. Also entwender "newline at CR+LF" aktivieren (und evtl. "show newline characters" deaktivieren) oder auf dem Arduino nur print() machen

Im Programm bringe nicht byte und char durcheinander. char wird oft eher als ASCII interpretiert.

Ich habe dir jedenfalls vor Tagen einen funktionierenden Code geliefert. Der geht wenn man HTerm so einstellt dass Dezimal gesendet wird und Dezimal angezeigt wird. Wieso also nicht versuchen das zu verstehen statt willkürlich Sachen auszuprobieren?

Und gewöhne dir an für die Größe von Arrays sizeof() zu verwenden, statt das per Hand zu schreiben. Das ist weniger fehleranfällig und passt sich automatisch an wenn man die Array-Größe ändert. Geht natürlich nicht wenn man nur einen Zeiger an eine Funktion übergibt, aber soweit wirst du noch nicht sein

ich habe noch ein Problem mit dem Code:

if (Serial.available())

{
    j=Serial.readBytes(Panel, 65);
    for(i=0;i<=j;i++)
    Serial.println(Panel[i]);
}

Ich habe auch ein Problem mit dem “Code”:
loop und das übliche void setup() { Serial.begin(9600); } kann ich ja raten, aber
i, jund besondersPanelsind nicht definiert. Je nach Definition passiert aber was ganz anderes.

j und i sind jeweils int und sie werden ja da in dem ausschnitt mit einem wert belegt… i mit 0 zu beginn der for schleife und j soll durch Serial.readBytes(Panel, 65); die menge der im buffer befindlichen Bytes ausgeben… dadurch wird die for schleife nur so oft gemacht wie auch bytes im buffer sind…

zu dem Code:

if (Serial.available())
  {
    j=Serial.readBytes(Panel, 65);
    for(i=0;i<=j;i++)
    Serial.println(Panel[i]);
    }

Ich habe immer einen Sketch namens test.ino nebenbei und da versuche ich so wenig funktionen wie möglich rein zu bringen, deswegen direkt 65, um fehlerquellen auszuschließen.

Jetzt bekomme ich aber immer das wieder, was ich gesendet habe… das passt also nur die Displays bekommen noch nicht das passende zum Anzeigen…

j und i sind jeweils int und sie werden ja da in dem ausschnitt mit einem wert belegt

Klar, das kann ich auch raten, du hättest auch

    byte j=Serial.readBytes(Panel, 65);
    for(byte i=0;i<=j;i++)

schreiben können, aber der Datentyp vonPanelist entscheidend dafür, was
    Serial.println(Panel[i]); 
macht