*********************************************************

Arduino und Processing  pin-A0 & pinA1

 Sender:             Proces_Zwei_Analog_WERTe_1a.ino                1023,1023,
 Empfänger:       Processing_Zwei_Analog_WERTe_1a.pde  




Physical Computing

Arduino und Processing
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() Funktion.

Arduino → Processing  1023,1023

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

Code Arduino

Hier ein Beispiel, welches die Werte von zwei Analog-Sensoren über die serielle Schnittstelle zu Processing sendet.

/*Arduino-Sketch: Process_pin-A0 pin-A1_1a.ino*/#define FIRST_PIN 0 // Define the Analog Pins add more if needed#define SECOND_PIN 1int firstValue, secondValue; // Define Variables to store the analog Valuesvoid setup() {  Serial.begin(9600);        //Open the Serial Port with baudrate set to 9600}void loop() {  firstValue = analogRead(FIRST_PIN);   // Read the first PIN  secondValue = analogRead(SECOND_PIN); // Read the second PIN  Serial.print(firstValue);  // Send the first Value  Serial.print(',');         // Send a delimiter  Serial.print(secondValue); // Send second Value  Serial.print(',');         // Send a delimiter  Serial.println();          // Send a carriage-return}

Processing

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

So sieht die Ausgabe bei Processing typischerweise aus…

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:

/*Processing-Sketch: Processing_pin-A0 pin-A1_1a.ino*/import processing.serial.*; // Import the Processing Serial Library for communicating with arduinoSerial myPort; // The used Serial Portint firstValue, secondValue; // fourthValue, fifthValue, … // add more if neededvoid setup() {  size(300, 300);  println(Serial.list()); // Prints the list of serial available devices (Arduino should be on top of the list)  myPort = new Serial(this, Serial.list()[1], 9600); // Open a new port and connect with Arduino at 9600 baud}void draw() {}void serialEvent(Serial myPort) { // Is called everytime there is new data to read  if (myPort.available() > 0)  {    String completeString = myPort.readStringUntil(10); // Read the Serial port until there is a linefeed/carriage return    if (completeString != null)  { // If there is valid data insode the String         trim(completeString); // Remove whitespace characters at the beginning and end of the string      String seperateValues[] = split(completeString, ","); // Split the string everytime a delimiter is received      firstValue = int(seperateValues[0]);      secondValue = int(seperateValues[1]);      print(firstValue);      print("  -  ");      println(secondValue);    }  }}

http://cmuems.com/2012/c/arduino-processing/

Processing → Arduino

Arduino
Um auf der Seite des Arduino auf eingehende Nachrichten über die serielle Schnittstelle zu horchen müssen wir einige Funktionen benutzen.
Diese sind:

strtok()
char *single = strtok ( char * str, const char * delimiters );
Diese Funktion splittet fine Sequenz von Bytes (*str) in einzelne Strings (*str). Dazu nutzt sie die vorhandenen Delimiter (*delimiters)

http://www.cplusplus.com/reference/clibrary/cstring/strtok/

atoi()
int value = atoi( const char * str );
Konvertiert einen String (*str) in ein Integer-Wert (value)

http://www.cplusplus.com/reference/clibrary/cstdlib/atoi/

memset()
void * memset ( void * ptr, int value, size_t num );
Setzt die Bytes an einer speziellen Stelle (size_t num) in einem Array (*ptr) aug einen festgelegten Wert (value).

http://www.cplusplus.com/reference/clibrary/cstring/memset/

Code Arduino

/*Arduino-Sketch: Process_first,second,thirth_1a.ino */#define BUFFER_SIZE 20 // actual size of the buffer for integer values: (numberOfValsToRead*6)+(numberOfValsToRead-1)char incommingBuffer[BUFFER_SIZE]; // buffer to store incomming valueschar incomming; // primary buffer to store single incommning bytesint incommingCounter = 0; // counter for counting the positions inside the bufferint firstValue, secondValue, thirdValue; // fourthValue, fifthValue, … // add more if neededvoid setup() {  Serial.begin(9600);}void readSerial() {  while(Serial.available()) {    incomming = Serial.read(); // read single incommning bytes    if(incomming != '\r') { //if no carriage return is received proceed in reading the serial port         incommingBuffer[incommingCounter++] = incomming; // go on the next position in the buffer    }    else  { //read until a carriage ('\r') is received      incommingBuffer[incommingCounter] = '\0'; // set the last byte to NULL to sign it for the string operators      char *a = strtok(incommingBuffer, ",.;");           // split the string after delimiters into tokens      char *b = strtok(NULL, ",.;"); // …      char *c = strtok(NULL, ",.;"); // …                                     //char *d = strtok(NULL, ",.;"); // add another line if needed      firstValue = atoi(a);          // convert the strings into integers      secondValue = atoi(b);         // …      thirdValue = atoi(c);          // …      //fourthValue = atoi(d);       // add another line if needed      incommingCounter = 0;          // reset the counter      memset(incommingBuffer, 0, BUFFER_SIZE); //overwrite the incommingBuffer    }  }}void loop() {  readSerial();                      // read the values available at the serial port  Serial.print(firstValue);          // debugging  Serial.print("\t");  Serial.print(secondValue);  Serial.print("\t");  Serial.print(thirdValue);  Serial.print("\t");  //Serial.print(fourthValue);        // add these lines if needed  Serial.println();                   // send a carriage return for debugging}

Processing
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.

Code Processing

/*Processing-Sketch: Processing_first,second,thirth_1a.ino*/import processing.serial.*; // Import the Processing Serial Library for communicating with arduinoSerial myPort; // The used Serial Portvoid setup()  {  background(0);  size(500, 500);  println(Serial.list()); // Prints the list of serial available devices (Arduino should be on top of the list)  myPort = new Serial(this, Serial.list()[1], 9600); // Open a new port and connect with Arduino at 9600 baud}void draw()  {  int firstValue = 111;  int secondValue = 222;  int thirdValue = 333;  myPort.write(str(firstValue));  myPort.write(",");  myPort.write(str(secondValue));  myPort.write(",");  myPort.write(str(thirdValue));  myPort.write(",");  myPort.write("\r");  delay(1000);}

Weitere Informationen

Serial() auf arduino.cc
Serial() auf processing.org

http://blogs.iad.zhdk.ch/physical-computing-hs-12/08-arduino-und-processing/





*********************************************************
Processing - eine Einführung in die Programmierung
Version 1.1                  Andres Wanner                BUCH vorhanden

Von www.schaltungen.at downlodbar

300_d_Wanner-x_Processing - eine Einführung in die Programmierung (88 Seiten)_1a.pdf

Bilder speichern
save()
Mit einem einzigen Befehl kann die Zeichenfläche als Bilddatei gespeichert werden.
Als Endungen sind .jpg, .png, .tif und .tga möglich.
Das Bild wird automatisch in den Projekt-Ordner gespeichert.
save("screenshot.jpg");
saveFrame()
Um gleich jedes einzelne Frame separat zu speichern kann saveFrame verwendet werden.
Wird im Dateinamen #### angegeben, wird an dieser Stelle die Framenummer eingefügt.
In einem Videoprogramm können die Frames später auch wieder zu einer Animation zusammengefügt werden.
 saveFrame("bild_####.jpg");
Das konstante Speichern der Bilder benötigt Zeit und verlangsamt die Abspielgeschwindigkeit stark.
Die gespeicherten Bilder dieses Beispiels heissen:
bild_0001.jpg
bild_0002.jpg
bild_0003.jpg
usw..



*********************************************************
Andres Wanner, Processing, Serielle Kommunikation mit Arduino

Processing MENU > Files > Examples > Libraries > Arduino (Firmata) >

arduino_input

arduino_output

arduino_pwm

arduino_servo

Grundlagen der Entwicklungsumgebung
Die Arduino Entwicklungsumgebung besteht aus nur einem Fenster und ist fast identisch mit der von Processing.
Es gibt nur zwei neue Schaltflächen:
    - „Upload“ um Code auf das Arduino-Board zu transferieren.
    - „Serial Monitor“ um den Datenaustausch zwischen Computer und Arduino-Board anzuzeigen.

Vorsicht!
Es ist immer nur eine serielle Verbindung möglich.
Ist der „Serial Monitor“ geöffnet, kann Processing nicht gleichzeitig mit dem Arduino-Board kommunizieren.
Die einfachste Art mit Processing das Arduino-Board anzusprechen ist die Arduino Library, welche in Processing standardmässig enthalten ist.
Um sie zu nutzen wird auf Arduino die Firmata Firmware geladen, welche den Datenaustausch mit der Library übernimmt und die ganzen Events seitens Arduino überwacht.
Einmal aufgespielt, braucht man sich nicht weiter um den Arduino-Code zu sorgen.
Zum besseren Verständnis führen wir weiter unten auch noch Beispiele für die Kommunikation direkt über die Serial Library an.
In dieser Variante müssen sowohl der Code für Processing als auch derjenige für Arduino aufeinander angepasst werden.
Dadurch wird leichter nachvollziehbar, was genau geschieht.
Hier aber zunächst die einfachere aber weniger transparente Variante mit Firmata. Referenz zur Firmata Library findest Du unter:
http://www.arduino.cc/en/Reference/Firmata




*********************************************************

Beispiel 1: Arduino Input
Einlesen von digitalen und analogen Werten aus Arduino

1. In Arduino die StandardFirmata Firmware aufspielen
Im Arduino-Programm MENU > Datei > Beispiele > Firmata > StandardFirmata öffnen,  ACHTUNG: 57600 Baud
 „Upload“ klicken und (bei älteren Modellen) gleichzeitig den reset-Knopf drücken.
StandardFirmata ist zu gross für ältere Arduino-Modelle.
2. Schaltung aufbauen
Weiter unten folgen je ein Beispiel für eine analoge und eine digitale Schaltung, Abschnitte „Analoge
Schaltung mit Potentiometer“ und „Digitale Schaltung (ein-aus Kontakt)“.
3. Processing Sketch laden
Den Processing-Sketch „processing_firmata_beispiel1_arduinoinput_1a.pde” in Processing starten:
Die Eingabewerte von Arduino werden in Processing sichtbar.
Achtung:
Pins, welche nicht mit GND oder +5V verbunden sind, liefern ständig willkürliche Werte!

Digital Eingänge pin-13 bis pin-0

                     Analog-Eingänge pin-A5 bis pin-A0

Beispielcode
processing_firmata_beispiel1_arduinoinput_1a.pde
//im Sketch werden 13 Quadrate und 6 Kreise gezeichnet.
//wenn ein digitaler pin kontakt hat, wird das entsprechende quadrat angezeigt
//wenn ein analoger pin ein signal hat, wird der entsprechende kreis abhängig vom signal skaliert
// ACHTUNG: pins, welche nicht auf GND gehen, liefern ständig irgendwelche werte oder sie flackern.

SENDER:              Arduino MENU > Datei > Beispiele > Firmata > StandardFirmata
EMPFÄNGER:      Processing-Code: processing_firmata_beispiel1_arduinoinput_1a.pde


Das Kernstück dieses Skripts besteht aus folgendem Code.
Mit dem Befehl arduino.pinMode(i, Arduino.INPUT); werden die Pins als Eingänge definiert.
Der Wert, den Arduino sendet, wird mit arduino.digitalRead(i) für HIGH und LOW und arduino.analogRead(i) für analoge Werte ausgelesen und kann in Processing wie eine normale Variable verwendet werden.
Die Variable i steht hier für die physische pin-Nummer auf dem ARDUINO UNO R3.






Beispiel 2: Arduino Output
Werte von Processing über Arduino ausgeben
1. In Arduino die StandardFirmata Firmware aufspielen
Im Arduino-Programm MENU/File/Examples/Firmata/StandardFirmata öffnen, „Upload“ klicken und (bei älteren Modellen) gleichzeitig den reset-Knopf drücken. (StandardFirmata ist zu gross für ältere Arduino-Modelle.
Deshalb liefern wir – ohne Gewähr – eine abgespeckte Version StandardFirmata_s mit.)
2. Schaltung aufbauen
Für das Überprüfen von HIGH / LOW Werten an Arduino-Pins kann eine LED mit einem geeigneten Vorwiderstand zwischen den entsprechenden Pin und GND geschalten werden (ausser Pin 13, da ist ein Vorwiderstand integriert).
3. Processing Sketch laden
Den Sketch „processing_firmata_beispiel2_arduinooutput_1a.pde“ in Processing starten:
Beim Klicken auf ein Quadrat in Processing leuchtet die LED am entsprechenden Pin auf.


Digital Ausgänge pin-13 bis pin-0

Auf dem Arduino-Board vorhandene LED pin-13 leuchtet

SENDER:              Arduino MENU > Datei > Beispiele > Firmata > StandardFirmata
EMPFÄNGER:      Processing-Code: processing_firmata_beispiel2_arduinoinput_1a.pde


import processing.serial.*;                                            // serial library laden
import cc.arduino.*;                                                      // arduino library laden
Arduino arduino;                                                           // arduino-objekt deklarieren
arduino = new Arduino(this, Arduino.list()[1], 57600);     // arduino-objekt initialisieren (57600 Baud notwendig)


Wie beim Beispiel 1 ist auch hier der für die Kommunikation wichtige Teil des Skripts durch die Definition der Pins als Ausgang mit arduino.pinMode(i, Arduino.OUTPUT); und dem senden eines Wertes an einen Pin mit arduino.digitalWrite(pin, Arduino.HIGH); gekennzeichnet.
Die Variablen i bzw. pin definieren wieder die physischen Pins auf Arduino.





Beispiel 3: Arduino PWM
Pulsbreitenmodulation (pulsewidth modulation) beispielsweise zum Dimmen einer LED
1. In Arduino die StandardFirmata Firmware aufspielen
Wenn nicht schon aufgespielt, im Arduino-Programm File/Examples/Firmata/StandardFirmata öffnen, „Upload“ klicken und (bei älteren Modellen) gleichzeitig den reset-Knopf drücken. (StandardFirmata ist zu gross für ältere Arduino-Modelle. Deshalb liefern wir – ohne Gewähr – eine abgespeckte Version StandardFirmata_s mit.)
2. Schaltung aufbauen
Wie bei Beispiel 2 wird bei dieser Schaltung nur eine LED mit passendem Vorwiderstand benötigt. Diese wird
mit Ground und einem PWM – Pin (in diesem Code Pin 11) verbunden.
3. Processing Sketch laden
Den Sketch „processing_firmata_beispiel3_arduinopwm.pde“ in Processing starten:
Beim Bewegen der Maus über den Sketch verändert sich dessen Helligkeit (links Schwarz, rechts Weiss), und gleichzeitig wird die LED am Arduino gedimmt.



SENDER:              Arduino MENU > Datei > Beispiele > Firmata > StandardFirmata
EMPFÄNGER:      Processing-Code: processing_firmata_beispiel3_arduinoPWM_1a.pde

Die Helligkeit der LED an pin-11 (PWM) kann mit der Mouse vo 0 bis 255 geregelt werden

/*Processing-Code: processing_firmata_beispiel3_arduinoPWM_1a.pde processing errechnet aus der mausposition einen pwm wert und sendet ihn an den pin-11 (pwm pin) von arduino */import processing.serial.*;   // serial library ladenimport cc.arduino.*;          // arduino library ladenArduino arduino;              // arduino-objekt deklarierenint pwm;                      // unsere PWM variablevoid setup() {  size(512, 100);  arduino = new Arduino(this, Arduino.list()[1], 57600); // arduino-objekt initialisieren}void draw() {  pwm = constrain(mouseX / 2, 0, 255);    // PWM WERT mit mausposition berechnen  background(pwm);                        // hintergrund setzen  arduino.analogWrite(11, pwm);           // PWM wert an pin 11 von arduino senden}

Die Variable pwm wird in diesem Beispiel auf einen Wert zwischen 0 und 255 skaliert.
Mit dem Befehl arduino.analogWrite(11, pwm); wird dem Arduino mitgeteilt, dass nicht ein HIGH oder LOW wert folgt, sondern ein analoger Wert.
Die Firmata Firmware interpretiert diesen Wert automatisch als PWM-Wert und dimmt den entsprechenden Pin.

Instruction-Set der Arduino Library
Klasse
Arduino
Die Klasse für die Kommunikation mit Arduino
arduino = new Arduino(this, name, baudrate);
// name: der Name des Devices wie er von Arduino.list() geliefert wird
// baudrate: Verbindungsgeschwindigkeit

Methoden
list()
Gibt eine Liste der verfügbaren seriellen Devices zurück. Wenn ein Arduino angeschlossen ist,
wird es in dieser Liste erscheinen.
pinMode(pin, mode)
Einen digitalen Pin als Eingang oder Ausgang definieren
// pin: Pinnummer
// mode: Arduino.input oder Arduino.output

digitalRead(pin)
digitalWrite(pin, value)
Digitale Werte lesen und schreiben
// pin: Pinnummer
// value: zu sendender Wert
analogRead(pin)
Analogen Wert einlesen (von 0 bis 1023)
analogWrite(pin, value)
Analogen Wert (PWM Signal von 0 bis 255) an einen der PWM Pins senden




Analoge Schaltung mit Potentiometer
Stückliste:
1 Arduino-Board
div. Kabel
1 Potentiometer
Schaltung aufbauen
Für eine Analoge Eingabe wie etwa das Auslesen eines Sensors oder Potentiometers (Drehwiderstand) ist folgende Schaltung aufzubauen:
Potentiometer (Drehwiderstände) haben 3 Beine.
Das mittlere Bein wird mit einem "ANALOG IN" Eingang am Arduino verbunden, in diesem Beispiel mit
"Analog In 0" (muss bei der Arbeit mit der Serial Library mit Arduino-Code übereinstimmen).
Eines der beiden äusseren Beine wird mit +5V (Spannungsversorgung) verbunden
Das andere Bein mit GND (Erdung)
Viele Sensoren funktionieren nach dem Schema des Potentiometers:
Es gibt drei Kontakte: die äusseren beiden sind mit der Erdung (GND, schwarz), und mit dem Pluspol (+5V, rot) verbunden.
Der mittlere Kontakt liefert den Sensorwert, also eine Spannung zwischen 0 und 5V.
Wird er mit einem analogen Input von Arduino verbunden, liefert uns dieser Pin Werte zwischen 0 und 1023.
Durch 4 geteilt ergibt dies ein Wert zwischen 0 und 255, was für die serielle Übermittlung geeigneter ist.



Digitale Schaltung (EIN/AUS Kontakt)
Stückliste:
1 Arduino-Board
1 Widerstand, z.B. 300 Ohm
div. Kabel
1 Taster
Schaltung aufbauen
Ein Ein-Aus Schalter wird parallel zu einem Widerstand geschaltet.
Schalter offen -> Verbindung zwischen inPin 2 und GND -> inPin2 = 0V
Am Eingang wird "O" gelesen.
Schalter geschlossen -> (Kurzschluss)-Verbindung zwischen Power (5V) und inPin 2 -> inPin2 = 5V
Am Eingang wird "I" gelesen.



Kommunikation über die Serial Library
Folgende Beispiele sollen die Kommunikation mit Arduino über die Serial Library illustrieren.
Dabei gehören je ein Codeblock für Processing und einer für Arduino zusammen, welche miteinander kommunizieren.



Beispiel 1: Arduino erhält Werte von Processing
Wenn in Processing die Maus gedrückt wird, leuchtet die LED am Pin 13 auf, wenn die Maus bewegt wird,
blinkt die Maus entsprechend dem mouseX Wert schneller oder langsamer.


SENDER:             Processing_1_proc_arduino_receives_1a.pde
EMPFÄNGER:     Proces_1_arduino_receives_1a.ino



Die Daten werden über myPort.write(); an Arduino gesendet.
Der folgende Arduino-Code nimmt die Werte mit Serial.read(); an und reagiert je nachdem ein H, ein L oder eine Zahl kommt.
Mit dem Befehl digitalWrite(ledPin, HIGH); wird die eingebaite LED am pin-13 geschalten.

X-Mouseposition 0..255 verändert die Füllfarbe von weiß auf schwarz

Mausklick schaltet LED an pin-13

*********************************************************

Beispiel 2: Arduino sendet Werte an Processing

Taster Digital-Eingang pin2 erstellt rotes Quadrat   0  1

Potentiometer Analog-Eingang pin-A0  verändert Füllfarbe von schwarz auf weiß  255


Der folgende Arduino Code zeigt das Auslesen der Pins mit
digitalRead(pin); und
analogRead(pin); und das Senden der Werte mit
Serial.write(wert);

/*Arduino-Sketch: Proces_2_arduino_sends_1a.inoTaster verbunden mit Pin 2 und +5V, 10k Widerstand zwischen pin-2 und GND*/                       // digitalint switchPin = 2;     // Taster an Digital-Eingang pin-2  (RxT pin-0 und TxT pin-1 müssen frei bleiben)                       // analogint analogInPin = 0;   // Analog-Eingang pin-A0 an dem der Poti angeschlossen istint sensorValue = 0;   // vom Potentiometer erhaltener Wertint outputValue = 0;   // von 1023 auf 255 umgerechneter analoger Ausgabewertvoid setup() {  pinMode(switchPin, INPUT); // LED Pin als Eingang initialisieren  Serial.begin(9600);        // Serielle Kommunikation starten mit 9600 bps  }void loop() {                             // digital lesen und senden  if (digitalRead(switchPin) == HIGH) {    // Wenn der Taster gedrückt ist    Serial.write(1);           // sende 1 an Processing  }  else {    Serial.write(0);           // andernfalls sende 0 an Processing  }                               // analog lesen und senden  sensorValue = analogRead(analogInPin);           // analogen Wert lesen  outputValue = map(sensorValue, 0, 1023, 0, 255); // 255); auf Ausgabebereich umrechnen  Serial.write(outputValue);                       // seriell ausgeben  delay(100); // 100 Millisekunden warten bevor der nächste Wert geschrieben wird}

SENDER:             Proces_2_arduino_sends_1a.ino    
EMPFÄNGER:     Processing_2_proc_arduino_sends_1a.pde

/*Prozessing-Sketch: Processing_2_proc_arduino_sends_1a.pde*/import processing.serial.*;   // serial library ladenSerial myPort;                // objekt der serial-klasse deklarierenint val;                      // variable für erhaltene daten vom serial portvoid setup() {  size(400, 250);  println(Serial.list());  String portName = Serial.list()[1];  myPort = new Serial(this, portName, 9600); // serial-Objekt initialisieren}void draw() {  background(255);                  // Hintergrund weiss setzen  if ( myPort.available() > 0) {    // wenn serielle Daten vorhanden    val = myPort.read();            // lesen und in val speichern    println(val);  }  if (val == 0) {           // wenn serieller Wert 0 ist,    noStroke();             // linie ausblenden  } 
    else if (val == 1) {    // wenn serieller Wert 1 ist,    stroke(255, 0, 0);      // rote Linie    strokeWeight(15);  } 
    else {                  // wenn serieller Wert weder 1 noch 0 ist,    fill(val);              // Quadrat mit analogwert füllen  }  rect(70, 70, 115, 115);   // schwarzes Qudrat zeichnen}

Werte aus Arduino werden eingelesen und in Processing dargestellt.
Es wird ein schwarzes Quadrat gezeichnet, die Helligkeit der Füllfarbe entspricht dabei dem WERT, welcher am Analog-Eingang pin-A0 gelesen wird (Potentiometer),
und die rote Umrandung des Quadrats wird nur gezeichnet, wenn der Taster am Digital-eingang pin-2 gedrückt wird.

Der Befehl myPort.read(); liest die von Arduino gesendeten Werte und interpretiert diese.


Instruction-Set von Processing.serial
Klasse
Serial myPort;
Die Klasse für Serielle Kommunikation
myPort = new Serial(this, portname, baudrate);
portname: der Portname, [0]=der PC   [1]=der Arduino
baudrate: Verbindungsgeschwindigkeit, muss mit Arduino übereinstimmen
Methoden
available() zur Prüfung, ob das serielle Gerät verfügbar ist, und ob ein Datenwert geschickt wurde
Schreiben und Lesen
read()
write()
Event
serialEvent()
dieser Event-Handler wird aufgerufen, wenn etwas auf dem Seriellen Port passiert ist, z.B. wenn Arduino eine Meldung geschickt hat.




*********************************************************

BUCH:

Daniel Shiffman,
Learning Processing: A Beginner's Guide to Programming Images, Animation, and Interaction,
Morgan Kaufmann,
2008,
ISBN: 0-1237-3602-1

*********************************************************



Einführung ins Programmieren mit Processing
Matthias Wolf.
Published August 2013. 178 pages. PDF, Paperback.
Die eigenständige Programmiersprache Processing basiert auf Java und ähnelt diesem sehr, verbirgt aber gleichzeitig viel von dessen Komplexität.
Dadurch ist Processing für den Programmieranfänger ideal geeignet, um sich Konzepte des Programmierens zu erschließen
und bewahrt gleichzeitig die Möglichkeit eines späteren Umstiegs.

Dennoch ist die Sprache keineswegs nur für triviale Anfängeraufgaben geeignet:
speziell im Bereich der graphischen Datenverarbeitung spielt Processing seine Stärken aus.

Dieses Buch richtet sich in erster Linie an den Einsteiger, den es an die Bewältigung auch komplexerer Aufgaben heranführt, wobei grundlegende Konzepte der imperativen und der objektorientierten Programmierung vorgestellt werden.

Auch notwendige theoretische Hintergründe kommen dabei nicht zu kurz.
Ausführlich kommentierter Beispielcode erschließt Konzepte und Sprache.

Aber auch der routinierte Programmierer, der sich "nur" eine neue Sprache erschließen will, wird fündig!

Aus dem Inhalt:
Datentypen — Variablen — Arrays (ein- und mehrdiomensional) — Flusssteuerung — Methoden — Objektorientiertes Programmieren — 2D-Graphik — 3D-Graphik — Dateizugriff — PDF — QuickTimeTM — Arduino®-Mikrocontroller — Alphabetischer Index

Die Programmiersprache Processing basiert auf Java und ähnelt diesem sehr, verbirgt aber gleichzeitig viel von dessen Komplexität.
Dennoch ist die Sprache keineswegs nur für triviale Aufgaben geeignet:
speziell im Bereich der graphischen Datenverarbeitung spielt Processing seine Stärken aus.

Dieses Buch richtet sich in erster Linie an den Anfänger, den es an die Bewältigung komplexerer Aufgaben heranführt, wobei Konzepte der imperativen und der objektorientierten Programmierung vorgestellt werden.

Auch theoretische Hintergründe kommen dabei nicht zu kurz.

Aus dem Inhalt:
Datentypen — Variablen — Arrays — Flusssteuerung — Methoden — Objektorientiertes Programmieren — Textausgabe — 2D-Graphik — 3D-Graphik — Dateizugriff — PDF — QuickTime™ — Arduino® Mikrocontroller — Index

http://www.computerfueralle.ch/programmieren/cfa_kurs/cfa_000_start.html

DIN A4 ausdrucken
*********************************************************
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:[email protected]
ENDE







a