programmieren « WordPress.com Tag Feed

Pixelmanipulation in C++ mit openFrameworks

netzwelten — Mon, 30 Nov 2009 20:18:12 +0000

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)

netzwelten — Sun, 29 Nov 2009 09:20:58 +0000

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.

Es kann YouTube

nkreipke — Wed, 25 Nov 2009 21:25:43 +0000

TubeFlect kann ab heute doch tatsächlich schon mal das Grundlegende, was es können muss: YouTube-Videos abspielen. Das soll vorerst nur als Test laufen, weshalb das Layout auch noch nicht perfekt aussieht. Wie es funktioniert: Man nehme einen handelsüblichen YouTube-Link, kopiere ihn in das Textfeld und klickt auf “Load Video”. TubeFlect schnappt sich daraufhin den Flashplayer aus der YouTube-Seite und lädt ihn im Fenster. Das beste daran: Da er die Elemente rund um den Flash-Player nicht laden muss, geht der Ladeprozess schneller als auf konventionelle Methode – ein Pluspunkt für Leute mit schwachen Internetleitungen.

Somit haben wir schon mal einen Grundstein gelegt für eines der Prioritäten von TubeFlect: Das schnelle Laden von Videos. Den Text und vor allen Dingen die Werbung drumherum, die immer zuerst geladen werden, werden jetzt elegant übersprungen.

Zum ersten Mal kann man jetzt schon die Grundidee von TubeFlect sehen: Das Video im Mittelpunkt. Wie gesagt, alles erstmal nur ein Test, das Layout des Videobrowsers gefällt uns auch nicht Zum Screenshot: Die YouTube-Suche funktioniert noch nicht, die Buttons in der Menüleiste auch nicht. Die letzten Probleme mit der Navigationsleiste sind behoben, so wird sie vorerst bleiben. Der Vollbildmodus vom VouTube-Video funktioniert selbstverständlich und auch maximieren kann man die Geschichte schon. Die 4 Favoritenordner hab ich mit dem Plusbutton hinzugefügt, das funktioniert also auch schon gut.

Wir haben heute zusätzlich zum Browser auch unter der Haube ein paar Sachen geändert. Der Quelltext ist insgesamt kleiner geworden, es wird nicht mehr durch unnötige Variablen Speicher verbraucht. Auf dem Screenshot seht ihr übrigens FileMerger, ein Hilfsprogramm mit dem man 2 Dateien miteinander vergleichen kann. Rechts ist die alte Version des FolderListControllers, links die neue Version.

Zum Schluss noch 2 Sachen: Erstens sieht man, dass wir wirklich nur träge weiterkommen. Das liegt daran, dass wir täglich wegen dem Schulstress momentan nur maximal 2 Stunden pro Tag Zeit für TubeFlect haben. Außerdem bin ich noch nicht gerade der Profi in Sachen Cocoa-Programmierung und Obi versteht nur Bahnhof vom Quelltext

Außerdem möchte ich demnächst einen zweiten Blog eröffnen, der sich nur um TubeFlect kümmert. Ich möchte diesen Blog weiterhin als Privatblog behandeln und nicht mit Changelogs vollstopfen. Ich sage euch bezüglich der Änderung rechtzeitig bescheid.

Recoding

nkreipke — Tue, 24 Nov 2009 21:32:17 +0000

Wie es der Teufel so wollte, habe ich gemeinsam mit Obi das Grundgerüst von TubeFlect neugeschrieben. Also kompletter Neustart mit neuer, leerer Projektdatei. Durch das Recoding haben wir einige Probleme behoben und solche, die noch kommen sollten, direkt verhindert:

Alle Controls wurden getaggt und ausreichend mit Identifiers versehen.
Copy-Paste ist wieder möglich.
Wir haben direkt mit 2 TableViews angefangen, und so konnten wir das bestehende Problem mit dem Löschen und Editieren der Hauptkategorien beheben.

Ansonsten sind wir eigentlich auf dem Stand von gestern. Dafür gibbet auch noch mal eine größere Auswahl von momentanen Screenshots:

openFrameworks

netzwelten — Sat, 21 Nov 2009 14:30:59 +0000

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:

Buch-Rezension zu "Systemarchitekturen für Verteilte Anwendungen"

Johnny Graber — Thu, 19 Nov 2009 19:30:21 +0000

Die steigenden Anforderungen an aktuelle Software benötigen entsprechend flexible Lösungen. Herausforderungen wie Skalierbarkeit oder Ausfallsicherheit hofft man mit verteilten Systemen lösen zu können. Doch wo soll man starten? Was für Möglichkeiten gibt es und wie kann man die unzähligen Begriffe und Konzepte einordnen?

Diese und weitere Fragen versucht das Buch “Systemarchitekturen für Verteilte Anwendungen” von Jürgen Dunkel, Andreas Eberhart, Stefan Fischer, Carsten Kleiner und Arne Koschel zu beantworten. Eine kurze Einführung über Software-Architektur und eine Erklärung der grundlegenden Begriffe dient als Start in die Welt der verteilten Anwendungen.

Diese Konzepte werden im 2. Teil vorgestellt:

Um ein Gefühl dafür zu bekommen wird jeweils eine Erklärung des Architekturkonzepts, eine Übersicht zu den Realisierungsplattformen und Code-Beispiele geliefert.

Teil 3 behandelt die Auswahl einer konkreten Architektur. Die im zweiten Teil vorgestellten Konzepte werden wieder aufgenommen und auf die Anforderungen aus dem Softwarelebenszyklus hin untersucht. Dies umfasst die Problemanalyse, das Design, die Implementierung und Test, sowie den Betrieb und die Wartung.
Die Fallbeispiele aus der Praxis reichen vom LAMP-Stack über den PetStore von Java EE bis hin zum Grid des CERN für den LHC (Large Hadron Collider).

Als Abschluss dient ein Ausblick auf Software as a Service (SaaS), Virtualisierung und Cloud Computing.

Stärken und Schwächen
Ein so komplexes und grosses Thema auf weniger als 300 Seiten näher zu bringen ist eine grosse Herausforderung. Es gelingt den Autoren einem einen guten Überblick zu verschaffen und hilft dabei, die unzähligen Begriffe einordnen zu können. Die Stärken des Buches liegen eindeutig bei den allgemeinen Erklärungen.

Bei den konkreten technischen Umsetzungen fällt die Qualität aber stark ab. Die Code-Beispiele sollen zeigen wie das Beschriebene konkret umgesetzt wird. Allerdings sind diese viel zu kurz und wenn man sich nicht bereits mit dem Thema auseinander gesetzt hat wird man kaum verstehen, was da nun gezeigt wird. Die Seitenlangen XML-Dokumente helfen da auch nicht weiter.

Die Formatierung ist sehr gewöhnungsbedürftig. Alle Leerzeichen in den Strings werden konsequent markiert – auch dann wenn diese nur zum einrücken dienen und über die halbe Seite gehen. Dafür fehlt bei Befehlszeilen der Hinweis, dass der Zeilenumbruch dem Layout geschuldet ist und man den Befehl als eine Zeile eingeben muss.

Auch sehr gewöhnungsbedürftig ist die Art, wie auf weiterführende Literatur verwiesen wird. Als Beispiel die Einleitung des Architekturkonzepts der Grid Architekturen:

Als Geburtsstunde des Grid Computing wird üblicherweise das Jahr 1998 mit dem Erscheinen des Werkes [25] genannt.

Möchte man wissen welches Buch gemeint ist, bleibt einem nichts anderes übrig als zum Literaturverzeichnis zu blättern. Dies ist leider kein Einzelfall.

Die grosse Anzahl der Autoren bemerkt man bei den Erklärungen der Begriffe. Teilweise wird sehr grosszügig damit umgegangen und dann wiederum werden Abgrenzungen gemacht, die mit der Praxis kaum noch etwas zu tun haben.

Die Fallbeispiele sind eine Enttäuschung. Der LHC an sich ist spannend, doch wer braucht eine vergleichbare Lösung? Und ist die Demo-Applikation PetShop wirklich erwähnenswert? Mehr Beispiele aus der Praxis die einer grösseren Leserschaft bekannt sind (wie Amazon) hätten da besser gepasst.

Fazit
Das Buch ist gut geeignet um einen Überblick über das Thema der verteilten Anwendungen zu bekommen. Wer allerdings an der technischen Umsetzung interessiert ist, sollte sich nach einem anderen Buch umschauen.

Zum Buch
Systemarchitekturen für Verteilte Anwendungen, von Jürgen Dunkel, Andreas Eberhart, Stefan Fischer, Carsten Kleiner und Arne Koschel, 2008 HANSER, ISBN 978-3-446-41321-4, 293 Seiten

[Tutorial]TI89Titanium: Programmieren eines Spiels |Teil 2|

ceecilion — Tue, 17 Nov 2009 19:04:14 +0000

Teil 1|-

TEIL 2: Das Grundgerüst

Wir müssen erstmal eine “Oberfläche” Herstellen. Ein Inhaltsloses Programm, das sich immer wieder wiederholt, bis es den Endbefehl vom Benutzer bekommt.Die einfachste Art, das hinzukriegen, ist es zuerst eine Variable für die Tasten zu Definieren und das Programm in einer While-schleife laufen lassen, bis Escape registriert wird. Das sollte dann so aussehen:

Spiel1()
Prgm
o➝key
While key≠264[Escape]
Getkey➝key
Endwhile
Endprgm

Dieses Programm läuft nun in einer endlosschleife, bis wir Escape drücken.
Als vereinfachte Version eines Chars nehmen wir einfach mal einen Kreis. Dazu DEfinieren wir seine Y- und seine X-Position in Variablen und zeichnen ihn.

Spiel2()
Prgm
o➝key
15➝Cy
17➝Cx
While key≠264[Escape]
Getkey➝key
Pxlcircle Cy,Cx,15
Endwhile
Endprgm
nun soll sich unser Char aber auch bewegen können. Da die Tasten schon abgefragt werden, müssen wir also nurnoch die veränderung der Variabeln einsetzen.

Spiel3()
Prgm
o➝key
15➝Cy
17➝Cx
While key≠264[Escape]
Getkey➝key
Pxlcircle Cy,Cx,15
if key=344 then
Cy+5➝Cy
Endif
if key=338 then
Cy-5➝Cy
Endif
if key=340
Cx+5➝Cx
Endif
if key=337 then
Cx-5➝Cx
Endif
Endwhile
Endprgm

Das geht natürlich sehr viel eleganter, aber dazu kommen wir später.
Jetzt bewegt sich unser Kreis zwar, aberer zieht eine Lange Spur hinter sich her. um die Verschwinden zu lassen, reinigen wir einfach den Screen bei jedem Durchlauf.

Spiel4()
Prgm
o➝key
15➝Cy
17➝Cx
While key≠264[Escape]
ClrDraw
Getkey➝key
Pxlcircle Cy,Cx,15
if key=344 then
Cy+5➝Cy
Endif
if key=338 then
Cy-5➝Cy
Endif
if key=340 then
Cx+5➝Cx
Endif
if key=337 then
Cx-5➝Cx
Endif
Endwhile
Endprgm

So. Das Grundgerüst des Spiels steht.
beim nächstem mal behandeln wir die grobere Spielmechanik

Sequel Pro - MySQL Management

Allan — Tue, 17 Nov 2009 17:56:41 +0000

Da war ich wieder mal auf der Suche nach allem und finde ganz was besonderes. Ich hatte schon ein an

Processing-Spielerei

netzwelten — Sat, 14 Nov 2009 20:09:09 +0000

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

netzwelten — Sat, 14 Nov 2009 12:21:28 +0000

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

Arduino im Netz

netzwelten — Thu, 12 Nov 2009 19:10:41 +0000

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:

Temperatur messen mit Arduino Teil 2

netzwelten — Tue, 10 Nov 2009 20:04:31 +0000

Nachdem ich in diesem Artikel ausführlich beschrieben habe, wie man mit dem Arduino Temperaturen messen kann, habe ich heute, nach dem ich freudig die neuen Bauteile vom Postboten gebracht bekommen habe, eine neue Möglichkeit ausprobiert.

Bestellt habe ich bei Watterott.com einen LM35 CZ Temperatursensor TO92. Schnell ins Datenblatt geschaut und die Anschlüsse herausgefunden.

Calibrated directly in ° Celsius (Centigrade)
Linear + 10.0 mV/°C scale factor
0.5°C accuracy guaranteeable (at +25°C)
Rated for full −55° to +150°C range
Suitable for remote applications
Low cost due to wafer-level trimming
Operates from 4 to 30 volts
Less than 60 μA current drain
Low self-heating, 0.08°C in still air
Nonlinearity only ±1⁄4°C typical
Low impedance output, 0.1 W for 1 mA load

Unter “Typical Applications” ist als einfachste eine Anwendung zu finden, bei der man Vs mit dem 5V-Anschluss am Arduino, Ground mit GND und den mittleren Output-Pin am LM35 mit einem Analog-In am Arduino verbindet.

Nun zur Theorie:

Der Arduino liefert laut Hersteller 5V. Mit dem Multimeter habe ich damals ja 4,76V gemessen, so dass ich einfach mal mit beidem rechne.

5/1023 oder 4,76/1023 (denn 1023 entspricht vollen 5 bzw. 4,76 Volt) ergibt 0,0048875855327468 bzw. 0,004652981427175. D.h. ein Messwert von 1 liefert ca. 5mV. Bei einem Sensor-Wert von 13 sind das 63,53 bzw. 60,48 Millivolt, was der Temperatur von 6,35 oder 6,05 Grad Celsius entspricht – je nach Messansatz.

Hier die Arduino-Schaltung:

Das Bild ist draußen auf meinem Balkon aufgenommen und die Temperatur zeigt ca. 8° Grad Celsius an. Und hier der Serial-9600 Output aus meinem Arduino-Sketch:
Messwert: 17 Grad: 8.31 Grad genau: 7.91

Und hier noch der Sketch:


const int analogInPin = 0;
int sensorValue = 0;
float Volt = 0.0;
float Volt_genau = 0.0;

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

void loop() {
  sensorValue = analogRead(analogInPin);
  Serial.print("Messwert:\t");
  Serial.println(sensorValue);
  Volt = sensorValue * 0.48875855327468;
  Volt_genau = sensorValue * 0.4652981427174976;
  Serial.print("Grad:\t");
  Serial.println(Volt);
  Serial.print("Grad genau:\t");
  Serial.println(Volt_genau);
  delay(500);
}

Die Tage werde ich dann mal eine schöne 24h-Temperaturkurve mit dem Output und OpenOffice erstellen.

Arduino: Testen der RGB-LED

netzwelten — Mon, 09 Nov 2009 20:27:18 +0000

Das fleißige Bauelemente-Testen geht weiter. Heute muss die RGB-LED – auch die gabs bei Conrad (2,98 €) – dran glauben.

Eine RGB-LED hat drei LED-Kristalle, Rot, Grün und Blau. Die Anschlüsse habe ich dieser recht undeutlichen Zeichnung entnommen, die ich irgendwo gefunden habe:

Nun bauen wir die Schaltung und schreiben einen kleinen Sketch:

Da ich nur ein Potentiometer zur Hand habe, entscheide ich mich, Grün auf 127 und Blau auf 255 zu setzen und nur Rot mittels Potentiometer zu steuern.


int sensorPin = 0;
int ledPinRot = 4;
int ledPinBlau = 5;
int ledPinGruen = 6;
int sensorValue = 0;  

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

void loop() {
  sensorValue = analogRead(sensorPin);
  Serial.print(sensorValue);  // Debug

  analogWrite(ledPinRot, sensorValue/4);
  analogWrite(ledPinGruen, 127);
  analogWrite(ledPinBlau, 255);  

  delay(10);
}

Das Ergebnis ist eine nette Stimmungsleuchte, die blau/lila-rotes Licht erzeugt:

Arduino: Erste Versuche mit dem Servomotor

netzwelten — Sun, 08 Nov 2009 19:10:05 +0000

Ich habe mir schon vor einiger Zeit einen Servomotor bei Conrad gekauft. Jetzt bin ich endlich mal dazu gekommen, das Teil auszuprobieren.

Dazu habe ich das Beispiel aus Arduino genommen:


#include <Servo.h> 

Servo myservo;  // create servo object to control a servo 

int potpin = 0;  // analog pin used to connect the potentiometer
int val;    // variable to read the value from the analog pin 

void setup()
{
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object
} 

void loop()
{
  val = analogRead(potpin);            // reads the value of the potentiometer (value between 0 and 1023)
  val = map(val, 0, 1023, 0, 179);     // scale it to use it with the servo (value between 0 and 180)
  myservo.write(val);                  // sets the servo position according to the scaled value
  delay(15);                           // waits for the servo to get there
}

Kurz gesagt wird vom Analag-Pin 0, der mit einem Potientiometer verbunden ist, ausgelesen. Der hier erhaltene Wert zwischen 0 und 1023 wird auf die 0 bis 180, die der Servomotor nutzt, umgerechnet. Den Servomotor schließt man wie folgt an: GND (braun oder schwarz) wird mit GND auf dem Arduino verbunden, VDD (rot) mit 5V und SIGNAL mit Pin9 (PWM).

Hier die Schaltung:

Wenn man nun am Potentiometer dreht, bewegt sich die am Servomotor befestigte Fahne hin und her. Fein!

Anwendungsbeispiel: Die Fahne soll sich hin und her bewegen, sobald eine E-Mail erhalten wurde o.ä..

Links:

Arduino Artikel aus der c’t, der sich auch mit Servomotoren beschäftigt

Buch-Rezension zu "The Art of Unit Testing"

Johnny Graber — Sun, 08 Nov 2009 12:45:32 +0000

“The Art of Unit Testing” von Roy Osherove ist im Mai 2009 bei Manning erschienen. Das Buch behandelt Unit Testing in C#.

Zum Inhalt
Kapitel 1 zeigt die Basis von Unit Tests. Diese umfasst eine Definition der Begriffe, eine kurze Einführung zu Test-Driven Development (TDD) und eine Abgrenzung gegen Integrationstests. Den nicht alles, was sicht Unit Test nennt, ist auch wirklich einer.

Kapitel 2 hilft einem durch den ersten Unit Test. Nach der Auflistung der Vorteile die ein entsprechendes Test-Framework bringen folgt ein Rundgang durch NUnit. Dieser reicht von der Installation über die Einrichtung eines Test-Projekts zu Namenskonventionen bis hin zur Ausführung der Tests.

Wie man mit Stubs die Abhängigkeiten aufbrechen kann wird in Kapitel 3 gezeigt. Das Beispielprojekt hat zu beginn eine direkte Abhängigkeit zum Dateisystem. In 2 Schritten wird der Code so umgebaut, dass die Abhängigkeit aufgelöst werden kann. Mit einer kleinen Hilfsklasse, dem Stub, kann man dann genau die Antwort zurück liefern, die man für den Test der Übergeordneten Klasse benötigt. Dies kann in dem Beispiel sowohl ein Boolean sein wie auch eine Exception des Dateisystems.
Es folgt ein Abstecher ins Thema Dependency Injection. Denn der Stub, aber auch die konkrete Klasse mit der Logik, muss ja mit der aufrufenden Klasse verbunden werden. Es werden die Vor- und Nachteile der jeweiligen Ansätze dargelegt, damit man selber das zu seinem Problem passende auswählen kann.

Kapitel 4 zeigt wie man mit Mock Objekten die Interaktion mit der zu testenden Klasse prüfen kann. Mit einem selbst geschriebenen Mock wird das Prinzip erklärt, bevor in Kapitel 5 das Mock-Framework Rhino Mocks erklärt wird. Eine Übersicht der anderen verbreiteten Frameworks (wie TypeMock, NMock und NUnit.Mocks) rundet das Kapitel ab.

Die Organisation von Tests, Test Patterns und Continuous Integration bilden das Kapitel 6, während Kapitel 7 die Qualität der Tests behandelt. Lesbarkeit und Verständlichkeit sind Dinge, die auch bei Tests bedacht werden müssen.

Kapitel 8 hilft bei der Integration von Unit Tests in die Firma. Hierbei geht es nicht um die technische, sondern um die organisatorische Ebene. Osherove berichtet über seine Erfahrungen und liefert Antworten zu häufig aufkommenden Fragen und Problemen.

Wie man mit Legacy Code arbeiten kann zeigt Kapitel 9. Grosse Projekte ohne wirkliche Unit Tests benötigen spezifische Vorgehensweise. Auch hier werden Vor- und Nachteile der Ansätze aufgezeigt. Der Einsatz von Tools kann einem auch hier das Leben erleichtern. Depender oder NDepend können Abhängigkeiten anzuzeigen, was als Ausgangslage für Unit Tests dienen kann. Für Java Entwickler werden die Tools JMockit (vergleichbar mit TypeMock) und Vise erwähnt.

Design und Testbarkeit werden noch einmal ausführlich im Anhang A behandelt. Anhang B bietet eine kompakte Auflistung von Tools und Frameworks aus allen Bereichen von Tests.

Fazit
Ein sehr gutes Buch zur Kunst des Unit Testings. Auf rund 300 Seiten erfährt man unzählige Möglichkeiten zum sauberen testen. Das Buch richtet sich eher an Leser mit Erfahrungen im Bereich Unit Testing. Für Anfänger mag sich nicht immer erschliessen, worin die Vorteile der jeweiligen Ansätze liegen. Hat man sich aber mit den Problemen selber herumgeschlagen, braucht es nicht mehr viele Worte. Ich fand das Buch eine ideale Ergänzung zu Test Driven.
Der Anhang A hätte ein eigenes, „richtiges“ Kapitel verdient und einige Grafiken hätte man nochmals überarbeiten können. Davon abgesehen ist das Buch sehr gut.

Zum Buch
The Art of Unit Testing with Examples in .NET von Roy Osherove, 2009 Manning, ISBN 978-1-933988-27-6, 320 Seiten

Übersicht über Java Collections

dedeibel — Fri, 06 Nov 2009 11:27:43 +0000

Ein Kollege hat heute einen Link zu einer schönen Übersicht über die Standard Java Collections herumgeschickt.

http://www.torsten-horn.de/techdocs/java-collections.htm

Unreal Engine 3 - Kostenlos

Allan — Thu, 05 Nov 2009 18:44:27 +0000

Einfach nur toll. Unreal Engine 3 kostenlos. Das muss man sich mal auf der Zunge zergehen lassen. In

Java arrived!

r0m — Wed, 04 Nov 2009 13:42:07 +0000

Hallo zusammen, es ist eine Zeit her, dass das letzte Mal hier im Blog von mir was veröffentlicht wu

Macheist 4 - Countdown Widget

Allan — Sat, 31 Oct 2009 09:49:02 +0000

Dann will ich mal mein Countdown Widget vorstellen. Nichts besonderes nur damit man nichts ve

Kurze Einführung in die die Programmiersprache Processing

netzwelten — Fri, 30 Oct 2009 19:41:03 +0000

Processing is an open source programming language and environment for people who want to program images, animation, and interactions. It is used by students, artists, designers, researchers, and hobbyists for learning, prototyping, and production. It is created to teach fundamentals of computer programming within a visual context and to serve as a software sketchbook and professional production tool. (Quelle: processing.org)

Mehr will ich dazu vorerst gar nicht sagen. Processing macht jedenfalls Spaß – eine Menge Spaß. Processing ist auch die – der Syntax nach C ähnliche – Programmiersprache der Arduino-Umgebung. Es ist eine recht einfach zu erlernende Sprache für Leute, die ihre Entwürfe (Sketches) schnell ausprobieren und sich so z.B. durch Bilder, Animationen oder kurzen Programmen ausdrücken und verwirklichen wollen.

Die hier vorgestellte Einführung richtet sich an Menschen mit wenig (aber vorhandener) Programmiererfahrung. Begriffe wie Variablen oder Schleifen sollten bekannt sein.

1. Download, Installation und Entwicklungsumgebung

Processing kann auf der Processing Homepage runtergeladen werden. Verfügbar ist es im Moment in der Version 1.0.9 für Windows, Linux und Mac OSX.

Zur Installation muss nicht viel gesagt werden. ZIP-Datei laden und entpacken, eine Installation an sich ist nicht notwendig. Einfach die Anwedungsdatei processing.exe starten. Es erscheint die IDE (Integrated Development Environment – Entwicklungsumgebung):

Die Symbole sind auch selbsterklärend. Den (halb-)fertigen Sketch startet man mit dem “Play”-Button, das Quadrat symbolisiert “Stop”, dann gibt es noch “New”, “Open”, “Save” und “Export”. Zu der Export-Funktion gibt es noch einen Satz zu sagen: Klickt man auf den Button wird eine HTML-Seite mit eingebettetem Java-Applet generiert, das den Sketch enthält.

2. Hallo Welt


line(10,20,30,40);  // Eine Linie

Das obligatorische “Hallo Welt”-Programm erstellen wir in Processing mit dem line() Befehl, der eine Linie zeichnet. Diese verläuft von den Koordination (10,20) nach (30,40). Die Koordinate (0,0) ist übrigens links oben.

Auf “Run” klicken und wenige Millisekunden später erscheint das Programm, dass eine simple Linie zeichnet, auf dem Desktop

// leitet übrigens, wie in vielen anderen Programmiersprachen, einen Kommentar ein. Alles was danach kommt, wird von Processing ignoriert. Multi-Line-Comments werden mit /* eingeleitet und mit */ abgeschlossen.

3. Programmstruktur

In Processing gibt es zwei Hauptfunktionen: setup() und draw(). Der Code in der setup()-Funktion wird beim Starten des Programms ausgeführt (z.B. um Variablen zu initialisieren), der Code in draw() läuft kontinuierlich.

Beispiel:


void setup() {
  size(300,300);
}

void draw() {
  background(105);
  float x = mouseX;
  float y = mouseY;
  line(x,y,x+40,y-80);
}

Kommentare habe ich mal weggelassen, hier die Erklärung:

In setup() wird mit size() die Bildgröße von 300 mal 300 Pixeln festgesetzt.

Der draw()-Teil läuft kontinuierlich. Hier werden die float-Variablen x und y mit der aktuellen Mauscursorposition geladen. Dann wird die Linie gezeichnet. Bewegt man die Maus, verschiebt sich die Linie. Der Grund, wieso die background()-Farbe immer wieder neugesetzt wird, leuchtet ein, wenn man den Befehl in die setup()-Funktion läd und sich obigen Screenshot vor Augen führt.

4. Die Variablen

In Processing gibt es verschiedene Datentypen, wie: int (Integer), float (Fließkommazahl) oder boolean (true/false).

int[] feld = new int[20] deklariert und kreiert ein Feld (Array) von [0..19].

5. Die Konsole, oder: “Hallo Welt 2″

Im unteren Bereich der Processing-IDE sieht man die Konsole. Hier schreibt man mittels print() oder println() Werte rein, um z.B. nichtgrafische Rückmeldungen vom Programm auszugeben:

6. Weitere Grafikbefehle zum Ausprobieren

point(x, y)
triangle(x1, y1, x2, y2, x3, y3)
quad(x1, y1, x2, y2, x3, y3, x4, y4)
rect(x, y, width, height)
ellipse(x, y, width, height)
bezier(x1, y1, cx1, cy1, cx2, cy2, x2, y2)

7. Formen Eigenschaften geben

fill() setzt die Füllfarbe für Formen, stroke() die Außenlinienfarbe. Ein zweiter Parameter gibt die Transparenz an. smooth() aktiviert Antialiasing, noSmooth deaktiviert es wieder.

8. Rechnen mit Processing

Wie auch in anderen Programmiersprachen gibt es verschiedene Wege Werte zu verändern. +, -, *, /, % (modulo). ++ erhöht die Variable um 1, — verkleinert sie um 1. += addiert einen Wert zu einer Variablen hinzu und weist der Variable dann den neuen Wert zu. Äquivalent dazu -=, *=, /=.

9. Entscheidungen

Will man den Kontrollfluss überprüfen, gibt es folgendes Konstrukt:


if (test) {
code;
}

Beispiel:


int y = 3;
int x = 5;
if (x &gt; y) {
  wird erfüllt;
} else {
  sonst-Bedingung. Wird hier nicht erfüllt
}

Um Werte zu Vergleichen gibt es Operatoren wie , =, AND, OR, NOT, !.

10. Schleifen

Hier ähnelt Processing C ebenso. Beispiel:


for (int i = 10; i &lt; 100; i += 2) {
  tue etwas;
}

11. Hüpfe, Ball!

Mit dem vorhandenen Wissen wollen wir nun etwas experimentieren:


int window_size_x = 1024;
int window_size_y = 768;

boolean circle_direction = false; // 0 = left, 1 = right
float circle_point_x = 140;
float circle_point_y = 140;
int circle_d = 50;
float speed_x = 10.0;
float speed_y = 10.0;
float direction_x = 1;
float direction_y = -1;

void setup() {
  randomSeed(millis());
  size(window_size_x,window_size_y);
}

void draw() {

  frameRate(50);
  background(204);

  ellipse(circle_point_x,circle_point_y,circle_d,circle_d); // Kreis zeichnen

  circle_point_x += speed_x * direction_x;
  circle_point_y += speed_y * direction_y;

  if (direction_x > 0) {
    circle_point_x--;
  }
  else {
    circle_point_x++;
  }

  // Kollisionen

  if ((circle_point_x >= window_size_x - circle_d/2) || (circle_point_x <= circle_d/2)) {
    direction_x = -direction_x;
  }

  if ((circle_point_y >= window_size_y - circle_d/2)  || (circle_point_y <= circle_d/2)) {
    direction_y = -direction_y;
  }
}

Und hier das Ergebnis:

12. Schlusswort

Das ist natürlich längst nicht alles, was Processing bietet. Ich wollte hiermit auch nur kurz eine Einführung und einen kleinen Überblick über einige Möglichkeiten geben. Wer tiefer in die Materia einsteigen will (lohnt allein schon wegen Arduino), dem empfehle ich die Processing Website sowie dieses Buch:

Processing: A Programming Handbook for Visual Designers and Artists
von Casey Reas und Ben Fry

Gebundene Ausgabe: 736 Seiten, gebunden
Verlag: The Mit Press
Sprache: Englisch
ISBN-10: 0262182629

Preis: Ca. 45 Euro

Unity 2.6 - Kostenlos

Allan — Fri, 30 Oct 2009 14:21:57 +0000

Unity 2.6 – True cross-platform game development, optimized. SAN FRANCISCO, CA – October

Endlich mal wieder was tippseln!

wint0r — Mon, 26 Oct 2009 19:48:45 +0000

Für die Leute die meinen Blog verfolgt haben tut es mir wirklich leid,dass so lange nichts kam – jede Menge Stress in der Schule,dann privat einiges was sich verändert hat,und wenn ich dann Zeit hatte war ich einfach zu müde,euch was schönes zu tippen.Das vor einiger Zeit versprochene Bashskript reiche ich hiermit nach,und danach werde ich mich der neuen Version von Ubuntu,9.10 oder auch “Karmic Koala”,zuwenden.(Dessen Release ich als religiösen Feiertag zelebrieren werde!)
Wie in meinem letzten Kurzartikel erwähnt gibt euch dieses Script genaue Informationen über Prozesse,deren Speicherbelastung und über angeschlossene USB Geräte.

#!/bin/bash chmod 755 echo "Na dann sehen wir uns mal an,was wir an Speicherplatz haben:" df -m -T echo "So,und nun noch einige kleine Infos,was alles an Arbeitsspeicher belegt wird:" ps -a -m echo "Angeschlossene USB-Geräte:" lsusb echo "Verbaute PCI - Slots:" lspci

Einfach per Konsole ausführen;wer möchte kann sich das ganze auch als Cronjob umschreiben – Hilfestellung hierzu kann ich leider keine bieten,da ich mich nur spielerisch mit der Programmierung in Bash beschäftigt habe und selbst nur mit Mühe einen selbigen hinbekommen konnte.Nun widme ich mich allerdings einem Blick auf Ubuntu 9.10 dass am 29.10 erscheinen wird.Ich kann es jetzt kaum noch erwarten (und lade mir deshalb gerade das Daily Release herunter,aber gehen wir einfach davon aus,dass ich es noch nicht teste!) und drum schaue ich mal,was sich seit 9.04 so getan hat.Ganz sicher ist schon einmal,dass Ubuntu in der neuen Version Änderungen aller Größenordnungen mit sich bringt.Die drei wichtigsten Ziele wurden stellvertretend von der Ubuntu Foundation zusammengefasst.(Bezieht sich auf die Desktopedition!):

Verbesserte Nutzerfreundlichkeit
Mehr Informationen für den Benutzer
Geschwindigkeitsverbesserungen bei alltäglichen Arbeiten

Diese Nutzerfreundlichkeit soll vor allem durch die erweiterte Dokumentation der Programme sowie einer intuitiveren Menüführung erreicht werden – doch einen wirklich großen Fehler begingen die Entwickler,in dem sie alle Icons aus dem Menü entfernten,”to increase the overview for normal users”.Das ganze sorgte für einen ziemlichen Aufschrei in der deutschssprachigen – und sicherlich auch über dem Ärmelkanal und dem Atlantik – Gemeinde,da niemand die Logik hinter dem ganzen Verstand.Es ist zwar möglich die Icons nachträglich zu aktivieren,aber mal ehrlich – wer ausser Textfetischisten die die Konsole trotzdem nicht mögen würde soetwas wollen … ?!

Folgendes Zitat von hier finde ich sehr interessant:

“Ubuntu 9.10 gives users more reasons than ever to seriously consider Linux at a time when many are thinking again about their operating system options. We are delivering a platform for users interested in an easy-to-use, great-looking, web-friendly operating system,” says Jane Silber, COO at Canonical. “A faster, more beautiful boot and login sequence, file and contact synchronisation through online services and great experiences on the most popular notebook, desktop and netbook models continue to drive Ubuntu into the mainstream of computing choices.”

Ich finde es einerseits toll dass sich Entwickler die Mühe machen,ihr Betriebssystem so Benutzerfreundlich wie nur möglich zu gestalten,aber andererseits … hatte Linux immer diesen Touch etwas “besonderes” zu sein.Bitte missversteht mich nicht,ich war immer ein absoluter Gegner dieser,”Wir sind 3l1t3″ – Mentalita,doch die meisten Linuxuser die ich kennenlernen durfte waren in der Lage und auch willig,logisch zu denken und nicht gleich Gott und die Welt zu verfluchen,falls etwas nicht nach dem ersten Anlauf klappte.Ich mache mir irgendwie ernsthafte Sorgen darüber,dass die Linxuwelt von DAUs überrannt wird … aber das sind nur meine Gedanken! Wünsche einen schönen Restabend und viel Spaß beim warten auf den 29.10!

LINQ to SQL vs ADO.NET Entity Framework

depaule — Mon, 26 Oct 2009 14:45:22 +0000

So habe jetzt mal LINQ to SQL ausprobiert. Ist auch soetwas wie ein OR-MAPPER. Hat auf jedenfall einen besseren Wizzard als ADO.NET EF und ist bei der Laufzeituntersuchung von über 100.000 Datensätzen (mit über 100 Spalten) mit 20 sec 5 sec schneller als das EF

ADO.NET Entity Framework mit Oracle

depaule — Mon, 26 Oct 2009 10:34:05 +0000

Habe heute mal das ADO.NET Entity Framework (ein OR-Mapper) von Microsoft ausprobiert. Für den Zugriff auf die Objekte habe ich LINQ verwendet. IMHO hat es eine sehr schöne Syntax.
Leider bietet Microsoft keinen Treiber für Oracle also habe ich diesen von http://www.devart.com/ verwendet.
Schein ziemlich schnell zu sein…
Werde noch weitere Testes machen. Praktisch finde ich auch die Graphische Darstellung des Datenmodells