Natebu is on display again! For the TISSOT stand at the Baselworld we covered a entire welcome desk of 5 square meters.

Photos will follow soon. In the meanwhile you can go to Basel and see it yourself.

The exhibition is open till Thursday the 10th of April.

This weekend (Fr./Sa. 7./8. December) we are at the diy* festival 07 in Zürich. http://www.diyfestival.ch

Besides workshops, lectures and concerts the festival also features an exposition where we show Natebu. Feel free to visit us there.

I finally managed to upload a new movie about the data visualisation. One of the Natebu boards is connected to a mac that is running a Processing sketch. This bar chart was just for debugging. The door is now open to all kind of Processing applications.

At the moment there is the Ars Electonica Festival in Linz Austria and we are very proud to be able to show our project at the Campus 2.0.

You can find us at the Kunstuniversität Linz on the second floor.

We just uploaded a new Video to YouTube:

We have some more pictures of ways to use natebu in public:

Until now we used to power the matrix over the USB ports of three computers. This was no satisfying solution at all. We now connected an old computer power supply which has a 5 V DC output. This does the job just fine.
We also did some work on the code. We now have a mode to display text and abstract animations.

We finally can show you some arduino source-code of our project.
It is  quite a mess and really rough but it seems to work.
We are working on a more sophisticated version so stay tuned.

Code after the jump.

// by rob natebu.wordpress.com

int dataPin = 10; //DS
int latchPin = 9; //ST
int clockPin = 8; //SH

int sS0 = 7; //sS0
int sS1 = 6; //sS1
int sS2 = 5; //sS2

int mS0 = 4; //mS0
int mS1 = 3; //mS1
int mS2 = 2; //mS2

// Pinf for the Status LED
int led = 13;

// Pin for the IR LEDs
int LEDpin = 11;

// Analog Inputs von den Fototransistoren
int analogInput = 0;

// variable to store the value

int values0[] = {
0, 0, 0, 0, 0, 0, 0, 0};
int values1[] = {
0, 0, 0, 0, 0, 0, 0, 0};
int values2[] = {
0, 0, 0, 0, 0, 0, 0, 0};
int values3[] = {
0, 0, 0, 0, 0, 0, 0, 0};
int values4[] = {
0, 0, 0, 0, 0, 0, 0, 0};
int values5[] = {
0, 0, 0, 0, 0, 0, 0, 0};
int values6[] = {
0, 0, 0, 0, 0, 0, 0, 0};
int values7[] = {
0, 0, 0, 0, 0, 0, 0, 0};

int values[8][8]; //display
int counters[8][8];//storrage

// a threshold to decide when the LED turns on 512 normal
int threshold = 700;

int timer = 0;

//holders for infromation you’re going to pass to shifting function
byte dataRED;
byte dataGREEN;
byte dataArrayRED[8];
byte dataArrayGREEN[8];

//alles für den multiplexer
int rm0 = 0; // value Master 4051 (s0)
int rm1 = 0; // value Master 4051 (s1)
int rm2 = 0; // value Master 4051 (s2)
int rowM = 0; // storeing the bin code
int bin [] = {
000, 1, 10, 11, 100, 101, 110, 111};//bin = binär, some times it is so easy

int rs0 = 0; // value Slave 4051 (s0)
int rs1 = 0; // value Slave 4051 (s1)
int rs2 = 0; // value Slave 4051 (s2)
int rowS = 0; // storeing the bin code

void setup() {

//multiplexer
pinMode(mS0, OUTPUT); // Master s0
pinMode(mS1, OUTPUT); // Master s1
pinMode(mS2, OUTPUT); // Master s2

pinMode(sS0, OUTPUT); // Slave s0
pinMode(sS1, OUTPUT); // Slave s1
pinMode(sS2, OUTPUT); // Slave s2

digitalWrite(led, HIGH); //die kontroll LED

//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);

//set the pin for the IR LEDs
pinMode(LEDpin, OUTPUT);
digitalWrite(LEDpin, HIGH);

// Analog Inputs von den Fototransistoren
pinMode(analogInput, INPUT);

dataArrayGREEN[0] = 254;
dataArrayGREEN[1] = 253;
dataArrayGREEN[2] = 251;
dataArrayGREEN[3] = 247;
dataArrayGREEN[4] = 239;
dataArrayGREEN[5] = 223;
dataArrayGREEN[6] = 191;
dataArrayGREEN[7] = 127;

for(int j = 0; j < 8; j++){
values[0][j] = values0[j];
values[1][j] = values1[j];
values[2][j] = values2[j];
values[3][j] = values3[j];
values[4][j] = values4[j];
values[5][j] = values5[j];
values[6][j] = values6[j];
values[7][j] = values7[j];
}
for(int i = 0; i < 8; i++){
for(int j = 0; j < 8; j++){
counters[i][j] = 0;
}
}
}

void loop() {

/// Multiplexer read alle
for (int countM=0; countM<8; countM++) {
rowM = bin[countM];
rm0 = rowM & 0×01;
rm1 = (rowM>>1) & 0×01;
rm2 = (rowM>>2) & 0×01;
digitalWrite(mS0, rm0);
digitalWrite(mS1, rm1);
digitalWrite(mS2, rm2);

for (int countS=0; countS<8; countS++) {
rowS = bin[countS];
rs0 = rowS & 0×01;
rs1 = (rowS>>1) & 0×01;
rs2 = (rowS>>2) & 0×01;
digitalWrite(sS0, rs0);
digitalWrite(sS1, rs1);
digitalWrite(sS2, rs2);

if(values[countS][countM] == 1) {
counters[countS][countM] = counters[countS][countM] + 1;
}
if( counters[countS][countM] > 50) {
counters[countS][countM] = 0;
values[countS][countM] = 0;
}

if ( analogRead(analogInput) < threshold) {
// macht die umschaltung
if(values[countS][countM] == 0) {
values[countS][countM] = 1;
}
}

dataArrayRED[countS] = values[countS][0]*1+values[countS][1]*2+values[countS][2]*4+values[countS][3]*8+values[countS][4]*16+values[countS][5]*32+values[countS][6]*64+values[countS][7]*128;
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//move ‘em out
shiftOut(dataPin, clockPin, dataArrayGREEN[countS]);
shiftOut(dataPin, clockPin, dataArrayRED[countS]);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
}
}

}

// the heart of the program
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {

//internal function setup
int i=0;
int pinState;
pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, OUTPUT);

//clear everything out
digitalWrite(myDataPin, 0);
digitalWrite(myClockPin, 0);

for (i=7; i>=0; i–) {
digitalWrite(myClockPin, 0);
if ( myDataOut & (1<<i) ) {
pinState= 1;
}
else {
pinState= 0;
}
//Sets the pin to HIGH or LOW depending on pinState
digitalWrite(myDataPin, pinState);
//register shifts bits on upstroke of clock pin
digitalWrite(myClockPin, 1);
//zero the data pin after shift to prevent bleed through
digitalWrite(myDataPin, 0);
}
//stop shifting
digitalWrite(myClockPin, 0);
}

After three days and nights working we finaly finished our project. We turned over a functional matrix prototype, a high end mock-up and flash animations to explain the interaction. Enjoy the pix as we do.

More pictures after the jump.

We are getting awfully close to the finishing line…