Processing

http://sites.prenninger.com/arduino-uno-r3/processing

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2014-12-12

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************
Arduino-IDE 1.0.6      Processing-IDE 2.2.1





Ich mußte leider feststellen das die im Internet kostenlos downloadbaren Sketche immer wieder kleine Fehler haben.
Auch in allen Büchern sind viele Sketche nicht lauffähig und den Autoren ist dies völlig egal.
BUCH wurde ja schon gekauft.

Auch die kleinsten Fehler in einem Sketch verhindern aber deren Gebrauch.
Meist hat man auch keine Ahnung wo es eigentlich hackt.
Nur durch akribische Fehlersuche bringt man dann diese zum laufen.
Alle korrigierten Sketche sind von www.schaltungen.at downloadbar.
Alle Sketche mit deutschen Erklärungen / Bemerkungen versehen, war doch sehr zeitaufwendig ! ! !
fritz prenninger
P.S
Bei den tausenden simplen Blinkschaltungen die keiner wirklich braucht da gibt es keine Probleme.
Aber wo es aufwendiger wird da ist Schweigen im Walde.

https://www.processing.org/
http://www.pixelstorm.ch/processing/
http://processingjs.org/

http://www.creativecoding.org/lesson/basics/processing/einstieg-in-processing


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-Datentyp println(Arduino.list());
Zum Schluß haben wir ein Arduino Library-Funktion,
arduino.analogRead(0);  hinzugefügt, um die Eingabe von der Maus zu ersetzen.

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.pde Arduino-Sketch: MENU > Datei > Beispiele > Firmata > StandardFirmata.ino  */ import processing.serial.*; import cc.arduino.*; Arduino arduino; int ledPin = 13; //OnBoard-LED pin-13 void 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:   Processing: Kreativ programmieren mit Processing.
Für Designer, Künstler und Geeks.  Visuelle Welten gestalten
Erik Bartmann



*********************************************************
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.pde
LM35 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

ACHTUNG: Firmata-Librarie ist auf beiden Seiten notwendig.
In diesem Projek werden die folgenden Arduino-Befehle verwendet:
Beispiel-Sketch = AllInputsFirmata aus der Firmata-Rubrik - siehe OBEN

http://firmata.org/wiki/Download
Für die Processing-Kommunikation müssen Sie eine Library herunterladen und installieren, die Sie unter dem folgenden Link finden.
http://playground.arduino.cc/Interfacing/Processing
Hinweis zur Programmiersprache Processing: Die Entwicklungsumgebung findet man unter
https://www.processing.org/



/*
Processing-Sketch: Processing_ArduinoNeu_ProjektKapitel_28_2a.pde
(Arduino-Sketch:) MENU > Datei > Beispiele > Firmata > AllInputsFirmata.ino
*/
import processing.serial.*; // in Prozessimg die serielle Schnittstelle import 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
usw. usw. usw.


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-A0
int valPot = 0;  // Wert des Eingang pin-A0
void 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 resistor
int val = 0;              // variable to store the value coming from the sensor
void 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 sensor
Serial.println(val);      // print the value to the serial port
delay(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.
I
n 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

Datenverarbeitung mit Prozessing Seite 278
Procesing_buch2_kap6.3_Processing_Gesicht_1a

Daten von ARDUINO an Processing

1-Kanal  pin-A0  Wert 0..255 mit 10k Poti - Kreisposition wird verändert

Sender:       Proces_buch2_kap6_arduino_send_analog_2a.ino  (0 bis 255)
int pinPot = 0;  // 10k Potentiometer an Analog Port pin-A0
int valPot = 0;  // Variable Potentiometer-WERT
void 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 
}

Empfänger: Processing_buch2_kap6_arduino_analog_empfangen_2a.pde  (geht nur ohne laufenden "Serial-Monitor")

Links unten = 0  Rechts oben = 255

*********

Arduino to Processing Serial ANALOG

ARDUINO UNO R3  steuern mit Processing
Daten von Processing an das ARDUINO UNO Board



Processing übernimmt das Kommando
Auch die komplette Steuerung des Arduino kann über die Processing-Oberfläche realisiert werden.
Dabei wird im ARDUINO und auf der Seite von Processing je eine Bibliothek installiert.
Die Bibliothek für das Arduino-Board heißt FIRMATA und wird bei der Installation der Arduino-IDE mit installiert.
http://www.arduino.cc/en/Reference/Firmata
Das Importieren der FIRMATA-Bibliothek erfolgt in der Entwicklungsumgebung über das Hauptmenü:

MENU > Sketch > Library importieren... > Firmata
Dabei wird im Arduino-Programm ein Verweis auf die Datei Firmata.h eingefügt.
#include <Boards.h>
#include <Firmata.h>

Für die Steuerung des ARDUINO über Processing-IDE ist in der Arduino-Sketchsammlung
bereits ein komplettes Programm vorhanden, das geöffnet und auf das Board hochgeladen werden kann.
Dabei sind keine weiteren Einträge nötig.

Das Programm heißt StandardFirmata und ist unter
MENU > Datei > Beispiele > Firmata > StandardFirmata
zu finden.


Nach dem Hochladen auf das Arduino-Board passiert vorerst nichts, da von Processing her noch keine Kommunikation erfolgt ist.
In Processing muss die Arduino-Bibliothek importiert werden.
Diese Bibliothek erweitert Processing um Arduino-Steuerbefehle.
Die Erweiterung steht auf der Arduino-Website zum Download bereit:
http://www.arduino.cc/playground/Interfacing/Processing
http://firmata.org/

Die ZIP-Datei wird nach dem Download extrahiert und im Processing-Verzeichnis abgelegt:
Processing-Verzeichnis
C:\2015 processing-2.2.1\modes\java\libraries
\
arduino (Firmata)
   (ACHTUNG: nachsehen ob Firmata-Library vorhanden ! ! ! )
dxf
glw
minim
net
pdf
serial
video


Somit sind alle nötigen Schritte durchgeführt und das erste Beipielprogramm kann geladen und ausgeführt werden.
Alle Programme beginnen nun jeweils mit dem Verknüpfen der Arduino-Library und dem anschließenden Erstellen eines Arduino-Objekts.


ARDUINO UNO = Empfänger: MENU > Datei > Beispiele > Firmata > StandardFirmata.ino  <Upload>
ODER
Proces_StandardFirmata_1a.ino   (ACHTUNG: 57600 baud)

Processing = Sender:  Processing_buch_pa_kap6_arduino_blink_2a.pde

import processing.serial.*;
import cc.arduino.*;
Arduino arduino;
int ledPin = 13;            // OnBoard-LED pin-13 blinkt
void setup()
{
  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
  delay(1000);                                 // 1000ms Leuchtdauer
  arduino.digitalWrite(ledPin, Arduino.LOW);   // OnBoard-LED AUS pin-13 low
  delay(1000);                                 // OnBoard-LED pin-13 blinkt alle 2 Sekunden
}


*********************************************************
Siehe Untergeordnete Seiten
Arduino und Processing mit Messenger-Bibliothek
http://raumfuehler.andreasmuxel.com/
Kommunikation Arduino Board zu Processing
http://raumfuehler.andreasmuxel.com/index.php/arduino-und-processing/kommunikation-arduino-board-zu-processing/
Kommunikation Processing zu Arduino Board
http://raumfuehler.andreasmuxel.com/index.php/arduino-und-processing/kommunikation-processing-zu-arduino-board/



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

BUCH:  Arduino Kochbuch  Seite 93

Arduino to Processing Serial ANALOG


Arduino Cookbook, 2nd Edition

Recipes to Begin, Expand, and Enhance Your Projects
Publisher: O'Reilly Media
Final Release Date: December 2011
Pages: 724

Übersetzung des Peter Klicman sehr fehlerhaft.

http://shop.oreilly.com/product/0636920022244.do



Viele Sketche (der Peter Klicman nennt dies Rezepte) sind einfach nur fehlerhaft = FALSCH.
Errata for Arduino Cookbook

http://www.oreilly.com/catalog/errata.csp?isbn=0636920022244


Processing-Entwicklungsumgebung Prozessing-IDE 2.2.1
http://processing.org/  


MEUNU > File > Examples... > Libraries > serial > SimpleRead

Sender:       Proces_Kochbuch_Simple_Read_1a.ino
Empfänger: Processing_Kochbuch_Simple_Read_1a.pde


Taster an ARDUINO UNO R3 Digital-Eingang pin-4



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

BUCH:  Arduino Kochbuch  Seite 106

Mehrere Textfelder zu Processing senden

Der Arduino-Code dieser Lösung sendet den folgenden Textstring an den seriellen Port
(\r steht für das Carriage Return  \nn)
^Linefeed (\n)",4>n (Linefeed)^\n (Line-feed)",4> für das Linefeed):


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,)


Fix-WERT Ausgabe für TESTs (3-Kanäle mit Header H, 10, 100, 1000, )

Sender:       Proces_Kochbuch_ch04r04_CommaDelimitedOutput_1a.ino  (H,10,100,1000,)
Empfänger: Processing_
Kochbuch_ch04r04A_CommaDelimitedOutput_1a.pde   (erwartete Format ist: H,1,2,3,)

ACHTUNG: Keine Display Windows Ausgabe nur in der Konsole


WERTe werden nur in der Processing-Konsole ausgegeben

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

Arduino to Processing Serial ANALOG

6-Analog-Kanäle   -128..0..+127   (mit Header Data,1023,100,128,256,512,1023 und Komma als Datentrenner)
Sender:       Proces_Kochbuch_ch04r04C_ShowSensorData_6-Kanal_1a.ino  ( Data, 255, )
Empfänger: Processing_
Kochbuch_ch04r04B_ShowSensorData_6-Kanal_1a.pde



Processing-Bildschirm mit Analog-Sensordaten




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

BUCH:  Arduino Kochbuch  Seite 115 & 120
Binäre Zufalls-Daten (random) vom Arduino zu Prozessing
2-Analog-Kanäle mit Header "H" und 2 integer-WERTE (16-bit) im binär-Format

Sender:      
Proces_Kochbuch_ch04r06_SendBinary_2-Kanal_1a.ino 


Empfänger: Processing_Kochbuch_ch04r07A_ReceiveBinaryData_X-Y_Rechteck_1a.pde



WERTe werden  in der Processing-Konsole ausgegeben




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

BUCH:  Arduino Kochbuch  Seite 121
Binäre WERTE aus Prozessing an den
Arduino senden
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

Sender:         Processing_Kochbuch_ch04r08_SendingBinaryToArduino_1a.pde

Empfänger:   Proces_Kochbuch_ch04r08A_BinaryDataFromProcessing_1a.ino 

WERTe werden nur in dem Processing-Nachrichtenfenster (Konsole) ausgegeben

**************
BUCH: Arduino Kochbuch Seite 123

Alle ARDUINO pin-WERTE an Processing-Konsole senden
Header "H" gefolgt von
WERT der digitalen PINs pin-2 .. pin-13      (bitRead-Funktion)
WERT der analogen PINs pinA-0 .. pin-A5  (sendBinary Integerwerte)

Arduino to Processing Serial ANALOG

Sender:       Proces_Kochbuch_ch04r09_SendBinaryFields_17-Kanal_1a.ino

Empfänger: Processing_Kochbuch_ch04r09A_ReceiveMultipleFieldsBinary_1a.pde

WERTe werden nur in dem Processing-Nachrichtenfenster (Konsole) ausgegeben.


**************
BUCH: Arduino Kochbuch Seite 127

Arduino-IDE 1.0.6

MENU > Datei > Beispiele > Firmata > 
AllInputsFirmata .ino  (ACHTUNG: 57600 baud)
AnalogFirmata       .ino
EchoString          .ino
i2CFirmata          .ino
OldStandardFirmata  .ino
ServoFirmata        .ino
SimplaAnalogFirmata .ino
SimplaDigitalFirmata.ino
StandardFirmata  .ino
(ACHTUNG: 57600 baud)
<Upload>

Processing-PDE 2.2.1

MENU > File > Java Examples > Librarys > Arduino (Firmata)
arduino_input     .pde
arduino_input_mega.pde
arduino_output    .pde
arduino_pwm       .pde
arduino_servo     .pde

<run>

**************
BUCH: Arduino Kochbuch Seite 127

Der Maus-Zeiger des PCs wird durch einen ARDUINO Analog-Joystik ersetzt
2 Analog Eingange  pin-A4 & pin-A5  (Bereich ist  -127 bis +128)
1 Digital-Eingang  pin-2  offen = LOW = 0  (PC-Maus aktiv)    geschlossen = +5V = HIGH = 1 (ARDUINO Poti-Maus EIN  aber PC-Maus deaktiviert)

(mit Header Data,-127,128,0 und Komma als Datentrenner)

Arduino to Processing Serial ANALOG

Sender:       Proces_Kochbuch_ch04r10_SerialMouse_PotiJoystick_1a.ino
Empfänger: Processing_Kochbuch_ch04r10A_SerialMouse_PotiJoystick_1a.pde

WARNUNG:
Der Sketch übernimmt die Maus
Drücken Sie Escape, um den laufenden Sketch zu schließen



Siehe auch unter
http://java.sun.com/j2se/1.3/docs/api/java/awt/Robot.html
finden Sie weiterführende Informationen zur Java Robot-Klasse.
Einen Artikel zum Einsatz der Robot-Klasse finden Sie unter
http://www.developer.com/ javalotherlarticle.php/10936_2212401_1
Nenn Sie eine Windows-Programmiersprache bevorzugen, können Sie die Low-Level-Funktion Sendlnput der Windows-API nutzen, um Tastatur- und Maus-Events in den Eingabestream einzufügen.
Weitere Informationen finden Sie unter
http://msdn.micro-soft.com/en-us/library/ms646310(VS.85).aspx

BUCH: Arduino Kochbuch Seite 131
Sollten Sie dies wünschen werde ich auch diesen Sketch für Sie noch bearbeiten.
Sketch 4.11 Seite 131 zeigt, wie man diese Technik nutzt, um in Google Earth mit einem Wii Nunchuck-Beschleunigungsmesser den Flugsimulator steuert.
Flug über die Erde  ch04r11.ino   ch04r11A.pde


**************
BUCH: Arduino Kochbuch Seite 136
ADUINO UNO Daten in einer Processing-Datei auf dem Computer speichern
Alle Digital E/A pin-2 bis pin-13 & Analog Eingänge pin-A0 bis pin-A5 als Text Datei ( *.TXT Datei)
Mit Konsolen Ausgabe

Arduino to Processing Serial ANALOG

Sender:       Proces_Kochbuch_ch04r09_SendBinaryFields_17-Kanal_1a.ino <Üpload>
Empfänger:   Processing_Kochbuch_ch04r12_ReceiveMultipleFieldsBinary_2a.pde  <Run>
Drücken Sie eine beliebige PC-Taste, um das Logging zu beenden und die Datei zu speichern. 

Verzeichnis öffnen mit MENU > Sketch > Show Sketch Folder (Strg+K) > 141122_1755.txt

Meßwerte werden jede Sekunde gespeichert.



**************
                                    (1A)
BUCH: Arduino Kochbuch Seite 139
ADUINO UNO Daten in einer Processing-Datei auf dem Computer speichern.
Die Analog Eingänge pin-A0 bis pin-A5 als kommaseparierte Datei ( *.CSV Datei)
Ohne Konsolen Ausgabe

Arduino to Processing Serial ANALOG


Sender:         Proces_Kochbuch_ch04r09_SendBinaryFields_17-Kanal_1a.ino <Üpload>
Empfänger:   Processing_Kochbuch_ch04r12_ReceiveMultipleFieldsBinary_CSV_2a.pde <Üpload>
Empfänger:   FRITZ_Logging_Arduino_data_as_csv_1a.pde  (englisch)
Drücken Sie eine beliebige PC-Taste, um das Logging zu beenden und die Datei zu speichern.

Verzeichnis öffnen mit MENU > Sketch > Show Sketch Folder (Strg+K) > 141122_1755.csv

Meßwerte werden jede Sekunde gespeichert.


Weiterführende Informationen zu createWriter finden Sie unter
http://processing.org/reference/createWriter_.html




**************
BUCH: Arduino Kochbuch Seite 147

Processing-PDE.

Processing Development Environment (PDE)
Der Verarbeitungsumgebung
enthält einen Text-Editor, Compiler und ein Anzeigefenster.
Es
ermöglicht die Erstellung von Software innerhalb eines sorgfältig gestalteten Reihe von Einschränkungen.


https://processing.org/reference/environment/

ARDUINO-IDE  1.0.6
Die verfügbaren seriellen Ports sehen.
MENU > Tools > Serieller Poert > COM1 (PC)  COM6 (Arduino-Board)

ODER

Processing-PDE 2.2.1
Processing-Sketch gibt die verfügbaren seriellen Ports aus
und gibt empfangene Zeichen aus   (? ? ? nur welcher Art)
Processing_Kochbuch_ch04r15_GettingStarted_1a.pde




DIN A4 ausdrucken
*********************************************************

Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE









a