Untere Zeile:

COM6:    StandardFirmata.ino-2.3    Tx:149 Rx:85xxxx




*********************************************************
BUCH: fritzing Einführung in den kreativen Umgang mit Elektronik  Seite 106
Firmata
Firmata ist ein Protokoll zur Kommunikation zwischen Mikrocontrollern (z.B. dem Arduino) und Software, die auf Computern ausgeführt wird.
Ein Protokoll kann man sich wie eine Sprache vorstellen, mithilfe derer sich zwei unterschiedliche Systeme unterhalten.
Damit diese Sprache verstanden wird, benötigen beide Systeme jeweils einen spezifischen Übersetzer.
Im folgenden Abschnitt werden wir ein Arduino und die Software Processing mit einander »reden« lassen.

Software: Prozessing                                 -     Firmata   -                   Board:  ARDUINO UNO R3
Processing-Library: Firmata                                                               ARDUINO-Code: Beispiele / Firmata / StandardFirmata



Vorbereitung des Arduinos
Öffnen Sie in der Software: (Arduino-IDE 1.0.6) das Programm "StandardFirmata"
MENU > Datei > Beispiele > Firmata > StandardFirmata
und übertrage es mit Upload (Icon = Pfeil nach rechts) auf das Arduino-Board.
Arduino ist nun für die Verwendung in Processing vorbereitet und muss nicht mehr umprogrammiert werden.

Processing Installation
Processing ist eine auf Java basierende offene Programmierumgebung.
Sie steht unter www.processing.org zum Download zur Verfügung.
Bitte lade die Version 1.5.1 und installiere sie für die weitere Bearbeitung.

Processing ist für den kreativen Umgang mit Code (Programmtext) entwickelt worden und besonders geeignet für die Erstellung generativer Grafik, Animationen und Interkationen.

Firmata-Library für Processing Installieren
Um Processing auf Arduino vorzubereiten sind noch ein paar Schritte nötig:
1. Lade die Firmata-Programmbibliothek herunter: http://playground.arduino.cc/interfacing/processing
2. Öffne den Sketchbook-Ordner von Processing. (Den Pfad findest Du, indem Du Processing öffnest und auf Processing > Datei > Einstellungen klickst.)
3. Wenn es im Sketchbook-Ordner noch keinen libraries-Ordner gibt, leg ihn selbst an. Achte auf die Schreibweise: libraries.
4. Kopiere die Firmata-Programmbibliothek hinein.
5. Starte Processing, die Bibliothek wird mit dem Programmstart automatisch geladen.

Schaltung vorbereiten
Baue die nebenstehende Schaltung auf (Processing RGB).

Programmbeispiel öffnen.
Im Fritzing Creator Kit Softwarepaket, das Du herunter-geladen hast, findest Du den Ordner Processing.
Öffne die sich darin befindliche Datei RGB in Processing.

Starte das Programm Sketch > Run <Strg+

Port wählen
Das Processing 2.2.1 Programmfenster hat unten einen schwarzen Ausgabebereich.
Beim Programmstart werden alle angeschlossenen COM-Geräte angezeigt.
Merke Dir die  COM-Nummer (z.B COM1  COM6) die auf das Arduino weist:
Bei Windows PCs ist es der letzte Eintrag (daher COM6),
Schließe das Programm und ändere die Nummer im Programmcode in der Zeile:
meinArduino = new Arduino(this, Arduino.list()[1], 57600);
Starte das Processing-Programm erneut  MENU > Sketch > Run  <Strg+R>

Die Processing-Software war das Vorbild für die Arduino-Software.


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

SENDER:          MENU > Datei > Beispiele > Firmata > StandardFirmata.ino  <Upload>
ODER  Proces_StandardFirmata_1a.ino
EMPFÄNGER:    Processing_fritzing_RGB_2a.pde

/*Sketch: Processing_fritzing_RGB_2a.pde*/import processing.serial.*;import cc.arduino.*;Arduino meinArduino;

int potPin=0;int value;int redX = 20;int greenX = 20;int blueX = 20;int redPin = 9;int greenPin = 10;int bluePin = 11;int oldGreen;int oldRed;int oldBlue;void setup() {size(400,300,P3D);  // size(255,300,P3D);println(Serial.list()); // List all the available serial ports:meinArduino = new Arduino(this, Arduino.list()[1], 57600); //  COM1=[0]  COM6=[1]noStroke();}void graphics(int theValue){colorMode(RGB,255);background(0);fill(100);rect(0,20,width,20);rect(0,60,width,20);rect(0,100,width,20);fill(255,0,0); rect(0,20,redX,20);fill(0,255,0); rect(0,60,greenX,20);fill(0,0,255); rect(0,100,blueX,20);colorMode(HSB, 100);fill(value,100,100);rect(0,160,width,height);}void draw(){value=meinArduino.analogRead(potPin);value=(int)map(value,0,1023,0,100);if (mousePressed==true){    if ((mouseX>0)&&(mouseX<=width)) {   if ((mouseY>20)&&(mouseY<40)) {   redX = mouseX;   }   if ((mouseY>60)&&(mouseY<80)) {   greenX = mouseX;   }   if ((mouseY>100)&&(mouseY<120)) {   blueX = mouseX;   }  } }

graphics(value);if (redX!=oldRed){   meinArduino.analogWrite(redPin,redX);   oldRed=redX;   }   if (greenX!=oldGreen){   meinArduino.analogWrite(greenPin,greenX);   oldGreen=greenX;   }   if (blueX!=oldBlue){   meinArduino.analogWrite(bluePin,blueX);   oldBlue=blueX;   }}

Nach der Installation von Arduino ( downzuloaden unter arduino.cc/en/Main/Software) und Processing ( processing.org/download) brauchten wir für Letzteres noch die Arduino-Library ( tinyurl.com/l5z4ph).

Nach dem Herunterladen muss man den entpackten -Arduino-Ordner in den Library-Ordner von Processing ziehen.

Und schließlich benötigten wir für die weitere Verwendung noch Firmata - ein Protokoll, das die Kommunikation zwischen dem Microcontroller (Arduino) und der Software ermöglicht.

Dazu startet man in die Arduino-IDE 1.0.6  und öffnet  MENU >  Datei > Beispiele > Firmata > StandardFirmata.ino.

Danach muss man den aktuellen Inhalt des Atmel-Chips auf dem Arduino-Board löschen, da er immer nur Platz für ein Script bereithält.

Dazu drückt man auf den Reset-Knopf des Boards und klickt danach sofort auf "Upload to I/O Board" im Arduino-Fenster , um den neuen Firmata-Code hochzuladen - wenn Sie zu lange warten, können Sie den Code nicht hochladen und müssen noch mal die Löschtaste drücken.

Einfache Beispiele  Simple Examples  http://playground.arduino.cc/Interfacing/Processing

Arduino Bibliothek für die Verarbeitung (und Firmata)    Arduino Library for Processing (and Firmata)

Herunterladen  Download

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

Bibliothek für die Verarbeitung v1.5.1: processing-arduino.zip (Aktualisiert 11. November 2011)
(Properties-Datei hier: Verarbeitungs-arduino.txt )

Hinweis: Wenn Sie Linux laufen, um Arduino.jar in arduino.jar ändern, da Linux ein fallspezifisches müssen und es nicht funktioniert, wenn Sie nicht, diesen Brief zu ändern (Arduino.jar ist im Ordner "Bibliothek" von dieser Processing Library).

Anleitung  Instructions

1. Entpacken Sie die Bibliothek und kopieren Sie die "Arduino" -Ordner in den "Bibliotheken" Unterordner Ihres Verarbeitung Sketchbook. (Sie können die Position Ihrer Sketch durch Öffnen der Verarbeitungseinstellungen zu finden. Wenn Sie einen "Bibliotheken" Unterordner vorgenommen haben, erstellen Sie eine.)
2. Arduino starten, öffnen Sie die MENU > Datei > Beispiele > Firmata > StandardFirmata sketch, und laden Sie sie auf dem Arduino Board.
3. Konfigurieren Verarbeitung für Serien: http://processing.org/reference/libraries/serial/
4. In Verarbeitung, öffnen Sie eines der Beispiele, die mit dem Arduino Bibliothek kommt.
5. Ändern Sie den Beispielcode, den seriellen Port von Arduino verwendet auszuwählen. Genauer gesagt, ändern Sie die [0] in diese Zeile auf [1]

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

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

       import processing.serial.*;    import cc.arduino.*;    println(Arduino.list());

   Das Ausgabefenster wird Ihre serielle Ports aufzuzählen. Wählen Sie die Nummer, die der seriellen Schnittstelle des Arduino-Umgebung unter Tools > Serial Port. 
6. Führen Sie das Beispiel.

Hinweis Reference

Diese Funktionen sind in der Verarbeitung Arduino Bibliothek und Kommunikation (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 eine Arduino-Objekt. Eltern sollte "this" (ohne die Anführungszeichen); Name ist der Name des seriellen Gerät (z.B. eine der von Arduino.list ()); zurück Namen ist die Geschwindigkeit der Verbindung (typischerweise 57600 baud). 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 pin-x muss als Eingang eingestellt sein).

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

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

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

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

Das Beispiel UNTEN zeigt das Zusammenspiel von Processing und Arduino-Befehlen.

Die bekannten Arduino-Befehle beginnen nun jeweils mit dem Objektnamen arduino.
Die wichtigsten Arduino-Befehle lauten:

Port als Eingang oder Ausgang setzen
arduino.pinMode(PortNummer, Arduino.OUTPUT);
arduino.pinMode(13, Arduino.INPUT);
Digitalen Eingang einlesen
arduino.digitalRead(PortNummer);
Digitalen Ausgang setzen
arduino.digitalWrite(ledPin, Arduino.HIGH);
arduino.digitalWrite(ledPin, Arduino.LOW);

Analogen Eingang einlesen
arduino.analogRead(PortNummer);
Analogen Wert ausgeben
arduino.analogWrite(PortNummer, Wert);

Mit dieser Funktionserweiterung kann ein Arduino über die Processing-Oberfläche programmiert werden,
wobei Arduino- Befehle und Processing-Funktionen, beispielsweise zur Darstellung der Oberfläche, gemischt werden können.

EMPFÄNGER:   MENU > Datei > Beispiele > Firmata > StandardFirmata.ino  <Upload>
SENDER:          Processing_buch-kap6_arduino_blink_1a.pde

Beispiel Example

/*
Sketch: Processing_buch-kap6_arduino_blink_1a.pde
*/

import processing.serial.*; 
import cc.arduino.*;

Arduino arduino;
int ledPin = 13; //OnBoard-LED pin-13

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
}

Ein weiteres Beispiel  Another example

• Hacking eine Verarbeitung Skizze für Firmata (Firmata 101)

Fehlerbehebung  Troubleshooting

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

Externe Ressourcen

• Arduino erfüllt Verarbeitung von K3, malmoe mit mehreren Beispielen für die Erstellung von Grafiken aus digitalen und analogen Sensoreingang
• Rubrik Tom Igoe über Verarbeitung mit mehreren Kommunikations- und Signal Nachbearbeitung Beispiele
• Pp. 169 bis 176 in der "Physical Computing" Buch von Dan O'Sullivan und Tom Igoe ( Vorschau in Google Bücher )
• Sie können auch die Verwendung SimpleMessageSystem mit Verarbeitung kommunizieren. Überprüfen Sie das Beispiel im Download.