Posts tagged ‘shield’

 

Fünfter Arduino OpenSpace am 08.02.2014

Fünfter Arduino OpenSpace am 08.02.2014

Es ist wieder soweit: Am Samstag den 08.02.2014 findet in der CoFab wieder ein Arduino OpenSpace in Dresden statt.

Zeitplan:

09:00 Eintreffen der Teilnehmer, Aufbauen eventueller Projekte
10:00 Vorstellungsrunde und Themenvorschläge
11:00 – 17:00 Sessions aus den angenommenen Themenvorschlägen

In der Vergangenheit hatten wir Themen wie „3D-Drucken“, „Aktuelle Arduino-Boards und -Shields“, „Aktuelle LED-Trends“, „Hexapod und andere Roboter“, „Hifi-Audio selbst gebaut“, „LED-Matrizen“, „Lessons Learned bei großen LED-Projekten“, „LED-Würfel“, „Arduino-Programmierung für Einsteiger“, „Mein erstes Arduino-Projekt“, und viele mehr

Es ist also für jeden etwas dabei. Aber welche Themen am 08.02.2014 angeboten werden, hängt von Euch ab. Also kommt vorbei und stellt Eure Projekte vor. Es gibt kein „zu trivial“ und auch kein „zu professionell“. Teilnehmen, inspirieren und inspiriert werden. Wir freuen uns auf Dich.

Schon jetzt bekannte Themenvorschläge:

  • Arduino für Einsteiger
  • Aktuelle Arduino-Produkte und -Zubehör (YUN, Galileo, NeoPixel, …)
  • Große LED-Matrizen mit dem Umsetzer-Board von SolderLab
  • Glediator (Software zur Steuerung von LED-Matrizen und Stripes)
  • Erste Erfahrungen mit Intel Galileo (dem Arduino-kompatiblen Board von Intel)
  • Digitale LED-Stripes mit einem Arduino Micro steuern.

Diesmal findet der Arduino OpenSpace im Rahmen des FabLabDD@CoFab statt. Das bedeutet, wir haben mehrere 3D-Drucker vor Ort, man kann also sogar vergleichen. Auch ein LaserCutter wird in diesem Rahmen vor Ort sein.

Anmeldung:

Bitte melde Dich unbedingt an, damit wir abschätzen koennen, auf wie viele Teilnehmer wir uns vorbereiten dürfen.

Anreise/Parken:

Straßenbahn: Die nächstgelegenen Haltestellen sind Pohlandplatz und Schillerplatz.

Auto: Parkplätze gibt es auf der Pohlandstrasse und der Eisenacher Straße.

Fahrrad: Fahrradständer sind am hinteren Ende vom Parkplatz im Hof.

Die CoFab befindet sich im 1.OG des Hinterhauses Pohlandstrasse 19 in 01309 Dresden (Karte).

FabLabDD@CoFab

Das FabLabDD ist eine Initiative vom Werk.Stadt.Laden und Freunden, die als mobiler MakerSpace die verschiedenen Maker-Gruppen in Dresden vernetzen will und so die Einrichtung eines MakerSpace in unserer Stadt vorbereitet. Im Rahmen des FabLabDD finden jetzt und in Zukunft auch immer wieder Arduino-bezogene Events statt, aber auch viele Veranstaltungen, die ohne Lötkolben und Computer auskommen. Schaut Euch also unbedingt an, was FabLabDD@CoFab in den Tagen vom 08.02.2014 bis zum 16.02.2014 bietet und empfehlt es weiter. Danke.

Weitere Details folgen. Ihr könnt natürlich auch unseren Newsletter abbonieren und uns auf Twitter und Facebook folgen.

Speaking Skull (Halloween Special)

Speaking Skull (Halloween Special)

A little plastic skull reads a text message (a.k.a. SMS) received via GSM. The robotic voice, little LEDs in the eyes and a moving jaw make this even more creepy.

This Speaking Skull was first presented at Mobile Bar Camp 2013 in Dresden as part of our presentation about open source hardware.

In preparation of Halloween we figured, it meight be a good idea to present this little project here, too. Enjoy.

How to do this?

Let’s start with jaw movement. The plastic skull has a small servo to move the jaw. An Arduino controls this servo. Just make sure the jaw moves freely. So far nothing special, just a bit mechanic and another use of the Servo library.

The Arduino is supposed to move the jaw following the spoken text message. Given some audio signal this could be coupled into a voltage divider where the resulting voltage is measured by an analog input of the Arduino.

Now, how to get the audio signal? There is a very cool text to speech module one can buy. Connect this to the Arduino and all the controlling is reduced sending a String to a serial interface. In order to keep this serial interface separated from the one the USB connection is using, we opted for an Arduino Leonardo.

And how does the Leonardo know the String to send? Well, finally the GSM shield gets involved. Just make sure to bend the pin 2 away when plugging the GSM shield in the Leonardo.

Don’t forget the final touches. The LEDs in the eyes are bidirectional LEDs which glow red or green depending on the direchtion of the current. Connect an resistor in series and wire that to two Arduino pins. As long as both pins are equal (both low or both high), the LED is off. If one pin is low while the other is high, the LED glows red. When levels are reversed, the LED glows green.

We decided to have the „eyes“ glow red when speaking.

Of course you want the text to be heared, so add some active speakers to the setup. Preferably some USB-powered speakers. USB-powered means, you can connect them to the 5V of the Arduino.

Finally, you don’t want to actually send a text message each time you want to demonstrate the speaking skull. So add a simple switch to the setup. Each time the switch is pressed an predefined message is processed. A prototype shield holds EMIC2, voltage divider, 5V power to speakers and the switch.

List of parts:

  • 1x Arduino Leonardo
  • 1x Arduino GSM-Shield
  • 1x Prototype Shield
  • 1x EMIC2 – text to speech module
  • 1x plastic skull
  • 1x miniature servo
  • 1x switch (print)
  • 2x resistor 4,7k (voltage divider)
  • 1x capacitor 100nF (coupling audio to voltage divider)
  • 1x USB powered speakers
  • 1x wooden board (200mm x 300 mm)
  • 2x distance bolt and screws (to hold skull)
  • 4x screw and distance roll (to hold Arduino Leonardo)
  • 2x double sided tape (to hold speakers)

Source Code

The source code is hosted at CodeBender, which we are proud to support.

Thank You

Thanks go to Arduino and SparkFun for providing the maker community with this fine electronic components.

Arduino OpenSpace Dresden (07.09.2013)

Arduino OpenSpace Dresden (07.09.2013)

Der nun schon 4. Dresdner OpenSpace rund um Arduino, Microcontroller allgemein, um LEDs und Roboter findet am ersten Samstag nach den Ferien statt.

Wann:

07.09.2013 von 10:00 bis ca. 17:00 Uhr

Wo:

CoFab
Pohlandstrasse 19
01309 Dresden

Wie:

Bei einem OpenSpace bestimmen die Teilnehmer, was konkret stattfindet und gestalten aktiv mit. Es gibt kein vorher definiertes Programm.

Zu Beginn stellt man sich kurz vor. Anschliessend bieten die Teilnehmer Themen an, die sie dann auch moderieren. Es kann sein, dass sie das Thema als Vortrag machen, oder sie haben noch keine Ahnung vom jeweiligen Thema und wollen sich einfach mal mit anderen dazu austauschen. Alles ist möglich.

Wir (konkret: Steffen) werden z.B. folgende Themen anbieten:

  • Arduino für Einsteiger
  • Algorithmen für ein animiertes Hexagon
  • Arduino YUN und Arduino Robot (falls wir dann schon Muster-Exemplare da haben)

Wenn Du ein Projekt von Dir zeigen willst, bring es also einfach mit. 😉 Wenn Du nichts mitbringst, auch ok.

Wenn Du für eine Präsentation mit Notebook machen möchtest, wir haben ein FULL-HD Display mit VGA- und HDMI-Kabeln. Dort kannst Du Dein Notebook anschliessen. Mac-Adapter sollte jeder selbst mitbringen. Falls Du WLAN brauchst, bitte bring Deinen Ausweis mit.

Wer:

Die Teilnehmer sind alle an Arduino und Microcontrollern interessiert, ist ja klar. Aber dann geht die Schere doch sehr weit auseinander. Sie reicht von Einsteigern, die sich erstmal informieren wollen, bis hin zu Profis, die tagtäglich eigene Schaltungen entwerfen und bauen. Es ist für jeden etwas dabei.

Ablauf:

  • ab 9:30 – Ankunft der Teilnehmer
  • 10:00 – 11:00 Session-Planung
  • 11:00 – 17:00 Sessions (inkl. Mittagspause)

Die Veranstaltung ist kostenlos, es wird jedoch um Anmeldung (Nachtrag: Link entfernt. Anmeldung nicht mehr möglich) gebeten. Es werden belegte Brötchen und alkoholfreie Getränke angeboten, solange der Vorrat reicht.

Akuelle Informationen (und Infos zu den zukünftigen Veranstaltungen) bekommst Du über folgende Kanäle:

Impressionen (Bilder vergangener Veranstaltungen)

arduino_openspace_dresden_xmega_session arduino_openspace_dresden_led_studien arduino_openspace_dresden_led_cube_session arduino_openspace_dresden_led_cube arduino_openspace_dresden_3d_drucker agile_hardware_at_maximatrix led-studien 20120916-145200.jpg

Nachtrag vom 10.09.2013

Die Veranstaltung liegt hinter uns (danke an alle Teilnehmer), und die Planung für den nächsten Arduino OpenSpace hat begonnen. Voraussichtlich wird der an einem Samstag im Februar 2014 stattfinden.

TeaBot (Bitter tea? Never again!)

TeaBot (Bitter tea? Never again!)

Imagine this situation: You prepare a cup of tea and look forward to drinking it. Then the phone rings or some other distraction leads you to forget the tea bag in the cup. That’s bitter and so is the tea. All the looking forward to a nice cup of tea turned into bitterness.

These are the kind of situations where a little bit of automation would help. And there is arduino. That got us thinking.

Core Ideas

Let’s build something with Arduino that removes the tea bag in time. But what time? It differs from tea to tea. So the time has to be easily adjustable.

  • When does the time start? Well, when the hot water meets the tea bag. Some sensing would be very helpful there, as there is no reason to start manually.
  • How does it remove the tea bag? It has to be something mechanical. Servos (known from RC-models) are easy to control with an Arduino.
  • If we can lift the tea bag out of a cup, we could lower it in there, too. This would be good to keep the tea bag in motion. Motion would result in a shorter time needed to make the tea. But do we want that? Really? On most tea bags the suggested draw time is printed on. If you speed up the process (by moving the tea bag all the time) all those suggestions would be worthless. Bottom line: Let’s Relax. We don’t keep the tea bag moving.
  • When two people drink tea together, chances are they have different tastes. So the system should be able to make two cups of tea at the same time, but with different drew times.

The result: TeaBot in action

How we did it

TODO

The trunk is fastened by a M5x20 screw from below. Also you see the 4 transparent feet in the corners of the base board. From above you see the LCD mounted with M3x20 screws and 3x10 distance rolls. Also good to see: the pull-up resistors are soldered to both sides of the switches.

Hardware (approx. 150..200 € in total)

  • 1 x Arduino Leonardo w/o Header
  • 1 x TimesSquareShield-Bausatz
  • 2 x Servo
  • 1 x LCD 20×4 Seriell
  • 2 x Temperatur-Sensor LM35DX (TO 92)
  • 2 x Servo-Arm (Plastik 10x10x120mm mit Bohrung und Einschnitt)
  • 2 x Holzschraube 2,9×12
  • 1 x Aluminium Vierkantprofil 20x20x250mm
  • 1 x Plexiglas Frontplatte 200x120x3mm
  • 1 x Plexiglas Rueckplatte 120x80x3mm
  • 2 x Abstandsbolzen M4 x 10 innen/aussen
  • 2 x Abstandsbolzen M4 x 20 innen/aussen
  • 4 x Abstandsbolzen M4 x 40 innen/aussen
  • 8 x Linsenkopfschraube M4 x 8
  • 1 x Senkkopfschraube M5 x 20
  • 1 x Frühstücksbrettchen
  • 4 x Inbusschraube M3 x 10
  • 4 x Inbusschraube M3 x 20
  • 8 x Mutter M3
  • 2 x Kipptaster (ein) / aus / (ein)
  • 1 x Kippschalter ein / aus
  • 4 x Widerstand 10 kOhm
  • 1 x Miniaturlautsprecher
  • 1 x Widerstand 470 Ohm
  • 1 x NPN-Transistor BC 546 (TO-92)

Software (free)

Sessions vom MobileCamp Dresden 2013

Sessions vom MobileCamp Dresden 2013

25.05.2013: „Arduino Grundlagen“

Präsentation:
PDF

Quelltext:

26.05.2013: „Arduino – Lessons Learned“

Präsentation:
PDF

Dokumentation der Arduino-Projekte

  • LedPost (Link folgt in Kürze)
  • TreasureChest (Link folgt in Kürze)
  • TeaBot (Link folgt in Kürze)
  • BeatingHeart (Link folgt in Kürze)
  • SmsSpeakingSkull (Link folgt in Kürze)

Arduino OpenSpace war wieder ein Erfolg!

Arduino OpenSpace war wieder ein Erfolg!

Wow. Das war ne tolle Veranstaltung. Und für Jeden war etwas dabei.

Vom 3D-Drucker über eine Kurzeinführung zu Arduino, über Arduino im Dauereinsatz (Stichwort WatchDog) und ein wenig Programmierung an echten Projekten bis hin zu Trends der LED-Technik, den Wunderwerken von SolderLab, der XMega-Programmierung und Radiofaro.

Hier werden in den kommenden Tagen noch ein paar Bilder und Links ergänzt. Jetzt wollen wir vor allem eines sagen:

DANKE. Danke an alle Teilnehmer, denn ein Openspace ist eben immer nur so gut, wie seine Teilnehmer.

Im Herbst gibt es die nächste Veranstaltung. Das steht schon fest. Wir freuen uns schon darauf.

 

Verlinkt!

Seit heute sind wir nun auch in der offiziellen Distributoren-Liste auf www.arduino.cc verlinkt. Sehr schön.

Das trifft sich gut, denn die nächste große Lieferung ist unterwegs. Mal sehen, wie lange die Arduino Due diesmal brauchen, bis sie wieder ausverkauft sind. 😉

02.02.2013 Arduino Open Space in Dresden

Am ersten Samstag im Februar ist es wieder soweit: In Dresden treffen sich Freunde von Arduino und Co. und stellen sich gegenseitig Ihre Projekte vor, fachsimpeln, entwickeln gemeinsam und knüpfen Kontakte.
Dabei sind wir keineswegs auf Arduino-Themen begrenzt, alles rund um Microcontroller und LEDs ist herzlich willkommen.

2.2.13 Bild1

2.2.13 Bild2

2.2.13 Bild3

2.2.13 Bild4

2.2.13 Bild5

LED-Studien.de präsentiert LED-Trends

Rene und Thomas von SolderLab werden z.B. Ihre neuesten Entwicklungen mit LED-Matrizen vorstellen und sicherlich auch ihre bereits bekannten Projekte (z.B. den RGB-LED-Globe) noch einmal aufbauen.

Nino von LED-Studien wird voraussichtlich wieder neueste Trends der LED-Technik vorstellen.

Carsten bereitet das Thema „Heimserver ala RaspberryPi, Dockstar und Co“ vor.

Daniel und Axel stellen Ihr Projekt uracoli vor.

Steffen von Agile-Hardware wird zeigen, was es Neues bei Arduino gibt, hat ein paar kleine Arduino-Projekte und nicht zuletzt die MaxiMatrix vorzuweisen.

Wir freuen uns auch auf Dich und Deinen Beitrag. (In der Vergangenheit hatten wir beispielsweise schon 3D-Drucker, eine Heim-Vernetzung mit Arduino oder auch ein LED-beleuchtetes Kugelzelt vor Ort.) Das wird wieder ein toller Tag!

Wann?
Samstag 02.02.2013 von 10:00 – bis ca.17:00

Wo?
CoFab
Pohlandstrasse 19
01309 Dresden
GERMANY

Wie?
Die Teilnahme ist kostenlos, jedoch solltest Du Dich vorher anmelden.

Bitte weitersagen!

Organisatorisches:

  • Ab 9:00 Uhr sind die Räume geöffnet. Wenn Du für Deine Präsentation etwas aufbauen möchtest, komme bitte rechtzeitig.
  • Ab 10:00 Uhr werden Themen vorgeschlagen. Alle Teilnehmer stimmen ab, was Sie interessiert.
    Ein kleiner Kreis der Teilnehmer bringt die Themen in eine sinnvolle Reihenfolge und macht daraus den plan für den Tag.
  • ca. 11:00 Der Plan steht und die Präsentationen beginnen. (jeweils ca. 25 Min.)
    Zu jeder vollen und halben Stunde beginnen neue Präsentationen. Wir werden 2 oder 3 parallele Tracks haben.
  • Alle Teilnehmer tragen ein kleines Namensschild. Wir Duzen uns.
  • Es gibt belegte Brötchen, Kaffee und Wasser. (Gesponsort von uns.)

Nicht vergessen: Es soll uns allen Spass machen.

Race-Condition beim Arduino Due

Aus dem Alltag eines Shop-Betreibers:

Der Arduino Due ist begehrt. Gestern haben zwei Kunden innerhalb von wenigen Sekunden unsere letzten vorrätigen Exemplare gekauft. (Natürlich haben wir längst nachbestellt.)

Sehr spannend. In der IT nennen wir das Race-Condition, denn beide Kunden waren zeitgleich im Shop. Beide hatten offenbar die Verfügbarkeitsprüfung schon hinter sich.

Leider nimmt der Shop in dieser Situation offenbar Bestellungen an, die über den Lagerbestand hinausgehen. Das wollten wir eigentlich vermeiden. Nun können wir dem zweiten Besteller leider nicht gleich so viele Exemplare schicken, wie er gern gehabt hätte. Das tut uns leid und wir haben ihm das natürlich längst mitgeteilt und eine Änderung der Bestellung angeboten. Alternativ schicken wir die weiteren Exemplare auf unsere Kosten hinterher, sobald wir sie haben.

Das ist unangenehm für den Kunden und für uns. Aber wir gehen offen damit um und bearbeiten die Bestellungen strickt nach Bestelleingang. Fair Play wird sich auf lange Sicht auszahlen.

Nicht zuletzt gehen wir davon aus, dass sich die Verfügbarkeit der Arduino Due stark verbessern wird. So wie es mit jedem neuen Arduino-Produkt war. Auch der Arduino Leonardo (mit Header) und das Arduino Wifi-Shield waren kurz nach Erscheinen nur schwer verfügbar. Inzwischen haben wir da einen Lagerbestand, der wohl auch über Weihnachten nicht aufgebraucht wird.

Adventskalender mit Arduino und LED-Matrix

Adventskalender mit Arduino und LED-Matrix

Weihnachten steht vor der Tür, in den Kaufhäusern und Supermärkten ist das Thema sehr präsent und auch wir können uns dem nicht entziehen. Aber wir können es anders angehen.

Wir möchten in diesem Artikel 24 kleine weihnachtliche Animationen für die 16×32 LED-Matrix von Sure Electronics vorstellen. Der Quelltext wird in den kommenden Tagen immer wieder ergänzt.

Nachtrag: Bis zum Nikolaustag gibt es schon was zu sehen.

Download des aktuellen Standes (noch in Entwicklung)

Idee: Wer mag, kann ja eine Echtzeituhr oder einen DCF77-Empfänger anschliessen, um ggf. automatisch auf die neue Animation umzuschalten.

Hardware:

Quelltext:

#include "matrix_32x16xRG.h"

int counter = 0;
int day     = 1;

int dayOfDecember() {
  if (counter>50) {
    day++;
    counter = 0;
    if (day >26) {
      day = 1;
    }
  }
  counter++;
  return day;
}

word ONE_CANDLE[32] = {
  0x7fff, 0x3ffc, 0x0fb0, 0x0ff0, 0x0fb0, 0x0ff0, 0x0fb0, 0x0ff0, 
  0x0fb0, 0x0ff0, 0x0fb0, 0x0ff0, 0x0fb0, 0x0ff0, 0x0fb0, 0x0ff0, 
  0x0fb0, 0x0ff8, 0x0fb8, 0x0ff8, 0x0fb8, 0x0ff8, 0x0fb0, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
};

word ONE_BRANCH[32] = {
  0x0f00, 0x0300, 0x1d00, 0x0d00, 0x3400, 0x1000, 0x0000, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
};

word KERZENSTAENDER[32] = {
  0x0000, 0x7ffe, 0x3ffc, 0x1ff8, 0x0ff0, 0x07e0, 0x03c0, 0x0180, 
  0x0180, 0x0180, 0x0180, 0x0180, 0x0180, 0x03c0, 0x17e8, 0x27e4, 
  0x27e4, 0x27e4, 0x1ff8, 0x03c0, 0x03c0, 0x03c0, 0x03c0, 0x03c0, 
  0x03c0, 0x03c0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
};

word SCHNEEMANN[32] = {
  0x0000, 0x1f84, 0x2044, 0x4024, 0x4024, 0x4024, 0x2044, 0x1084, 
  0x0f04, 0x1084, 0x2044, 0x2044, 0x2044, 0x1084, 0x0f44, 0x0924, 
  0x109f, 0x109f, 0x1080, 0x0f00, 0x3fc0, 0x0f00, 0x0f00, 0x0f00, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 
//  0x0008, 0x021c, 0x0708, 0x2200, 0x7002, 0x2087, 0x01c2, 0x0080 
};

word SCHNEEFLOCKEN[32] = {
  0x0000, 0x0000, 0x0000, 0x0000, 0x0200, 0x1540, 0x3260, 0x0a80,
  0x2720, 0x5dd0, 0x2720, 0x0a80, 0x3260, 0x1540, 0x0200, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0200, 0x1540, 0x3260, 0x0a80, 0x2720, 
  0x5dd0, 0x2720, 0x0a80, 0x3260, 0x1540, 0x0200, 0x0000, 0x0000 
}; 

word EISENBAHN[32] = {
  0x1f00, 0x3100, 0x7900, 0x3100, 0x1100, 0x1100, 0x1100, 0x1100,
  0x3100, 0x7900, 0x3100, 0x1f00, 0x0800, 0x1c00, 0x0c00, 0x1ffc, 
  0x1004, 0x30f4, 0x7894, 0x78f4, 0x3004, 0x1ffc, 0x1081, 0x1083, 
  0x108e, 0x30f4, 0x78f0, 0x7880, 0x3080, 0x1080, 0x1f80, 0x0000 
}; 

word GLOCKE[32] = {
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4000, 0x2000, 0x1000,
  0x0c00, 0x4200, 0x6100, 0x70c0, 0x5820, 0x4e18, 0x47c4, 0x41f2, 
  0x583e, 0xdf0f, 0xdf0f, 0x583c, 0x41f0, 0x47c0, 0x4e00, 0x5800, 
  0x7000, 0x6000, 0x4000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 
}; 

word STERNE[32] = {
  0x0000, 0x2008, 0x3018, 0x3838, 0x1ef0, 0x1ff0, 0x0fe0, 0x0fe0,
  0x0fe0, 0x3ff8, 0x7ffc, 0x07c0, 0x0380, 0x0180, 0x0080, 0x0000, 
  0x0000, 0x2008, 0x3018, 0x3838, 0x1ef0, 0x1ff0, 0x0fe0, 0x0fe0, 
  0x0fe0, 0x3ff8, 0x7ffc, 0x07c0, 0x0380, 0x0180, 0x0080, 0x0000 
};  

word SCHLITTEN[32] = {
  0x0000, 0x0000, 0x0000, 0x4200, 0x4200, 0x43e0, 0x43e0, 0x7fe8,
  0x43f0, 0x43f0, 0x43e8, 0x47e0, 0x4200, 0x43fa, 0x43fc, 0x43fc, 
  0x43fa, 0x4200, 0x43f0, 0x43f4, 0x7ff8, 0x43f8, 0x43f4, 0x43f0, 
  0x4200, 0x4300, 0x4180, 0x6080, 0x3180, 0x1f00, 0x0e00, 0x0000 
};  

word HIRSCHE[32] = {
  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0400, 0x7e00, 0x7e10,
  0x0e20, 0x0f20, 0x7fa0, 0x7ff0, 0x0fd8, 0x00c0, 0x0080, 0x0000, 
  0x0000, 0x0000, 0x0000, 0x0000, 0x0400, 0x7e00, 0x7e10, 0x0e20, 
  0x0f20, 0x7fa0, 0x7ff0, 0x0fd8, 0x00c0, 0x0080, 0x0000, 0x0000 
};  

word NIKOLAUSSTIEFEL[32] = {
  0x0000, 0x7fbe, 0xffff, 0x8001, 0x8001, 0x8001, 0x8081, 0x4101,
  0x3e01, 0x0101, 0x0081, 0x0081, 0x0041, 0x0041, 0x0041, 0x007f, 
  0x0081, 0x0081, 0x0081, 0x0077, 0x0149, 0x0229, 0x0419, 0x0209, 
  0x011f, 0x0ea0, 0x0240, 0x0200, 0x0000, 0x0000, 0x0000, 0x0000 
};

word WEIHNACHTSBAUM[32] = {
  0x0000, 0x03c0, 0x03c0, 0x03c0, 0x03c0, 0x03c0, 0xffff, 0x7ffe,
  0x7ffe, 0x3ffc, 0x1ff8, 0x7ffe, 0x3ffc, 0x1ff8, 0x0ff0, 0x3ffc, 
  0x1ff8, 0x0ff0, 0x07e0, 0x1ff8, 0x0ff0, 0x07e0, 0x03e0, 0x03e0, 
  0x01c0, 0x01c0, 0x0080, 0x0080, 0x0000, 0x0000, 0x0000, 0x0000 
};

word FLAME_PIXELS[] = {
                  0x1e08, 
          0x1d07, 0x1d08,
          0x1c07, 0x1c08,
  0x1b06, 0x1b07, 0x1b08, 0x1b09, 
  0x1a06, 0x1a07, 0x1a08, 0x1a09, 
  0x1906, 0x1907, 0x1908, 0x1909, 
          0x1807, 0x1808,
};

word FLAME_SMALL_PIXELS[] = {
                  0x1e08, 
          0x1d07, 0x1d08,
          0x1c07, 0x1c08,
          0x1b07, 0x1b08, 
          0x1a07 
};

int FLAME_COLORS[] = {
  COLOR_RED,
  COLOR_YELLOW,
  COLOR_YELLOW,
  COLOR_YELLOW,
  COLOR_NONE
};

void drawSprite(word bits32x16[], int offsetX, int offsetY, int color) {
  word bits;
  int  x;
  
  for (int indexX=0; indexX<32; indexX++) {
    bits = bits32x16[indexX];
    x    = indexX + offsetX;
    for (int y=offsetY; y<16+offsetY; y++) {
      if (bits & 0x0001) {
        plot(x, y, color);
      } // no else
      bits = bits >> 1;
    }
  }
} 

void drawRandom(word posXY[], int sizePosXY, int colors[], int sizeColors) {
  int x, y;
  
  for (int index=0; index<sizePosXY; index++) {
    x = (posXY[index] >> 8);
    y = (posXY[index] & 0x00ff);
    plot(x, y, colors[random(sizeColors)]);
  }
} 


void dec01() {
  for(int i=0; i<32; i++) {
    plot( random(32),  random(16), random(4));
  }
}

void dec02() {
  drawSprite(ONE_CANDLE, 0, 0, COLOR_RED);
  drawSprite(ONE_BRANCH, 0, 0, COLOR_GREEN);
  drawRandom(FLAME_PIXELS, sizeof(FLAME_PIXELS)/2, FLAME_COLORS, sizeof(FLAME_COLORS)/2);
}

void dec03() {
  drawSprite(KERZENSTAENDER, 0, 0, COLOR_RED);
  drawRandom(FLAME_SMALL_PIXELS, sizeof(FLAME_SMALL_PIXELS)/2, FLAME_COLORS, sizeof(FLAME_COLORS)/2);
}

void dec04() {
  for(int i=0; i<32; i++) {
    plot( random(32),  random(16), random(4));
  }
  drawSprite(GLOCKE, 0, 0, COLOR_YELLOW);
}

void dec05() {
  drawSprite(SCHNEEMANN, 0, 0, COLOR_YELLOW);
  for(int i=24; i<32; i++) {
    plot( 24+random(8),  random(16), random(4));
  }
}

int offset = -16;

void dec06() {
  drawSprite(NIKOLAUSSTIEFEL, 0, 0, COLOR_RED);
}

void dec07() {
  for(int i=0; i<8; i++) {
    plot( random(32),  random(16), random(4));
  }
  drawSprite(SCHNEEFLOCKEN, random(2), offset, COLOR_RED);
  offset++;
  if (offset>16) {
    offset = -16;
  }
  delay(50);
}

void dec08() {
}

void dec09() {}
void dec10() {}
void dec11() {}
void dec12() {}
void dec13() {}
void dec14() {}
void dec15() {}
void dec16() {}
void dec17() {}
void dec18() {}
void dec19() {}
void dec20() {}
void dec21() {}
void dec22() {}
void dec23() {}
void dec24() {}

void setup() {
  matrixSetup(ATS_CS_PIN, ATS_WRCLK_PIN, ATS_DATA_PIN, ATS_CLK_PIN);
}


void loop() {
  int day;
  
  day = dayOfDecember();
  
  switch (day) {
    case  1: dec01(); break; 
    case  2: dec02(); break; 
    case  3: dec03(); break; 
    case  4: dec04(); break; 
    case  5: dec05(); break; 
    case  6: dec06(); break; 
    case  7: dec07(); break; 
    case  8: dec08(); break; 
    case  9: dec09(); break; 
    case 10: dec10(); break; 
    case 11: dec11(); break; 
    case 12: dec12(); break; 
    case 13: dec13(); break; 
    case 14: dec14(); break; 
    case 15: dec15(); break; 
    case 16: dec16(); break; 
    case 17: dec17(); break; 
    case 18: dec18(); break; 
    case 19: dec19(); break; 
    case 20: dec20(); break; 
    case 21: dec21(); break; 
    case 22: dec22(); break; 
    case 23: dec23(); break; 
    case 24: dec24(); break;
    default : break;// do nothing (except waiting for xmas)
  }
  
  nextImage(10);
}