Firmata

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

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2014-11-22

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

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************
http://www.arduino.cc/playground/Interfacing/Processing
http://playground.arduino.cc/Interfacing/Processing



*********************************************************
                           Firmata
http://firmata.org/
http://firmata.org/wiki/Main_Page

Firmata ist ein allgemeines Protokoll für die Kommunikation mit dem ARDUINO UNO,
mit ATmega328p-Mikrocontroller mit der  firmata_test.exe Software auf einem Computer.

Programm firmata_test.exe

Board ARDUINO Uno R3
In der  ARDUINO-IDE 1.0.6, öffnen Sie den Firmata-Code mit
SENDER:        MENU > Datei > Beispiele > Firmata > StandardFirmata  <Upload>

void setup()
Firmata.begin(57600);  // 57.600 baud

StandardFirmata | Arduino 1.0.6
                                                       Arduino Uno on COM6


Dieses "firmata_test.exe" Programm arbeitet mit ARDUINO UNO Boards mit der  StandardFirmata Version.ino-2.3 oder höher.


Damit ist es möglich die ARDUINO UNO Boards schnell zu testen, man kann aber auch über eigenständiges Programm auf alle Pins zugreifen.
EMPFÄNGER:   firmata_test.exe läuft von einer einzigen Datei (keine Installation erforderlich), sehr gut für schnelle und einfache Tests!

http://www.pjrc.com/teensy/firmata_test/firmata_test.exe

ACHTUNG vorher einstellen:
MENU > Port > COM6: den seriellen Port COM6  öffnen
Baudrate:  57.600 baud



pin-0 = RxD   n.c.  freihalten
pin-1 = TxD   n.c.  freihalten


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.


***************
BUCH: fritzing Einführung in den kreativen Umgang mit Elektronik  Seite 109

Firmata

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


rot pin-9
grün pin-10
blau pin-11
Die 3 Farbbalken mit Maus aufziehen
10k Poti an pin-A0 - Die Farbe der Fläche ändert sich


siehe
http://sites.prenninger.com/arduino-uno-r3/starter-kit-lern-set
#13 Processing RGB   Seite 109

fritzing Datei: Processing_RGB.fzz
fritzing Code: Beispiele / Firmata / StandardFirmata
Processing-Code: Processing / RGB

Processing Software - Firmata (Protokoll zu Kommunikation) - ARDUINO UNO R3  Handbuch Seite 106  http://playground.arduino.cc/interfacing/processing
Processing Software  Handbuch Seite 107  www.processing.org

/*
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;    } }




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

Arduino für Processing einrichten
StandardFirmata
Zunächst einmal müssen wir entscheiden, ob wir Arduino lieber mit einer Flash- oder einer Processing-Anwendung steuern wollten.
Zwei Gründe sprachen für Processing:
Erstens basiert die Arduino-IDE auf Processing, sodass die Kommunikation (im Gegensatz zu Flash) ohne eine lästige Serial-Proxy-Signal-umwandlung auskommt.
Zweitens ist Processing (wie Arduino) ein Open-Source-Werkzeug.

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 kommt mit einigen grundlegenden Beispiele für die Kommunikation mit Processing (in Examples > Communication).
Diese sind nützlich, wenn Sie sowohl Arduino und Verarbeitungsprogramme schreiben wollen und sie miteinander sprechen.
Dies funktioniert am besten für die Kommunikation einfach Informationen.
Wenn Sie wollen einfach nur ein Arduino Board von einem Verarbeitungsprogramm zu steuern, können Sie die Arduino Bibliothek für die Verarbeitung im Folgenden beschrieben.

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

Diese Bibliothek erlaubt Ihnen, ein Arduino Board von Verarbeitung ohne das Schreiben von Code für die Arduino steuern.
Stattdessen können Sie eine Standard-Firmware (Programm) auch direkt hochladen und kommunizieren sie mit Hilfe der Bibliothek.
Die Firmware aufgerufen Firmata, und wird in der Arduino Software enthalten.
Die entsprechende Verarbeitung Bibliothek kann hier heruntergeladen werden.

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

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




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

BUCH: Arduino Praxiseinstieg Behandelt Arduino 1.0

Thomas Brühlmann

Arduino – Praxiseinstieg
von Thomas Brühlmann
2. Auflage
Softcover
528 Seiten
Format 17,0 x 24,0
ISBN: 3-8266-9116-4
Verlag: mitp/bhv

Erscheinungsdatum: September 2012

Zu bestellen bei Amazon.de

Inhaltsverzeichnis (2. Auflage)
Download Beispiele (2.Auflage) (ZIP, 134 kB)
Änderungen/Errata (PDF, 18k)

Im vorigen Beispiel wurden Daten vom Arduino an Processing gesendet.
Die Bibliothek für das Arduino-Board heißt FIRMATA und wird bei der Installation der....
Das Blog zum Buch "Arduino Praxiseinstieg"
http://arduino-praxis.ch/
arduino-praxis.ch/das-buch/


Sie laden den Firmata-Code auf den ARDUINO UNO  hoch.



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

Arduino Kochbuch - Seite 127

http://www.arduino-tutorial.de/2010/06/serielle-kommunikation/




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

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







Comments