Processing empfängt keine Daten von Arduino

Hallo,
ich bin neu hier und hoffe das hier ist das richtige Forum. Ich sitze seit längerem an folgendem Problem.

Ich versuche von meinem Arduino Daten in Processing zu visualisieren, allerdings empfängt das Programm keine Daten. Dazu habe ich einen Lichtsensoren am Arduino angeschlossen. Dessen sich ändernde Spannung soll als Kurve in Processing dargestellt werden. Das Hintergrundraster wird zwar dargestellt, allerdings erscheint die Kurve nicht.
Ich habe das ganze auch mit einem zweiten Sketch und einem anderen Aufbau versucht, mit dem selben Problem.

Folgende Fehlerquellen habe ich bereits überprüft:

  • in Processing über "println(serialValue)" überprüft dass der USB-Port korrekt ist.
  • in Processing über "println(serial.list())" die übertragenen Werte darstellen lassen. Der Wert bleibt auf 0, was heißt das nichts ankommt.
  • In Arduino selber die Werte über "Serial.println" im seriellen Monitor ausgeben lassen. Hier funktioniert alles einwandfrei und die Werte schwanken in Abhängigkeit des Lichteinfalls auf den Sensor.

Das heißt doch dann dass die Schaltung und der Code in Ordnung sein sollten und das Problem irgendwo auf dem Weg zwischen Arduino und der Processing Software liegt, oder? Hat jemand eine Idee wo der Fehler liegen könnte?

Leider ist Processing für mich vollkommen neu. Ich hoffe jemand kann mir helfen.

Vielen Dank im voraus
Sam

Hier noch der Code für Arduino:

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

void loop() {
Serial.println(analogRead(A0));
delay(10);
}

und der für Processing:

import processing.serial.*;

Serial meinSeriellerPort;
int xPos = 1;
int serialValue;
int[] yPos;

void setup(){
  size(400, 300);
  println(Serial.list());
  meinSeriellerPort = new Serial(this, Serial.list()[1], 9600);
  meinSeriellerPort.bufferUntil('\n');
  
  background(0);
  yPos = new int[width];
}

void draw(){
  background(0);
  stroke(255, 255, 0, 120);
  for(int i=0; i < width; i+=50)
  line(i, 0, i height);
  for(int i=0; i < height; i+=50)
  line(i, 0, i width);
  
  stroke(255, 0, 0);
  strokeWeight(1);
  int yPosPrev = 0, xPosPrev = 0);
  println(serialValue);
  
  for(int x = 1; x < width; x++)
  yPos[x-1] = yPos[x];
  
  yPos[width - 1] = serialValue;
  
  for(int x = 0; x < width, x++){
    if(x >0)
    line(xPosPrev, yPosPrev, x, yPos[x]);
    xPosPrev = x;
    yPosPrev = yPos[x];
  }
}

Setze Deinen Code bitte in Codetags (</>-Button oben links im Forumseditor oder [code] davor und [/code] dahinter ohne *).

Lass Dir den Inhalt von meinSeriellerPort im Prozessing mal anzeigen, dass Du auch den richtigen Port hast.

Gruß Tommy

Edit: Der Arduino muss vorm Prozessing da sein

Dein Code ist (höchstwarhscheinlich) verstümmelt, weil er nicht in Code-Tags gestellt wurde.
Was aber schon zu sehen ist, dass du an keiner Stelle den seriellen Port ausliest. Etwa mit einer Anweisung wie:

serialValue = meinSeriellerPort.read();

Schau dir die Beispiele in Processing an, die sich mit der seriellen Schnittstelle beschäftigen.
Es ist zwar schon einige Zeit her, dass ich mich mit Processing beschäftigt habe, aber "früher" waren die entsprechenden Beispiele hier zu finden: Menü: Beispiele / Libraries / Serial I/O / SimpleRead

Fehlt dir nicht eine serialEvent function?

So würde zumindest etwas angezeigt. Basis ist dein Code, ein paar Syntaxfehler ausgebessert, SerialEvent ergänzt:

Arduino Code:

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

void loop() {
  int meinWert = analogRead(A0) / 4;
  Serial.write(meinWert);
  delay(10);
}

Processing Code:

import processing.serial.*;

Serial meinSeriellerPort;
int xPos = 1;
int serialValue;
int[] yPos;

void setup() {
  size(400, 300);
  println(Serial.list());
  meinSeriellerPort = new Serial(this, Serial.list()[1], 9600);   // nach deinen Gegebenheiten anpassen
  //  meinSeriellerPort.bufferUntil('\n');

  background(0);
  yPos = new int[width];
}

void draw() { 
  background(0);
  stroke(255, 255, 0, 120);
  for (int i=0; i < width; i+=50)
    line(i, 0, i, height);
  for (int i=0; i < height; i+=50)
    line(i, 0, i, width);

  stroke(255, 0, 0);
  strokeWeight(1);
  int yPosPrev = 0;
  int xPosPrev = 0;
  println(serialValue);

  for (int x = 1; x < width; x++)
    yPos[x-1] = yPos[x];

  yPos[width - 1] = serialValue;

  for (int x = 0; x < width; x++) {
    if (x >0)
      line(xPosPrev, yPosPrev, x, yPos[x]);
    xPosPrev = x;
    yPosPrev = yPos[x];
  }
}


void serialEvent(Serial meinSeriellerPort) {
  // read a byte from the serial port:
  serialValue = meinSeriellerPort.read();
}

Hi

Wenn wir schon im 'kommt nix an'-Code SYNTAX-FEHLER ausbügeln müssen, kann doch etwas dabei nicht stimmen.

@To
Wie viele Sekunden hast Du Dich um dieses Problem bemüht?
Dabei meine ich NICHT die Zeit, Die Du für diesen Post gebraucht hast - meine Schätzung geht gegen <10.

... ok, könnte sein, daß die Ferien vorbei sind und deshalb wieder schwerster Schulstress angesagt ist ...

MfG

Vielen Dank für eure Hilfen!
Ich habe eure Hinweise umgesetzt, das Problem besteht jedoch weiterhin. Selbst wenn ich den Code von Uxomm übernehme... Seltsam. Ich werde weitersuchen.

samhu:
Ich habe eure Hinweise umgesetzt, das Problem besteht jedoch weiterhin. Selbst wenn ich den Code von Uxomm übernehme...

Dann ist wohl was faul. :slight_smile:
Wenn ich die beiden Programme für Arduino und Processing von #4 (Antwort 4) verwende, an A0 des Arduino ein Potentiometer anschließe und daran lustig hin- und herdrehe dann sieht das bei mir so aus.
processing_ardu_a1.png
Also bei mir funktioniert das also definitiv, würde ich sagen.

Beachte: folgende Zeile wurde im Processing-Sketch "auskommentiert"

meinSeriellerPort.bufferUntil('\n');

Hast du das in deinem Sketch ebenfalls gemacht?

Versuche doch mal das Problem in Teilprobleme aufzuteilen - zum Beispiel so:
a) Anschluss eines Potentiometers an A0 des Arduino und erfolgreiches "Einlesen" der Werte.
b) Übertragen der Daten über die serielle Schnittstelle an den seriellen Monitor der Arduino-IDE (oder den "Seriellen Plotter" der Arduino-IDE).
c) Übertragen von seriellen Daten vom Arduino an Processing (noch ohne Potentiometer). Es geht zuerst mal nur darum, dass überhaupt etwas ankommt. Wählen der richtigen Schnittstelle etc.
d) Auswertung der empfangenen seriellen Daten mit Processing

Zu allen Teilproblemen gibt es Beispiele, sowohl bei Arduino als auch bei Processing.

Erst wenn alle "Teilprobleme" erfolgreich gelöst sind: eine komplexere Aufgabenstellung in Angriff nehmen (nämlich deine).

Wünsche gutes Gelingen.

Also Teilproblem a und b sind gelöst. Das funktioniert einwandfrei.

Zu c:
ich habe einen Sketch genommen mit dem ich ein Servo um 180 Grad hin und her schwenken lasse, also einen Wert generiere der mit einem delay von 0 bis 179 ansteigt und danach wieder abnimmt. Wenn ich den im Arduino Plotter ausgeben lasse sieht noch alles normal aus. In Processing wird zwar mittlerweile ein Wert dargestellt (die Linie erscheint), schwankt aber einfach um den Wert 10.

Wenn ich ein Potentiometer anschließe funktioniert im Plotter ebenfalls alles einwandfrei. Im Processing habe ich aber das gleiche Problem.
Es scheint also ein Signal anzukommen, allerdings nicht das richtige...
Der Port 0 muss auch der richtige sein, da nur einer erkannt wird und ich durch einen anderen Index eine Fehlermeldung bekomme.

Weiter kann ich es aber immer noch nicht eingrenzen. Hat noch jemand eine Idee woran es liegen könnte?

processing.png

Oh, und @uxomm: ja, die Zeile habe ich ebenfalls rausgenommen

Gib im Prozessing doch mal in Hex aus, was Du empfängst.

Gruß Tommy

Ich hoffe ich habe richtig verstanden was du meinst:

processing.serial.Serial@4ea784ae

Die Ausgabe ändert sich aber bei jedem Start

Z.B processing.serial.Serial@51b09d53

Nein. Nicht wo Serial steht, sondern das Zeichen, was Du empfängst.

Wenn Du im Code irgendwelche Änderungen machst, solltest Du wieder mal einen aktuellen Stand einstellen.

Gruß Tommy

Sorry, ich weiß nicht welches Zeichen du meinst. Meinst du den serialValue?

13
10
10
10
54
10
10
10
10
56
10
10
10
10
48

Ja und nun müsste man Vergleichsdaten haben, was der Arduino sendet.

Du kannst Dir ja auf dem Arduino einen festen Wert nehmen, z.B. 123, den der ständig sendet und dann mal schauen, was bei Prozessing ankommt.

Die aktuellen Codes könntest Du auch mal wieder einstellen.

Gruß Tommy

Vielen Dank, Tommy.
Zum Vergleich, der Arduino gibt auf und absteigende Werte aus, also:

0
1
2
3
...
177
178
179
178
177
...
usw.

Wenn ich einen konstanten Wert ausgeben lasse gibt der Arduino entsprechend diesen Wert dauerhaft zurück.

Processing hingegen gibt konstant den Wert 10 zurück, egal welchen ich im Arduino ausgeben lasse.

Arduino:

int wert = 130;

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

void loop() {
Serial.println(wert);
delay(100);
}

Processing:

import processing.serial.*;

Serial meinSeriellerPort;
int xPos = 1;
int serialValue;
int[] yPos;

void setup() {
  size(400, 300);
  println(Serial.list());
  meinSeriellerPort = new Serial(this, Serial.list()[0], 9600);   // nach deinen Gegebenheiten anpassen
  //  meinSeriellerPort.bufferUntil('\n');

  background(0);
  yPos = new int[width];
}

void draw() { 
  background(0);
  stroke(255, 255, 0, 120);
  for (int i=0; i < width; i+=50)
    line(i, 0, i, height);
  for (int i=0; i < height; i+=50)
    line(i, 0, i, width);

  stroke(255, 0, 0);
  strokeWeight(1);
  int yPosPrev = 0;
  int xPosPrev = 0;
  println(serialValue);


  for (int x = 1; x < width; x++)
    yPos[x-1] = yPos[x];

  yPos[width - 1] = serialValue;

  for (int x = 0; x < width; x++) {
    if (x >0)
      line(xPosPrev, yPosPrev, x, yPos[x]);
    xPosPrev = x;
    yPosPrev = yPos[x];
  }
}


void serialEvent(Serial meinSeriellerPort) {
  // read a byte from the serial port:
  serialValue = meinSeriellerPort.read();
}

Arduino:

int wert = 130
Serial.println(130); // Gibt 4 Zeichen aus '1', '3','0','\n'

Prozessing:

void serialEvent(Serial meinSeriellerPort) {
  // read a byte from the serial port:
  serialValue = meinSeriellerPort.read();  // liest ein einzelnes Byte/Zeichen ein
}

Du musst im Prozessing einlesen, bis Du '\n' erkennst und dabei die Zahl zusammen setzen.
Ich weiß jetzt nicht aus dem Kopf, ob es da was in Prozessing gibt. Das ist zu lange her.

Gruß Tommy

Wenn du im Arduino-Code folgendes verwendetst

Serial.println(wert);

ist es ja kein Wunder, wenn der Wert "um 10 herum schwankt".
Denn println gibt auch "Zeilenschaltung" mit aus. Das ist normalerweise 13 und 10.

Wenn du aber stattdessen folgendes verwendest:

Serial.write(wert);

dann werden keine Zeilenschaltungen mitgeliefert.

Das stand aber schon in #4 so...

Hi

Die 10 klingt nach LF (line feed), dem Zeilenende-Zeichen.
Die 13 klingt nach CR (carrige return), von Win werden Beide, von Linux nur EInes (und ich müsste jetzt suchen, Welches) benutzt.
Liest Du aktuell ALLES ein, solange was da ist und behältst nur das zuletzt eingelesene Zeichen?

MfG

PS: arg ... println ... erklärt natürlich die vielen 10/13er

Oh man, ich wusste es muss irgendwas blödes sein.
Ja ich habe es nach #4 auch geändert aber bei der ganzen rumprobiererei habe ich wohl irgendwann einen alten sketch geöffnet und das tatsächlich übersehen.
jetzt hab ichs aber.

ich danke euch!