Programmiersprachen…

Geht z.Z. durch diverse Linkschleudern, fand ich so schön, dass ich es auch mal zeige:

Arduino Eye-Shield

Jetzt wird der Arduino mit einem Auge ausgestattet: Arduino Eye Shield. Bald ist Weihnachten!

Links am 21.12.2009

Cool, da hab ich grad den Link über den Drohnen-Hack gepostet, da kommt schon die Meldung, dass diese bis 2014 weiterhin unverschlüsselt funken. Das nenn ich mal Patch-Delay ;-) Offensichtlich wussten die Militärs schon seit mehr als einem Jahrzehnt um die jetzt zutage getretene Sicherheitslücke. Sie hielten die Gefahr aber für vernachlässigenswert gering im Vergleich zu den Vorteilen, die die Drohnen den Truppen im Feldeinsatz verschaffen. Na dann!

Der aktuelle Firefox ist jetzt auch weltweit vor dem IE :-). Wundern tuen mich die sagenhaften 0,42% des Opera 9.6.

Intel hat den die neuen Atom-Prozessoren vorgestellt. [X] Mehr Power fürs Netbook jetzt! :-) (Zu den ersten Atom-N450-Netbooks gehören wohl der Asus Eee PC 1005PE und das Acer Aspire One 532)

Auf Telepolis gibt es ein Interview mit David Kahn, dem weltweit führenden Experten für die Geschichte der Verschlüsselungstechnik. Hochinteressant!

Ich habe mich ja schon gefragt, was an Google Wave eigentlich so toll sein soll, hier ist ein Artikel, der das näher beschreibt. Google positioniert Wave als „E-Mail der Zukunft“, denn das System lässt sich ähnlich wie E-Mail nutzen. Ein interessanter und ausführlicher Bericht, mit nettem Fazit: Entweder Wave funktioniert, oder es wird komplett scheitern. Das klingt nach einer realistischen Einschätzung.

I want that!

10 programming languages worth checking out.

Spaß am Programmieren: Programmieraufgaben

Wer Spaß am Programmieren oder Rästeln hat, und gerne kleine algorithmische Aufgaben löst, der wird u.a. hier fündig:

Project Euler: Project Euler is a series of challenging mathematical/computer programming problems that will require more than just mathematical insights to solve. Although mathematics will help you arrive at elegant and efficient methods, the use of a computer and programming skills will be required to solve most problems.

Sphere Online Judge (SPOJ): The SPOJ platform is centered around an online judge system, which serves for the automatic assessment of user-submitted programs.

USA Computing Olympiad

Python Challenge

Hackerboard Programmieraufgaben

Bundeswettbewerb Informatik.

Bitte melden, wer noch mehr kennt!

Links am 17.12.2009

Enigma – Das Geheimnis jetzt auf Heft-DVD von TV Movie.

Drohne is watching you – Hacker zapfen Video-Systeme von US-Drohnen an.

David After Dentist hat 37 Millionen Views, Quelle: Google-Blog.

Hab heute morgen das vorletzte Chaosradio Express gehört, Thema: Mediemkompetenz – mit Tim Pritlove und Torsten Kleinz. Empfehlenswert! Kleinz ist übrigens Schreiberling eines meiner Lieblingsblogs – Real Life – Aus der Welt der Geeks & Nerds.

Der ARD Radio Tatort! – wird wohl mein neuer Begleiter auf dem Weg zu Arbeit.

Grad beim Stöbern im I-Tunes Podcast-Store gefunden: Chemie in 2 Minuten.

Geschenk-Tipps für Geeks: Bananen essen macht Spaß!

Letztens entdeckt: Umberto Eco hat wohl ein neues Buch geschrieben. Das werd ich mir wohl, allein schon weil ich von dem schon so vieles habe, auch mal zulegen.

Falls es jemand noch nicht hat oder mitgekriegt hat – kürzlich erschienen: Thunderbird 3 lohnt sich

Getting started with openFrameworks

Was zum Lesen zu openFrameworks: Getting started with openFrameworks von Stephen Braitsch und das openFrameworks Tutorial Simple Physics (2D) (Mirror) von Sophie van der Sijp und Fin Kingma.

Pixelmanipulation in C++ mit openFrameworks

Grundsätzlich eignet sich C++ mit den openFrameworks-Bibliotheken wunderbar, um Pixel von Bildern auszulesen oder zu manipulieren.

Das geht wie folgt:

ofImage picture;
picture.loadImage("name_of_picture.xxx");
unsigned char *pixels = picture.getPixels();

Jetzt hat man alle Pixel, jeweils mit den drei RGB Farbwerten in pixels, z.b. pixels[0] = (255,255,255). Diese kann man jetzt mit zwei Schleifen zeilen- und spaltenweise durchlaufen, man muss lediglich darauf achten, dass immer drei hintereinanderliegende Werte eine Farbe definieren (RGB). Das könnte wie folgt aussehen:

for (int i = 0; i < picture.height * 3; i ++)
    {
        for (int j = 0; j < picture.width * 3; j ++)
        {
            for (int k = 0; k < 3; k++)
            {
                z = pixels[i * picture.width + j + k];   // z is now a value between 0 and 255
                // Do something with z
            }
        }
    }

Was kann man nun damit anfangen? Meine Kreativität hat jetzt dazu gereicht, ein kleines Programm zu schreiben, dass die Farbe jedes Pixels ausliest und eine HTML-Datei erstellt, die pro Pixel den Buchstaben „a“ in der jeweiligen RGB-Codierung enthält. Leider wird so eine HTML-Datei bei einem 5 Megapixel zig Megabyte groß, was dem Firefox nicht wirklich gut bekommt. Also Bild runterskaliert und nur jeden dritten Pixel beachten.

Dann wird aus: (640×480 Pixel)

diese vom Programm generierte, knapp 10 Megabyte große HTML Datei: (Strg+ lässt das Bild schrumpfen, die Markierung der „a“s soll zeigen, dass es sich um Text handel)

Hier noch das ganze Programm, inklusive einer Funktion zur Kreierung des Hex-RGB-Wertes für das HTML font-Tag:

#include "testApp.h"
#include "stdio.h"
#include <fstream>

ofImage picture;
fstream output;

string int2hex(int decimal)
{
        if (decimal == 0)
        {
            return "00";
        }

        string hex = "";
        int tmp;

        for (int i = 0; i <= 2 * sizeof(int) - 1; i++)
        {
          tmp = decimal >> i*4;
          if (tmp == 0)
            break;
                hex = "0123456789ABCDEF"[(tmp & 0xF)] + hex;
        }

        if (hex.length() == 1) {
            hex = "0" + hex;
        }

        return hex;
}

//--------------------------------------------------------------

void testApp::setup(){

    string color = "";
    picture.loadImage("coffee.jpg");
    output.open("output.html", ios::out);
    int z = 0;
    unsigned char *pixels = picture.getPixels();

    output << "<html><body><small><small><small>" << endl;

    for (int i = 0; i < picture.height * 3; i += 3)
    {
        output << "<nobr><code>" << endl;
        for (int j = 0; j < picture.width * 3; j += 3)
        {
            color = "";
            for (int k = 0; k < 3; k++)
            {
                z = pixels[i * picture.width + j + k];
                color += int2hex(z);
            }

            output << "<font color=\"#" << color << "\">a</font>" << endl;

        }

        output << "</code><\/nobr>" << endl;
        output << "<br>" << endl;

    }

    output << "<\/small><\/small><\/small><\/body><\/html>" << endl;

    output.close();
}

Conway’s Game of Life in C++ (openFrameworks)

Conway’s Game of Life ist eine 1970 entwickelte Simulation eines zellulären Automaten. Auf einer zweidimensionalen Fläche leben Zellen (Pixel) vor sich hin, deren Fort- oder Ableben durch vier Regeln bestimmt wird. Jede Zelle hat acht Nachbarzellen.

1. Tod durch Isolation: Hat eine Zelle weniger als zwei lebende Nachbarzellen, stirbt sie in der nächsten Generation an Einsamkeit.

2. Tod durch Überbevölkerung: Jede Zelle mit vier oder mehr lebenden Nachbarn stirbt in folge von Überpopulation.

3. Neugeburt einer Zelle: Jede tote Zelle (leeres Feld) mit genau drei lebenden Nachbarn wird in der nächsten Generation wiedergeboren.

4. Überleben einer Zelle: Jede Zelle mit zwei lebenden Nachbarn überlebt in die nächste Generation.

Simulieren will ich das ganze mit einem 1024 x 768 Pixel großen Feld und der Programmiersprache C++ in der openFrameworks-Umgebung. Zuerst brauchen wir drei Variablen, die das Feld darstellen. Eine für das aktuelle Feld, eine für das Feld der nächsten Generation und eine temporäre Variable, die für Kopierzwecke benötigt wird. Alle drei Felder sind zweidimensional:

const int width = 1024;
const int height = 768;
int gitter[width][height], gitter_next[width][height], gitter_temp[width][height];

Als nächstes soll das Basisfeld generiert werden. Das mache ich in der setup() Funktion. Die Gesamtanzahl aller Pixel ist 1024 mal 768. Für die Anfangsbevölkerung soll ca. jedes dritte Feld auf 1 (= lebende Zelle) gesetzt werden. Dann wird das Feld durchlaufen und alle auf 1 gesetzten Felder werden gezeichnet. Das mache ich mit ofCircle(x,y,1), da ich das mit dem Pixelsetzen in openFrameworks noch nicht ganz durchschaut habe. ofCircle(x,y,1) setzt also einen Kreis auf die Postion (x,y) mit Radius 1 (= 1 Pixel).

void testApp::setup(){

    float dichte = 0.3 * width * height;

    for (int i = 0; i < dichte; i++)
    {
        gitter[int(rand() % width)][int(rand() % height)] = 1;
    }

    ofBackground(255,255,255);

    for (int x = 0; x < width; x++)
    {
        for (int y = 0; y < height; y++)
        {
            if (gitter[x][y] == 1) {
                ofSetColor(0,0,0);
                ofCircle(x,y,1);
            }
        }
    }
}

Jetzt zur draw() Funktion, die in einer Endlosschleife läuft. Zuerst sollen für jede Zelle alle lebenden Nachbarn ermittelt werden. Dazu schreibe ich eine kleine Funktion:

int zaehle_nachbarn(int x, int y)
{
    int nachbarn = 0;

    if(gitter[x-1][y+1] == 1)
    {
        nachbarn++;
    }
    if(gitter[x-1][y] == 1)
    {
        nachbarn++;
    }
    if(gitter[x+1][y] == 1)
    {
        nachbarn++;
    }
    if(gitter[x+1][y+1] == 1)
    {
        nachbarn++;
    }
    if(gitter[x+1][y-1] == 1)
    {
        nachbarn++;
    }
    if(gitter[x-1][y-1] == 1)
    {
        nachbarn++;
    }
    if(gitter[x][y+1] == 1)
    {
        nachbarn++;
    }
    if(gitter[x][y-1] == 1)
    {
        nachbarn++;
    }
    return nachbarn;
}

Zurückgegeben wird die Anzahl der lebenden Nachbarn. Nun die Hauptengine der Simulation, die draw() Funktion:

void testApp::draw(){

    for (int x = 0; x < width; x++)
    {
        for (int y = 0; y < height; y++)
        {
            int nachbarn = zaehle_nachbarn(x, y);

            if ((gitter[x][y] == 1) && (nachbarn < 2))
            {
                gitter_next[x][y] = 0; // Tod durch Isolation
                ofSetColor(0,0,0);
                ofCircle(x,y,1);
            }
            else if ((gitter[x][y] == 1) && (nachbarn > 3))
            {
                gitter_next[x][y] = 0; // Tod durch Überbevölkerung
                ofSetColor(0,0,0);
                ofCircle(x,y,1);
            }
            else if ((gitter[x][y] == 0) && (nachbarn == 3))
            {
                gitter_next[x][y] = 1; // Drei Nachbarn = Zelle wird geboren
                ofSetColor(255,255,255);
                ofCircle(x,y,1);
            }
            else
            {
                gitter_next[x][y] = gitter[x][y]; // Überlebt
            }
        }
    }

    for (int x = 0; x < width; x++)
    {
        for (int y = 0; y < height; y++)
        {
            gitter_temp[x][y] = gitter[x][y];
            gitter[x][y] = gitter_next[x][y];
            gitter_next[x][y] = gitter_temp[x][y];
        }
    }

}

Für jede Zelle werden die lebenden Nachbarn ermittelt. Dann werden die Regeln angewendet. Zum Schluss wird das aktuelle Feld (gitter) in die temporäre Variable kopiert, das aktuelle Feld mit dem zukünftigen Feld besetzt und das Zukünftige Feld wird das aktuelle Feld.

Fertig!

Das Video zeigt einige Sekunden aus dem Leben der Zellen:

Links:

Quellcode und ausführbare Datei

Es gibt einen sehr schönen Conways Spiel des Lebens Wikipedia-Artikel, der noch ein paar Hintergründe beleuchtet und ein paar sich aus den Zellen entwickelnde Objekte zeigt.

Sieben Google Wave Invitations zu vergeben

Google Wave ist ein in Echtzeit ablaufendes System zur Kommunikation und Zusammenarbeit. Man kann eine „Wave“ starten und andere Benutzer in die Wave einladen. Dann soll diskutiert werden oder an gemeinsamen Projekten und Dokumenten gearbeitet werden. Das ganze erinnert ein bißchen an ein Wiki. Angeblich sind Wave-Einladungen heiß begehrt und gehen bei ebay für bis zu 10 Euro weg. Das System ist zur Zeit beschränkt, es ist lediglich möglich, einen Testaccount anzufordern.

Und weil ich ein Glücklicher bin, der in die Google-Wave-Welt eingeladen wurde und sich mir der Sinn des ganzen noch nicht 100prozentig erschließt, verjubel ich meine Free-Invitations doch gleich hier übers Blog.

Wenn also jemand einen Google-Wave Account haben will und von mir eingeladen werden will, soll sich melden. 7 Einladungen hab ich noch.

Hier noch ein Wave Gadgets Tutorial.

Links am 24. November 2009

Schönes Projekt: Freedroidz – Roboterbau (ab 270 Euro) für jeden. Interview hier.

Am 7. Dezember soll OpenSocial in SchülerVZ, studiVZ und meinVZ starten. Das würde bedeuten, dass, ähnlich wie bei Facebook (Facebook-Freunde), jeder der Lust und Können hat eigene Programme und Erweiterungen für diese sozialen Netzwerke entwickeln könnte. Hier gibt es die Sandbox – developer.studivz.net. Was heißt das? Viele tolle neue Features, jede Menge unnützes Zeug und Sicherheitslücken, die dann gestopft werden wollen ;-)

Schon ein paar Tage alt: Google kündigt Chromium OS als Open Source Projekt an. Heise hat es schon getestet und kommt zu dem Schluss, dass das Betriebssystem kein Ersatz für Windows sein werde, aber durchaus Neues biete. So werden Anwendungen online geladen und in einer Datenwolke (Cloud) im Internet bereitgestellt. Somit werden kaum noch Daten lokal gespeichert, alles online, alles unter „Google-Kontrolle“. Ein Schelm, wer böses dabei denkt. Man hört sogar schon Gerüchte, dass ein kostenloses, mit Chrome betriebenes Netbook geplant sei. Und wie wird das dann finanziert? Mehr: Download the Google Chrome OS Virtual Machine, Google Cheats. Auch brisant: Google attackiert den Mobilfunkmarkt.

Morgen (Mittwoch, 25.11.2009, 22 Uhr) kommt wieder Chaosradio. Dann geht es darum, Wie man als Hacker am Leben bleibt. Mit fefe und Andy Müller-Maguhn.

Ein Augsburgr ist kein Augsburger.

openFrameworks

Heute ist endlich mein über Amazon.de bei einem englischen Händler bestelltes Buch „Programming Interactivity“ von Joshua Noble gekommen :-). Der Untertitel des über 700 Seiten schweren Buches lautet „A Designer’s Guide to Processing, Arduino, and openFrameworks„, also genau das, womit ich mich zur Zeit befasse. Schon beim Stöbern bei Amazon viel mir das äußerst vielversprechende Inhaltsverzeichnis sofort auf.

Aber hier soll es erstmal um die Einrichtung von openFrameworks gehen. Was ist das überhaupt? openframeworks.cc titelt selbst: openFrameworks is an open source C++ toolkit for creative coding. Hört sich schon mal ganz interessant an. Dann wollen wir uns das mal ansehen.

Zuerst benötigen wir einen C++ Compiler für Windows. openFrameworks.cc und „Programming Interactivity“ nennen u.a. Code::Blocks (Open Source). Dieser ist schnell runtergeladen (10,8 + 19,3 MB) und installiert. Zusätzlich werden die Code::Blocks Additions für openFrameworks benötigt. Die includes und libs des ZIP-Files kopieren wir nach C:\Program Files (x86)\CodeBlocks\MinGW.

Nun geht es weiter mit dem eigentlichen openFrameworks. Dieses wird von der openFrameworks Downloadseite heruntergeladen. Damit der Compiler die entsprechenden Dateien auch finden und zuordnen kann, sollte der Inhalt des openFrameworks nach C:\Users kopiert werden.

Das wars, nun kann der Spaß beginnen. Am einfachsten beginnt man immer mit dem Leer-Beispiel, was openFrameworks mitliefert. Das würde sich dann in C:\Users\apps\examples\emptyExample befinden. Ordner z.B. auf den Desktop kopieren und emptyExample.cbp starten (im Regelfall sollte diese Dateiendung dann mit Code::Blocks verknüpft sein). Im Programm werden wir hauptsächlich in der TestApp.cpp programmieren:

Wir sehen verschiedene Funktionen. setup() ist vergleichbar mit der setup() aus Processing oder der Arduino-Umgebung. update() wird vor draw() aufgerufen – draw() ist die Dauerfunktion in openFrameworks, so wie loop() bei Arduino und die gleiche draw() bei Processing. Dann sind noch die häufig benutzten Funktionen zum Abfangen von Tastatur- und Mauseingaben deklariert.

Unser Hallo-Welt-Programm soll einen Kreis darstellen:

#include "testApp.h"
#include "stdio.h"

//--------------------------------------------------------------
testApp::testApp(){

}

//--------------------------------------------------------------
void testApp::setup(){

}

//--------------------------------------------------------------
void testApp::update(){
}

//--------------------------------------------------------------
void testApp::draw(){
    ofSetColor(0,0,0);
    ofFill();
    ofCircle(400,400,200);
}

//--------------------------------------------------------------
void testApp::keyPressed  (int key){
}

//--------------------------------------------------------------
void testApp::keyReleased(int key){

}

//--------------------------------------------------------------
void testApp::mouseMoved(int x, int y ){
}

//--------------------------------------------------------------
void testApp::mouseDragged(int x, int y, int button){
}

//--------------------------------------------------------------
void testApp::mousePressed(int x, int y, int button){

}
//--------------------------------------------------------------
void testApp::mouseReleased(int x, int y, int button){

}

//--------------------------------------------------------------
void testApp::resized(int w, int h){

}

Das Ergebnis ist eine 1.226kb große EXE-Datei, die dieses Ergebnis ausgibt:

Links am 16. November 2009

Creative Coding soll einen Einstieg in die Gestaltung und den kreativen Umgang mit Code mit Hilfe der Programmierumgebung Processing vermitteln.

Local Guru – Blog zu Themen wie Processing uvm., u.a. mit nettem Processing-Tutorial

Neues (In)Secure PDF

Der Ardubot

O’Reilly schreibt fleißig über den Geek Atlas

R/C Lawnmower – cooool!

Processing-Spielerei

Das Bild im Kopfbereich dieses Blogs ist ja bekannt:

Jetzt habe ich mal an einem kleinen Processing-Sketch gearbeitet, um mir ein neues Bild zu erstellen:

PFont font;
String[] data = new String[40]; // Array of 40 strings
int i = 0;

void setup()
{
  noStroke();
  size(800, 200);
  randomSeed(0);
  int zero_or_one = 0;
  for (int h = 0; h < 39; h++) {
    String zero_one_string = "";
    for (int number = 0; number < 100; number++) {
      zero_or_one = int(random(0,2)); // 0 or 1
      zero_one_string = zero_one_string + str(zero_or_one); // create string of 0s and 1s
    }
    data[h] = zero_one_string; // fill array
  }
  font = loadFont("CourierNewPSMT-48.vlw");
  textFont(font);
  textSize(18);
}

void draw()
{
  fill(255 - i*0.25, 255 - i*0.25, 255 - i*0.25);
  rect(i,0,i,height);
  fill(0,0,120);
  int k = 15;
  for (int lines = 0; lines < height/20; lines++) {
    text(data[lines],lines,k);
    k += 20;
  }
  i++;
  for (int z=0; z<5; z++) {
    fill(155-z*10,224-z*30,220+z*10,18);
    ellipse(0,height/2-height/4+z*4,200,200);
  }
}

Der Sketch erstellt ein paar zufällige Strings aus Nullen und Einsen, stellt sie untereinander dar und lässt Weiß- bis Schwarztöne horizontal darüberlaufen. Heraus kommt das hier:

Das nehme ich jetzt auch erstmal als neues Bild im Kopfbereich.

Arduino²: Zwei Arduinos verbinden

Da ich ja mittlerweile zwei Arduinos besitze, einen Arduino Mega sowie den Arduino Duemilanove, liegt es ja nahe, diese einmal miteinander zu verbinden und sie über I²C miteinander kommunizieren zu lassen. Im Sketch wird dazu die Wire.h library benutzt: This library allows you to communicate with I2C / TWI devices. On most Arduino boards, SDA (data line) is on analog input pin 4, and SCL (clock line) is on analog input pin 5. On the Arduino Mega, SDA is digital pin 20 and SCL is 21.

Aber zunächst müssen die beiden Arduinos miteinander vernetzt werden. Das geht wie folgt: Zuerst braucht man einen „Master“ und einen „Slave“, d.h. ein Arduino ist das „Gehirn“, der andere der ausführende „Sklave“ ;-). Weil der Arduino Mega mit seinen 54 digitalen In- und Output Pins, seinen 128kb Speicher sowie sonst auch ziemlich aufgemotzt daherkommt, lassen wir diesen mal den Slave spielen. Er ist an meinem eee PC angeschlossen, während der Arduino Duemilanove an meinem Desktop PC hängt.

Nun werden die beiden Arduinos gemäß diesem Schema miteinander verbunden:

Es ist wichtig, dass die beiden Arduinos ihre Stromkreise teilen, deshalb verbindet man jeweils 5V sowie GND (Ground, Erde) miteinander und setzt zwei Widerstände dazwischen, sonst funktioniert die Kommunikation zwischen den Arduinos nicht. Dann verbindet man die beiden SDA und SCL Pins der Boards miteinander, d.h. Analog In 4 des Duemilanoves mit 20 des Megas sowie Pin 5 des Duamilanoves mit Pin 21 des Megas. Es ergibt sich folgendes Bild:

Ziel des ganzen ist es, ein kleines Netzwerk zwischen den beiden Arduinos aufzubauen, wobei am Duemilanove ein Lichtsensor arbeitet und den jeweils ermittelten Sensorwert an den Arduino Mega sendet. Dieser soll je nach Höhe des Wertes eine LED unterschiedlich hell aufleuchten lassen. Die in die eine Richtung (Duemilanove, Master –> Mega, Slave) übertragenen und vom Lichtsensor ermittelten Werte sollen außerdem im Serial-Fenster angezeigt werden. Die komplette Schaltung sieht dann so aus:

Nun müssen noch zwei kleine Sketche für die beiden Arduinos geschrieben werden. Wie oben bereits erwähnt, bedient man sich dabei der Wire.h-Bibliothek. Zuerst der Master:

#include <Wire.h>

void setup()
{
  Serial.begin(9600);
  Wire.begin(); // join i2c bus
}

int sensorPin = 0;
int sensorValue = 0;

void loop()
{
  sensorValue = analogRead(sensorPin);
  Serial.println(sensorValue);
  Wire.beginTransmission(4); // transmit to device #4
  Wire.send(sensorValue);
  Wire.endTransmission();
  delay(500);
}

Die Datenübertragung läuft über device #4. Dasselbe wird auch im Slave aufgesetzt:

#include <Wire.h>

int led_status = 0;
int ledPin = 13;

void setup()
{
  Wire.begin(4);                // join i2c bus with address #4
  Wire.onReceive(receiveEvent); // register event
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}

void loop()
{
  analogWrite(ledPin, led_status);
  delay(500);
}

// function that executes whenever data is received from master
// this function is registered as an event, see setup()
void receiveEvent(int howMany)
{
  led_status = Wire.receive();
  Serial.println(led_status);
} 

Die Quellcodes der Sketche sind leicht zu verstehen: Im loop() des Masters wird am Analog-Input der helligkeitsabhängige Widerstand des Lichtsensors gemessen, im Serial-Fenster ausgegeben sowie über die Funktion send() der Wire-Bibliothek verschickt. Der Slave bekommt diesen Wert, gibt ihn ebenfalls aus und benutzt den Wert für die analogWrite-Funtkion an die LED.

Abschließend zeigt dieses kurze und wackelige Video, dass das auch tatsächlich funktioniert:

Links
• Connect multiple Arduino microcontrollers using I²C
• I2C / TWI (Two-Wire Interface)
• Die Wire-Library
• Arduino I2C Expansion I/O

Arduino im Netz

Heute kam per Post mein bei Watterott.com bestelltes Arduino Shield – Ethernet. Hierbei handelt es sich um ein zusätzliches Shield für den Arduino Duemilanove, das man einfach auf den Arduino steckt. Auf dem Shield befindet sich ein Netzwerkkabelanschluss (RJ45):

Shield also draufgesteckt und erstmal angeschlossen. Dann Arduino.cc – EthernetShield angesehen und die Referenz zur Bibliothek studiert.

Herausgekommen ist ein kleiner Sketch, der dem Arduino die IP 192.168.2.20 im lokalen Netzwerk zuordnet und den Arduino als Server fungieren lässt:

#include <Ethernet.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192, 168, 2, 20 };

Server server(80);

void setup()
{
  Ethernet.begin(mac, ip);
  server.begin();
}

void loop()
{
  Client client = server.available();
  if (client) {
    server.print("Und der Arduino ist im Netz...");
  }
  delay(10);
  client.stop();
}

Bei der Wahl der MAC- und IP-Adresse sollte man darauf achten, keine Konflikte im lokalen Netz zu erzeugen. Also erstmal auf „Upload“ gedrückt. Dieser dauert gefühlt ein wenig länger als bei Offline-Sketches.

Arduino pingt jedenfalls schon mal zurück:

Nun mal schauen, ob auch im Browser was zu sehen ist:

Um den Arduino mit der dem Heimnetzwerk von dessen Provider im Internet zugewiesenen IP-Adresse anpingen und -surfen zu können, muss jetzt noch je nach Router ein NAT (=Network Address Translation) eingerichtet werden, so sieht das z.B. beim Telekom-Speedport aus: