Processing-Tutorial 
Einstieg in die Programmierung mit Processing
http://lernprocessing.wordpress.com/



Processing-PDE

2.1.1

Januar 2014

Bugfix-Release

ist das Gegenstück zur Arduino-IDE für den PC.

https://processing.org/books/
http://de.wikipedia.org/wiki/Processing

Oft wird sogar auch die Programmiersprache für den Arduino fälschlicherweise  als Processing bezeichnet.
Die nahe Verwandschaft der beiden Programme ist aber offensichtlich.
Auch die Steuer-Icons haben die gleichen Bedeutungen wie beim Arduino, natürlich mit dem Unterschied,
dass mit dem run-Symbol (>) das aktuelle Programm nicht zum Arduino gesendet, sondern direkt vom PC ausgeführt wird.
Das Programm kann kostenlos unter
http://processing.org/

herunter geladen werden.
Wie bei der Arduino-Version, werden viele interessante Beispielprogramme mitgeliefert.
Allein das Austesten dieser Beispiele, ist schon eine umfangreiche aber hochinteressante und sehr lehrreiche Aufgabe.
So enthält ein Processing-Sketch ebenfalls die beiden Funktionsblöcke void setup() und void draw() anstelle von void loop().
Mit den entsprechenden Bibliotheken (libraries) werden Arduino und Processing zu einem unschlagbaren Duo.

Hinweis:
Processing-Programme für den PC haben das Suffix „*.pde".
Dieses wird auch bei den Arduino-Sketchen in allen Versionen vor Arduino 1.0 ( < 0022) verwendet.
Hier kann es also leicht zu Verwechslungen kommen.
Die Situation wird dadurch entschärft, dass ab IDE-Version 1.0 die Endung „*.ino" für Arduino-Sketche verwendet wird.

ARDUINO (Sender) seriell zu Processing (Empfänger)

SENDER:          Meßwertaufnahme und Daten versenden über die serielle Schnittstelle ("Serial-Monitor" COM6  9600 baud).

EMPFÄNGER:   Empfangene Meßwerte grafisch darstellen

P  Windows 64-bit     processing-2.2.1-windows64.zip

ACHTUNG:
COM6-PORT nur für "Serial-Monitor"  ODER nur für Grafikausgabe im Processing Grafikfenster verwenden ! ! !

http://processing.org/

C:\2015 prozessing\

Installation
1)  ZIP-Datei (processing-2.2.1-windows64.zip ) entpacken. Eine Installation ist nicht erforderlich.

2) prozessing.exe STARTEN

3) Firmata-Library für Prozessing  installieren

http://playground.arduino.cc/Interfacing/Processing

Firmata_v2.3.6.zip
http://firmata.org/wiki/Download

Arduino-IDE and Processing-IDE

Processing ist eine Open-Source-Sprache / Entwicklungswerkzeug für das Schreiben von Programmen in anderen Computern.
Nützlich, wenn Sie die anderen Computer zu "sprechen" mit einem Arduino, zum Beispiel zum Anzeigen oder speichern Sie einige Daten von der Arduino gesammelt werden soll.

Simple Examples

Arduino kommt mit einigen grundlegende Beispiele für die Kommunikation mit Processing (in den Beispielen> Kommunikation).
Diese sind nützlich, wenn Sie sowohl Arduino und Verarbeitungsprogramme schreiben wollen und haben sie miteinander reden.
Dies funktioniert am besten für die Kommunikation einfache Informationen.
Wenn Sie wollen einfach nur ein Arduino-Board aus einem Verarbeitungsprogramm zu steuern, können Sie die Arduino Bibliothek für die Verarbeitung im Folgenden beschrieben.

Arduino Library for Processing (and Firmata)

Diese Bibliothek (library) ermöglicht es Ihnen, ein Arduino-Board von Verarbeitung, ohne Code schreiben für den Arduino steuern.
Stattdessen können Sie eine Standard-Firmware (Programm) auch direkt hochladen und kommunizieren mit ihm die Benutzung der Bibliothek.
Die Firmware aufgerufen Firmata, und ist in der Arduino Software enthalten.
Die entsprechenden Verarbeitungsbibliothek kann unten heruntergeladen werden.

Download

Bibliothek (Library) für die Verarbeitung v2.0: processing2-arduino.zip (Stand 6. November 2013)
(Properties-Datei hier: Processing2-arduino.txt)

Instructions

1. Entpacken Sie die Bibliothek (processing2-arduino.zip) und kopieren Sie die entpackten Arduino-Ordner in den Bibliotheken-Unterordner Ihrer Verarbeitung Sketch Verzeichnis.
(Sie können den Speicherort Ihrer Sketch durch Öffnen der Bearbeitungseinstellungen zu finden.
Wenn Sie noch keine Bibliotheken-Unterordner erstellt haben, erstellen Sie einen)
2. Arduino starten, öffnen Sie die Beispiele > Firmata > examples > StandardFirmata > StandardFirmara.ino, und laden Sie sie auf das Arduino-Board.
C:\  ..  arduino-1.0.5-r2-windows\Firmata\examples\StandardFirmata\StandardFirmara.ino
3. Konfigurieren Verarbeitung für Serien: http://processing.org/reference/libraries/serial/
4. In der Verarbeitung, öffnen eines der Beispiele, die mit mit dem Arduino Bibliothek kommt.
5. Bearbeiten Sie das Beispiel-Code, um die serielle Schnittstelle von Arduino verwendet auszuwählen. Insbesondere, ändern Sie die [0] in diese Zeile auf [1] 

meinArduino = new Arduino(this, Arduino.list()[1], 9600); //  [0]=COM1 [1]=COM6
meinSeriellerPort = new Serial(this, Serial.list()[1], 9600);

Um das richtige Element im Array zu finden, führen Sie diesen Code in Bearbeitung:

import processing.serial.*; // Verweis auf die serielle Bibliothek
import cc.arduino.*;  // Verweis auf die Arduino Bibliothek
Arduino arduino;     //erstellen Sie eine Variable arduino des Arduino-Datentypprintln(Arduino.list());

Das Ausgabefenster wird Ihre serielle Ports aufzuzählen. [0]=COM1 [1]=COM6
Wählen Sie die Nummer, die der seriellen Schnittstelle des Arduino-Umgebung unter Werkzeuge
> Serial Port [1]=COM6


Referenz

Diese Funktionen sind in der Verarbeitung Arduino Bibliothek und kommunizieren (von Processing) mit einem Arduino, auf denen die Firmata Skizze installiert wurde.

Arduino.list (): gibt eine Liste der verfügbaren seriellen Geräten. Wenn Ihr Arduino-Board wird mit dem Computer verbunden, wenn Sie diese Funktion aufrufen, wird sein Gerät in der Liste sein.

Arduino(parent, name, rate):
erstellen Sie ein Arduino-Objekt. Elternteil sollte "dieses" (ohne die Anführungszeichen); Name ist der Name des seriellen Gerät (dh eines der von Arduino.list zurückNamen ()); Rate ist die Geschwindigkeit der Verbindung (typischerweise 57600). Beachten Sie, dass in der v2-Bibliothek ist die Rate Parameter optional.

pinMode(pin, mode):
Setzt einen digitalen Stift, um Eingabe-, Ausgabe- oder Servomodus (Arduino.INPUT, Arduino.OUTPUT oder Arduino.SERVO).

digitalRead(pin):
gibt den Wert eines digitalen Stift entweder Arduino.LOW oder Arduino.HIGH (der Stift muss als Eingang eingestellt werden).

digitalWrite(pin, value):
schreibt Arduino.LOW oder Arduino.HIGH zu einem digitalen Stift.

analogRead(pin):
gibt den Wert eines Analogeingang (0 bis 1023).

analogWrite(pin, value):
schreibt einen Analogwert (PWM-Welle) zu einem digitalen Stift, der es unterstützt (Stifte 3, 5, 6, 9, 10 und 11); Wert sollte zwischen 0 (immer aus) bis 255 (immer an) sein.

servoWrite(pin, value):
 schreibt einen Wert mit einem Servomotor; Wert sollte von 0 bis 180 sein.


Processing to Arduino Serial DIGITAL   pin-13  0 und 1
SENDER:          Processing_buch-kap6_arduino_blink_1a.pde

EMPFÄNGER:   MENU > Datei > Beispiele > Firmata > StandardFirmata.ino  <Uploa

arduino = new Arduino(this, Arduino.list()[1], 57600);

Beispiel
Processing_Beispiel_1a.pde

/*Processing-Sketch: Processing_buch-kap6_arduino_blink_1a.pdeArduino-Sketch: MENU > Datei > Beispiele > Firmata > StandardFirmata.ino */import processing.serial.*; import cc.arduino.*;Arduino arduino;int ledPin = 13;            //OnBoard-LED pin-13void setup() {  size(75, 75);  println(Arduino.list());  // alle COM-Ports anzeigen COM1=[0] COM6=[1]  arduino = new Arduino(this, Arduino.list()[1], 57600); //Verbindung mit ARDUINO herstellen  arduino.pinMode(ledPin, Arduino.OUTPUT);               // Digital Ausgang pin-13 als Ausgang}void draw() {  arduino.digitalWrite(ledPin, Arduino.HIGH); //OnBoard-LED EIN pin-13 high  print("pin-13= " + Arduino.HIGH);  // H-Pegel-Ausgabe im Nachrichten-Fenster  delay(1000);                                // 1000ms Leuchtdauer  arduino.digitalWrite(ledPin, Arduino.LOW);  //OnBoard-LED AUS pin-13 low  println("   pin-13= " + Arduino.LOW);  // L-Pegel-Ausgabe im Nachrichten-Fenster  delay(1000);               // OnBoard-LED pin-13 blinkt alle 2 Sekunden}

Ein weiteres Beispiel

Hacking eine Verarbeitung Skizze für Firmata (Firmata 101)
http://playground.arduino.cc/Interfacing/ProcesssHackForFirmata


Fehlerbehebung

Wenn Sie Probleme haben, diese zur Arbeit sind, können Sie um Hilfe bei der Arduino Forum fragen. Wenn Sie einen Fehler in der Arduino (Firmata) Bibliothek zur Verarbeitung gefunden haben, melden Sie dies bitte auf der GitHub Themen-Liste.


Externe Ressourcen

Arduino erfüllt Verarbeitung von K3, Malmoe ( http://webzone.k3.mah.se/projects/arduino-workshop/projects/arduino_meets_processing/instructions/index.html ) mit mehreren Beispielen für die Erstellung von Grafiken aus digitalen und analogen Sensoreingang
Rubrik Tom Igoe ( http://www.tigoe.net/pcomp/code/category/category/Processing/ ) über Verarbeitung mit mehreren Kommunikations- und Signalnachbearbeitungs Beispiele:
Pp. 169-176 in der "Physical Computing" Buch von Dan O'Sullivan und Tom Igoe (Vorschau in Google Bücher)
Sie können auch die SimpleMessageSystem ( http://playground.arduino.cc/Code/SimpleMessageSystem ) verwenden, um mit Verarbeitung kommunizieren.
Überprüfen Sie das Beispiel im Download.

*********************************************************
BUCH:  Die elektronische Welt mit Arduino entdecken
Erik Bartmann, Verlag-O'REILLY

Einfaches Oszilloscop Seite 503

1-Kanal Grafikausgabe im Processing Grafikfenster

void setup() {
  size(500, 400); smooth();
  println(Serial.list());   // Liste aller aktuellen seriellen Schnittstellen
  meinSeriellerPort = new Serial(this, Serial.list()[1], 9600);     // [0] = COM1  [1] = COM6=ARDUINO-Board
  meinSeriellerPort.bufferUntil('\n');
  yPos = new int[width];
}

liest Werte von analogen pin-A0  1-Kanal (ohne Header "H")   0 bis 1023

ARDUINO-IDE 1.0.5-r2

Sender:       Proces_ArduinoNeu_ProjektKapitel_12_2_1b.ino  (1023)         (zum IDE  "Serial-Monitor" nur zum testen)
void setup() {    UND  void loop() {

Processing-PDE 2.2.1
Empfänger:   Processing_ArduinoNeu_ProjektKapitel_12_2_1b.pde   (geht nur ohne laufenden "ARDUINO Serial-Monitor")
void setup() {    UND  void draw() {
http://www.erik-bartmann.de/arduino-projekt-kapitel-12.html



****************
Richtungs-Detektor mit 2 LDRs - Solar-Nachführung
Differenz-Wert Anzeige  -512..0..+511  Lichtquellen Position  Ausgabe im Processing Grafikfenster Seite 511
Sender:        Proces_ArduinoNeu_ProjektKapitel_13_1a.ino
Empfänger:  Processing_ArduinoNeu_ProjektKapitel_13_1a.pde    (geht nur ohne laufenden "Serial-Monitor")
http://www.erik-bartmann.de/arduino-projekt-kapitel-13.html

void loop() {
  int messwert;
  analogWertPin0 = analogRead(0);              // speichert den LDR1 Sensor-Werte von analogen pin-A0
  analogWertPin1 = analogRead(1);              // speichert den LDR2 Sensor-Werte von analogen pin-A1
  messwert = analogWertPin1 - analogWertPin0;  // LDR Differenz berechnen
  Serial.println(messwert);                    // Differenz-Wert an den "Serial-Monitor" übertragen
  delay(10);                                   // 10..50ms Pause ist notwendig
}






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

1-Kanal Thermometer (0.00 bis 99.99 °C)

LM35 mit Mittellwert-Berechnung - Temperatur-Verlauf in Processing dargestellt  Seite 723

0°C bis 100°C  (10mV/ °C)   1000mV = 100,00°C   (max. WERT 10-bit = 1023 = 5V = 499.51 = theoretisch 500°C)

Sender:       Proces_ArduinoNeu_ProjektKapitel_26_2a.ino   ( WERT 0.00  bis  100.54  bis  499.51 )
Empfänger: Processing_ArduinoNeu_ProjektKapitel_26_2a.pde (geht nur ohne laufenden "Serial-Monitor")
http://www.erik-bartmann.de/arduino-projekt-kapitel-26.html

Wenn das Ausgabefenster von Processing geöffnet ist, ist die Kommunikation mit dem Arduino-Board nicht möglich.
Warum?
Ganz einfach:
Processing greift auf die serielle Schnittstelle zu, die auch das ARDUINO-Board zur Kommunikation mit der Entwicklungsumgebung benötigt.
Dieser Port (COM6) ist also durch Processing blockiert und muss erst wieder durch das Schließen des Processing-Ausgabefensters freigegeben werden.

Website:    http://www.erik-bartmann.de
Blog:          http://www.tumblr.com/tumblelog/arduino-processing
Twitter:       https://twitter.com/#!/ErikBartmann
Flickr:        http://www.flickr.com/photos/erikbartmann/6318112502
Scope:       Die Temperatur
Version:     1.0
Date:         03.10.2011
Last modified:
Description:   Dieser Sketch zeigt die Auswertung der Temperatur über den Temperatursensor LM35

Referenz: http://arduino.cc/en/Reference/Serial
               http://arduino.cc/en/Reference/For
               http://arduino.cc/en/Reference/Delay


#define sensorPin 0    // verbunden mit LM35 Ausgang pin-A0
#define DELAY 10       // 10ms Wartezeit
const int cycles = 10; // Anzahl der Messungen 5..20

Scetch: Processing_ArduinoNeu_ProjektKapitel_26_1a.pdeLM35 Temperatur-Oscilloscop  0..100,54°C (Auflösung 0..1023 = 5V = 500°C theoretisch)10mV = 1°C  1000mV = 100°C

Mittelwert aus 10 Messungen 0.00  bis 499.51 GRAD

Sender:          Proces_Arduino_ProjektKapitel_26_NEU_2a.ino
Empfänger:    Processing_ProjektKapitel_26_NEU_2a.pde



  Serial.println(resultTemp);  // Ausgabe an die serielle Schnittstelle

Mittelwert aus 10 Messungen 0.0  bis 4995.0 mV

Sender:          Proces_Arduino_ProjektKapitel_26_NEU_2a.ino
Empfänger:    Processing_4995.0 milliVolt_2a.pde

****************
Datenerfassung und Visualisierung  ARDUINO-Analog-Tracker  6-Kanäle  Seite 757
Abfrage der Analog-Eingänge pin-A0 bis pin-A5 mit COM6 an Processing mit Firmata senden und grafisch darstellen.

Sender:       MENU > Datei > Beispiele > Firmata > AllInputsFirmata.ino  <Upload>
ODER  Proces_Arduino_AllInputsFirmata_2a.ino  (deutsch)

Empfänger: Processing_ArduinoNeu_ProjektKapitel_28_1_2a.pde (geht nur ohne laufenden "Serial-Monitor")
http://www.erik-bartmann.de/arduino-projekt-kapitel-28.html

/*Processing-Sketch: Processing_ArduinoNeu_ProjektKapitel_28_2a.pde
(Arduino-Sketch:) MENU > Datei > Beispiele > Firmata > AllInputsFirmata.ino
*/import processing.serial.*; // in Prozessimg die serielle Schnittstelleimport cc.arduino.*;Arduino arduino;Scrollbar myScrollbar0, myScrollbar1, myScrollbar2, myScrollbar3, myScrollbar4, myScrollbar5;void setup() {  size(420, 375);                               // Anzeige-Feld Größe      println(Arduino.list());                      // Anzeige aller COM-Ports den letzten nehmen  arduino = new Arduino(this, Arduino.list()[1], 57600);     // COM1=[0] COM6=[1] 57.600 baud  background(199);                             // Hintergrund-Farbe  hell-grau

ARDUINO Analog-Tracker  (Übertragungsprotokoll Firmata)

Processing-Ausgabefenster  (Processing-IDE 2.2.1)

Balkendiagram

Processing-Code-Review
Im Haupt-Sketch werden durch Instanziierungen wie z.B.

Scrollbar myScrollbar0,....
myScrollbar0 = new Scrollbar("Analog Pin 0:", 20, 20, 350, 35, color(89,7,243));
Scrollbar-Objekte generiert.
Der Konstruktor nimmt alle erforderlichen Argumente entgegen, um die Scrollbar zu erstellen.

•    Argument 1: 20 = x-Position der linken oberen Ecke der Scrollbar
•    Argument 2: 20 = y-Position der linken oberen Ecke der Scrollbar
•    Argument 3: 350 = Breite der Scrollbar
•    Argument 4: 35 = Höhe der Scrollbar
•    Argument 5: color(89, 7, 243) = RGB-Wert der Scrollbar-Hintergrundfarbe

Über die Methode wird die Scrollbar für den analogen Wert an pin-A0 im Ausgabefenster von Processing dargestellt.
myScrollbar0.drawScrollbar(arduino.analogRead(0));
Scrollbar-Objekt Scrollbar-Methode Firmata-Objekt Firmata-Methode



Datenerfassung und Visualisierung  ARDUINO Analog (6-Kanäle) & Digital (12-Kanäle)Tracker    Seite 765
Abfrage auch der Digital-Eingänge pin-2 bis pin-13 mit COM6 an Processing mit Firmata senden und grafisch darstellen.
Sender:        MENU > Datei > Beispiele > Firmata > AllInputsFirmata.ino  <Upload>
ODER  Proces_Arduino_AllInputsFirmata_2a.ino  (deutsch)
Empfänger: Processing_ArduinoNeu_ProjektKapitel_28_2_2a.pde (geht nur ohne laufenden "Serial-Monitor")
http://www.erik-bartmann.de/arduino-projekt-kapitel-28.html

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

BUCH: ARDUINO Schaltungsprojekte für Profis Seite 241

elektor-Verlag

C:\Benutzer\fritz\Desktop\2014-ARDUINO  .ino\BUCH Arduino Schaltungsprojekte für Profis\\CH_13\L13_01


Arduino to Processing Serial TEXT

Processing-TEST
Text-Ausgabe:      Processing_L13_01_TEST_Hello_World_1a.pde




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

Arduino to Processing Serial ANALOG

ARDUINO-UNO_Oscilloscope_6-Channel_ArduinoIDE_2a.ino
WERT  pin-A0 bis pin-A5  (H, 10, 100, 1000, 1023, 512, 256,)


Balken-Grafik für 6-Analog-Kanäle - Analog-Monitor (z.B Temperatur von 6 Räumen oder Kühlvitrinen messen)

ohne Header ohne Trennzeichen   (1023 0 200 256 800 1000)

Sender:        Proces_L13_02_Sechs_Channels_Balken_1a.ino  (1023 0 200 256 800 1000)
Empfänger: Procesing_L13_03_Sechs_Channels_Balken_1a.pde (geht nur ohne laufenden "Serial-Monitor")
http://www.elektor.de/Arduino_Schaltungspraxis_Software

Drei Dinge gilt es noch zu tun, bevor der Processing-Sketch einwandfrei läuft.
1) Zunächst muss Processing angewiesen werden, die Schriftart zu erzeugen, die wir für den Sketch verwenden.
Dazu müssen Sie den Sketch zunächst erstellen und speichern.
Klicken Sie dann bei geöffnetem Sketch auf
Processing-MENU >  Tools > Create Font > ArialMT-48.vlw    (Schriftgröße hat den Wert 48)
Klicken Sie anschließend auf OK.
2) Als zweiten Schritt müssen Sie bestätigen, dass Arduino den korrekten seriellen Anschluss  für die Kommunikation mit Arduino verwendet.
port = new Serial(this, "COM6", 9600);
3) Drittens müssen Sie die ARDUINO-Schaltung zusammenbauen und den ARDUINO-Sketch ( Proces_L13_02_Sechs_Channels_1a.ino ) hochladen.
Auf den meisten Systemen wird der Processing-Sketch einwandfrei laufen.





****************
Arduino to Processing Serial ANALOG

1-Kanal Data-Logger (pin-A0) (x-t-Diagramm von links nach rechts mit Bildschirm löschen)
Sender:       Proces_L13_04_einKanal_Data_Logger_2a.ino    (ohne Header 1023/2 = 0 bis 511)
Empfänger: Procesing_L13_05_einKanal_Data_Logger_2a.pde   (geht nur ohne laufenden "Serial-Monitor")
http://www.elektor.de/Arduino_Schaltungspraxis_Software

500 ---------------------------------------------------------------------
400 ---------------------------------------------------------------------
300 ---------------------------------------------------------------------
200 ---------------------------------------------------------------------
100 ---------------------------------------------------------------------
   0 ---------------------------------------------------------------------

int pinPot = 0;  // analog Eingang pin-A0int valPot = 0;  // Wert des Eingang pin-A0void setup() {  // serielle Übertragung initialisieren  Serial.begin(9600);  // max. 115200 baud}void loop() {   valPot = analogRead(pinPot) / 2; // analoge Werte lesen und durch 2 dividieren  Serial.println(valPot); // Bereich 0..511  delay(50);}

*********************************************************
BUCH: Arduino für Einsteiger  Seite 65

ARDUINO BUCH Sketche kostenlos downloadbar von

http://www.makezine.com/getstartedarduino

Arduino to Processing Serial ANALOG

1-Kanal  pin-A0

http://examples.oreilly.com/0636920021414/ch05/Example_07/Example_07.ino
Sender:       Proces_Beispiel_5_5_einKanal_Data_Logger_1a.ino   (ohne Header  1023 )

const int SENSOR = 0;     // select the input pin for the sensor resistorint val = 0;              // variable to store the value coming from the sensorvoid setup() {Serial.begin(9600);       // open the serial port to send data back to the computer at 9600 bits per second}void loop() { val = analogRead(SENSOR); // read the value from the sensorSerial.println(val);      // print the value to the serial portdelay(100);               // wait 100ms between each send}   

*********

Arduino to Processing  Serial ANALOG/DIGITAL

Arduino Networked Lamp  Seite 71 (Spielerei)

333_d_O'REILLY-x_ARDUINO für Einsteiger -6- Processing-Sketch_1b.doc

Arduino Networked Lamp
Reading feed:
http://blog.makezine.com/index.xml
peace = 0
love = 0
arduino = 0
sending #000000
light level [         ]
Next update in 10 seconds

Arduino Networked Lamp  Sketch-Fehler behoben

Dieses Arduino-Projekt nutzt 3-Daten aus dem Internet, um die Helligkeit der RGB-LED  zu steuern.
In der gleichen Zeit empfängt Processing Daten vom ARDUINO-BOARD.

Die Intensität der roten, grünen und blauen LEDs sind ein Verhältnis, wie oft die Worte,
"peace", "love" und "arduino"  in der URL http://blog.makezine.com/index.xml vorkommen.

const int SENSOR = 0;  // Analog LDR Eingang pin-A0 - light level
const int R_LED = 9;   // Digitaler Ausgang rot pin-9
const int G_LED = 10;  // Digitaler Ausgang grün pin-9
const int B_LED = 11;  // Digitaler Ausgang blau pin-9
const int BUTTON = 12; // Digitaler Eingang Taster pin-12


Beispiel 6-1 Seite 74
Sender:       Procesing_Beispiel_6_1_Arduino_network_lamp_1a.pde
http://examples.oreilly.com/0636920021414/ch06/Example_08A/Example_08A.pde

Beispiel 6-2 Seite 79
Empfänger: Proces_Beispiel_6_2_Arduino_network_lamp_1a.ino
http://examples.oreilly.com/0636920021414/ch06/Example_08B/Example_08B.ino

SENDER EMPFÄNGER Sketch:  http://cmuems.com/2012/b/b/11/14/monitoring-the-web-w-arduino/
https://www.inkling.com/read/getting-started-arduino-massimo-banzi-2nd/chapter-6/talking-to-the-cloud
.


Die Überwachung des Web w / Arduino
Diese Schaltungen und Codes demonstriert, wie eine bestimmte Webseite zu 3 verschiedene Wörter zu überwachen und zu verwenden, wie oft diese Worte erscheinen, um die Helligkeit von drei LEDs zu steuern. Es ist auch mit einem Lichtsensor (LDR), um die Farbe des Fensters der Computerbildschirm steuern. Als Beispiel mag dies willkürlich, aber es zeigt, wie Sensoren auf dem Arduino kann verwendet werden, um Dinge geschehen auf dem Bildschirm zu steuern, und es zeigt, wie Verarbeitung und seine Fähigkeit, mit dem Internet beteiligen können verwendet werden, um die Dinge geschehen über im physischen Raum Ihre Arudino.

Es gibt im Wesentlichen zwei Programme, die ausgeführt wird, ein Verarbeitungsprogramm , das auf Ihrem Computer ausgeführt wird, und eine, die auf Ihrem Arduino läuft. Die beiden unterhalten sich miteinander.
Um diese Kopie an ihren jeweiligen Plätzen mit den beiden Programmen und eine Schaltung mit LED und auf den pin-9, pin-10 und pin-11, einen Taster auf pin-12 und Fotosensor (LDR) an pin-A0.

https://www.inkling.com/read/getting-started-arduino-massimo-banzi-2nd/chapter-6/talking-to-the-cloud
http://forum.arduino.cc/index.php?topic=131981.0;wap2
http://forum.arduino.cc/index.php?topic=139218.0
https://answers.yahoo.com/question/index?qid=20140121180946AAdMCbc
http://cdn.makezine.com/make/books/getstartedarduino/eg/Example_08A.txt
http://forum.processing.org/one/topic/processing-arduino-networked-lamp-12-11-2012.html




*********************************************************
BUCH:
Arduino Praxiseinstieg  Seite 230 Listing 5.19 LED als Licht-Sensor
Thomas Brühlmann, mitp-Verlag

http://arduino-praxis.ch

Änderungen/Errata/   Korrekturen  (PDF, 18k)  http://arduino-praxis.ch/files/arduino-praxiseinstieg2-errata.pdf
arduino-praxis.ch/files/Beispiele-Buch-Arduino-Praxiseinstieg-2-Auflage.zip
http://arduino-praxis.ch/wp-content/uploads/Arduino-Praxiseinstieg-Linkssammlung.pdf

Arduino to Processing Serial ANALOG

www.thebox.myzen.co.uk/Workshop/LED_Sensing.html

LED als Berührungs-Sensor (LED als Licht-Sensor / Fotodiode)

Reagiert nur auf Änderungen  der LED-Ladung
LED Sensing    - LEDs can be used as a light sensor as well as an emitter.

Sender 6-Kanal: Proces_buch2_kap5_led_lichtsensor_Sensor_Feedback_1a.ino (geht noch nicht)
Proces_buch2_kap5_led_lichtsensor_6_Kanal_1a.ino 
http://www.thebox.myzen.co.uk/Workshop/LED_Sensing_files/Sensor_Feedback.pde (ino)

Sender 1-Kanal:       Proces_buch2_kap5_led_lichtsensor_1_Kanal_1a.ino 
http://www.thebox.myzen.co.uk/Workshop/LED_Sensing_files/Sensor_LEDs.pde  (ino)
Empfänger:             Processing_buch2_kap5_led_lichtsensor_1a.pde    (geht noch nicht)
http://www.thebox.myzen.co.uk/Workshop/LED_Sensing_files/LED_Sensor.pde



*********

Arduino to Processing Serial ANALOG

int pinPot = 0;  // 10k Potentiometer an Analog Port pin-A0int valPot = 0;  // Variable Potentiometer-WERTvoid setup() {  Serial.begin(9600);   // Übertragungsgeschwindigkeit 9600 baud}void loop() {  valPot = analogRead(pinPot) / 4;   // Werte 0..255 versenden  //valPot = 123;  Serial.println(valPot);   // Daten senden und Zeilenumbruch (ln) am Ende  delay(200);   // min. 20ms warten, damit sicher alle Werte versendet werden }

#include <Boards.h>

By Michael Margolis

Publisher: O'Reilly Media

Final Release Date: December 2011

Pages: 724

Im 512x512pixels größen grauen Processing-Fenster beliebige Position mit Mouse anklicken,
es werden die x- und y-Koordinaten der Maus in zwei 16-bit-Werten an den ARDUINO gesendet
und der gibt seinerseits das Ergebnis wieder an Prozessing zurück

Arduino to Processing Serial ANALOG