Page Comparison

Da Arduino auf Processing basiert eignen sich die beiden auch perfekt dazu Daten untereinander auszutauschen. Auf der Arduino-Seite nutzt man dazu die Funktion Serial.print() um Daten an Processing zu schicken und Serial.read() um Daten von Processing zu empfangen. Auf Processing-Seite nutzt man die Serial library welche schon in Processing integriert ist. Um Daten vom Arduino in Processing zu empfangen nutzt man ebenfalls die read() Funktion und um Daten an das Arduino zu schicken die write() FunktionDazu verwenden wir die serielle Schnittstelle "Serial" die das asynchrone Austauschen von Daten ermöglicht.

Arduino zu Processing

Auf der Arduino Seite ist das Prinzip relativ simpel. Man aktiviert die serielle Kommunikation und setzt eine Baudrate im setup (bits/second) fest (z.B. Serial.begin(9600)). Dann schickt in der "setup" Funktion fest. Dann schreibt man einfach die betreffenden Werte/Variablen über Serial.print(VARIABLE)auf die serielle Schnitstelle. Man muss lediglich darauf achten, einen Delimiter ein Trennzeichen (zbspl. Komma) zwischen den Werten und nach allen Werten einen carriage-return (Serial.println() od. Serial.print(‘r’)) zu schicken – das ein new-line Zeichen "\n" zu schicken. Dies macht die Unterscheidung in Processing nachher umso einfacher. Als Delimiter eignen sich Sonderzeichen wie “,;.:“.

Hier ein Beispiel, welches die Werte von zwei Sensoren über die serielle Schnittstelle sendet sendet:

void setup()
{
  // open the serial port with a baudrate of 9600
  Serial.begin(9600);
//Open}
the Serial
Portvoid withloop()
baudrate{
set to 9600// }reading of pins
void loop()
{
  int firstValue = analogRead(FIRST_PINA0);
// Read the first PIN
  int secondValue = analogRead(SECOND_PINA1);
  
  // Readwriting theof seconda PINsingle line to serial "100,200"
  Serial.print(firstValue);
// Send the first Value
  Serial.print(',');
// Send a delimiter
  Serial.print(secondValue); // Send second Value
  Serial.printprintln(','); // Send<- afinish delimiter
  Serial.println(); // Send a carriage-returnof line
}

Auf Processing-Seite müssen wir zunächst die Serial Library implementieren. Dies geschieht über:

import processing.serial.*; // Import Library
Serial myPort; // Den Port instanzieren

Im setup() lassen wir uns dann eine Liste mit allen verfügbaren seriellen Schnittstellen ausgeben und wählen den entsprechenden Eintrag in dieser Liste als Port für die Verbindung mit dem Arduino (es ist meist der erste Eintrag) und setzen die Baudrate auf den gleichen Wert wie im Arduino (in unserem Fall 9600).

println(Serial.list());
myPort = new Serial(this, "/dev/cu.usbmodem12131", 9600);

So sieht die Ausgabe bei Processing typischerweise aus…

Image Removed

Das Arduino ist der Eintrag “/dev/tty/.usbmodemfa131″

Um die Daten von Arduino auszulesen gibt es im Processing eine Funktion, welche aufgerufen wird, sobald Daten an der Serielle Schnittstelle anliegen:

void serialEvent(Serial myPort)
{
  // Hier werden die Daten der seriellen Schnittstelle gelesen
}

Innerhalb dieser Funktion filtern wir unsere Daten und suchen nach den Delimitern, welche wir in Arduino festgelegt haben. Damit können wir die einzelnen Variablen wieder “auseinanderpflücken” und im Processing verwenden.

Auf Processing Seite liesst folgender Code die Werte, welche wir von den zwei Sensoren über das Arduino senden …importieren, und die serielle Schnittstelle in der "setup" Funktion öffnen. Danach könne wir in der callback Funktion jeweils eine Zeile lesen, und die einzelnen Wert wieder rauslesen.

Hier ein Beispiel dass die beiden Werte ausliest und eine Ellipse zeichnet.

import processing.serial.*;  // Import
the Processing Serial Library for communicating with arduino
Serial myPort;

             // The used Serial Port

int firstValue, secondValue; // fourthValue, fifthValue,
...
// add more if needed

void setup()
{
  size(500, 500);

 println(Serial.list()); // Printsprint theall listavailable ofports
serial available devices (Arduino should be on top of the list) println(Serial.list());

  // open specific serial port
  myPort = new Serial(this, "/dev/cu.usbmodem12131", 9600);
//}
Open
avoid newdraw()
port{
and connect with// Arduinodraw atellipse
9600 baud }background(0);
 void drawfill(255)
{;
  ellipse(width/2, height/2, firstValue, secondValue);
}

void serialEvent(Serial myPort)
// Is{
called everytime there// ischeck newif data tois readavailable
{
  if (myPort.available() >== 0)
  {
    return;
  String}
completeString
= myPort.readStringUntil('\n'); // Readread thea Serialline portas untila therestring
is a linefeed/carriageString returnstr = myPort.readStringUntil('\n');
  if (completeStringstr !== null)
  //{ If
there is valid data insodereturn;
the String }

  {// remove leading and trailing whitespace
  completeStringstr = trim(completeStringstr);
//
Remove whitespace characters at the beginning and end of the string
   // split string
  String seperateValuesvals[] = split(completeStringstr, ",");
// Split the string everytime a delimiter is receivedif (vals.length != 2) {
    return;
  }
if
(seperateValues.length == 2)// {convert    values
    firstValue = int(seperateValuesvals[0]);
     
  secondValue = int(seperateValuesvals[1]);
      }
    }
  }println(firstValue, secondValue);
}

Processing zu Arduino

Auf der Seite von Processing können wir einfach die Funktion *.write() aus der Serial Library nutzen. Es ist lediglich darauf zu achten, dass Werte als Strings an das Arduino gesendet werden. Mit der Funktion str(value) lässt sich jeder Wert (value) in einen String umwandeln. Zusätzlich senden wir zwischen jedem einzelnen Wert ein ‘,’ als Delimiter und ein carriage-return (“t”) als Indikator für das Ende der Übertragung.

...