Processing — Android Apps programmieren

Processing kann noch mehr. So kann man relativ einfach für ein Android-Handy Apps entwickeln und entweder mit einem Simulator oder auf einem Handy testen.

Das genau Vorgehen kann und sollte man im Processing Wiki nachlesen. Ich beschreibe hier nur ganz kurz die nötigen Schritte.

  • Zuerst muss der Android SDK herunterladen und installieren werden.
  • Es müssen folgende zusätzlichen Pakete installiert werden (näheres dazu in der Installationsanleitung zum Android SDK)
    • “Tools”, markiere die “Android SDK Platform-tools”. Die “Android SDK Tools” sollten schon installiert sein.
    • Darunter folgt die “Android 2.2 (API 8)”, wähle “SDK Platform” und “Google APIs by Google Inc.” aus.
    • Wenn man möchte kann man auch noch andere Versionen von Android installieren.

  • Die aktuelle Version 2.0 alpha 3 von Processing herunterladen und installieren. (Download Links: Windows, Mac OS X, Linux)

Wenn man keinen Fehler macht und alles ordentlich installiert ist, kann man in Processing mit den mitgelieferten Beispiele anfangen und seine eigene Androide-Apps schreiben.

Im Android-Modus von Processing stehen dann folgende Optionen zur Verfügung

  • Ausführen im Emulator
  • Ausführen auf einem Gerät
  • Exportieren als Android Projekt

Arduino und Processing

[seriesposts name=“Arduino“, orderby=“user_order“]

Das Zusammenspiel von Processing und Arduino eröffnet viele Möglichkeiten.
Am Beispiel einer einfachen Wetterstation möchte ich das verdeutlichen.

Was ganze soll ungefähr so aussehen.

Das zentrale Feld soll je nach Temperatur seine Farbe ändern.

Arduino — Misst die Temperatur

Aufgaben von Arduino (Microkontroller Board)

  • Messen der Temperatur
  • Übermitteln der Messdaten über die serielle Schnittstelle

[js_markieren]

/*
  Measure the Temperature with the Sensor LM35CZ every 1 second
  and write the value to the serial port (format "xx C").

  Author: Wolfgang Wolff
  Date: 27.10.2011
*/

const unsigned int TEMP_SENSOR_PIN = 0;
const float SUPPLY_VOLTAGE = 5000;
const unsigned int BOUD_RATE = 9600;

void setup() {
  Serial.begin(BOUD_RATE);
}

void loop() {
  Serial.print(int(get_temperature()*100));
  Serial.println(" C");
  delay(1000);
}

const float get_temperature() {
  const int sensor_volate = analogRead(TEMP_SENSOR_PIN);
  const float voltage = sensor_volate *(SUPPLY_VOLTAGE / 1024);
  return voltage / 10;
}

Processing — liest die Daten und stellt sie dar

Aufgaben von Processing (PC)

  • Aufbau einer seriellen Verbindung zum Arduino
  • Lesen und Formatierung der Temperaturdaten
  • Ausgabe der aktuellen Temperatur in einem Fenster

[js_markieren]

/**
   Read the temperature over the serial port (Format: "int C")
   and write the Temperature to the Window with changing the backgroundcolor
   of the window center part.

   Author: Wolfgang Wolff
   Date: 27.10.2011
*/
import processing.serial.*;

final int LINE_FEED = 10;
final int BAUD_RATE = 9600;
Serial arduinoPort;

void setup() {
  println(Serial.list());
  arduinoPort = new Serial(this, Serial.list()[0], BAUD_RATE);
  arduinoPort.bufferUntil(LINE_FEED);
  PFont font = loadFont("Courier-20.vlw");
  textFont(font,20);
  size(200,200);
  fill(150);
  rect(0, 0, 200, 200);
  colorTempTable();
}

void draw() {
  fill(150);
  rect(40, 10, 120, 30);
  delay(1000);
  fill(50);
  float temperature = readTemperature(arduinoPort);
  text(temperature +" C",50,30);
  paintTemperature(temperature);
}

float readTemperature(Serial port) {
  final String arduinoData = port.readStringUntil(LINE_FEED);
  float temp = 0.0;
  if(arduinoData != null) {
    final String[] data = split(trim(arduinoData), ' ');
    temp = int(data[0]);
    println(temp);
  }
  return temp/100.0;
}

void paintTemperature(float temp) {
  if (temp < 20.0) {
    fill(0,0,255);
    rect(50, 50, 100, 100);
  }
  if (temp < 25.0 && temp > 20.0) {
    fill(0,255,0);
    rect(50, 50, 100, 100);
  }
  if (temp < 30.0 && temp > 25.0) {
    fill(255,187,13);
    rect(50, 50, 100, 100);
  }
  if (temp >30.0) {
    fill(255,0,0);
    rect(50, 50, 100, 100);
  }
}

void colorTempTable() {
   // draw color table
   fill(0,0,255);
   rect(50,175,25,25);
   fill(0,255,0);
   rect(75,175,25,25);
   fill(255,187,13);
   rect(100, 175, 25, 25);
   fill(255,0,0);
   rect(125, 175, 25, 25);
   // write text
   fill(50);
   text(20,62,195);
   text(25,87,195);
   text(30,112,195);
}

Processing — Einführung

Processing ist eine Open Source Programmiersprache mit zugehöriger integrierter Entwicklungsumgebung, diese ist Java implementiert. Sie ist einem Projekt des Massachusetts Institute of Technology in Boston von Ben Fry (Broad Institute) und Casey Reas (UCLA Design|Media Arts) initiiert worden. Processing ist vom Charakter einer stark vereinfachter Java-Dialekt. Processing erlaubt es Interaktionen und visuelle Elemente zu programmieren, und richtet sich vorwiegend an Gestalter, Künstler und Programmieranfänger.

Vorteile für den Unterricht:

  • Plattformunabhänigkeit (IDE und Applet auffällig auf Windows, Mac OS X und Linux)
  • Vereinfachte Java-Dialekt ermöglicht gute Didaktische Reduktion
  • Einfache und Übersichtliche IDE
  • Open Source Software, d.h. keine Lizenzgebühren

Quelle:
Von der Processing Homepage können verschieden Versionen herunter geladen werden:

Von der Struktur ist ein Processing-Programm ähnlich zu Arduino. Es gibt im wesentlichen
zwei Methoden, die setup()– und draw()-Methode

void setup()
{
 PFont font = loadFont("Courier-20.vlw");
 textFont(font,20);
 size(200,200);
}

void draw()
{
 text("Hello World!", 30,50);
}