Unter dem Motto "Informatik - on the move!" laden wir Dich für einen Tag an die Fakultät Informatik der HTWG Konstanz ein. Du wirst Versuche durchführen, die etwas mit Bewegung zu tun haben: Eine Smartphone App, ein Haufen von Bällen oder ein eigenes soziales Netzwerk - alles bewegt uns und die Informatik ist immer dabei. Die Veranstaltung findet am 28. April 2016 statt.

In dem Blog findest Du alles was Du brauchst, damit die Hardware auch auf Deinem Computer programmiert werden kann. Viel Spaß!

Girls' Day 2016: "Informatik - on the move!"

 

Unser Girls’ Day Motto ist "Informatik - on the move!"

Unter dem Motto "Informatik - on the move!" laden wir Dich für einen Tag an die Fakultät Informatik der HTWG Konstanz ein. Du wirst Versuche durchführen, die etwas mit Bewegung zu tun haben: Eine Smartphone App, ein Haufen von Bällen oder ein eigenes soziales Netzwerk - alles bewegt uns und die Informatik ist immer dabei.

Wir wollen Dir einen praktischen Zugang zur Informatik zeigen. Du wirst einige Laborversuche machen, bei denen Du den Umgang mit der modernen Informations- und Kommunikationstechnik kennenlernst. In kleinen Teams wirst Du Lösungen erarbeiten und die Ergebnisse selbst ausprobieren. Für die Teilnahme solltest Du Interesse mitbringen – wir erwarten keinerlei Vorkenntnisse in Informatik. Bei Fragen steht Dir unser Laborteam zur Seite.

Tagesablauf am 28. April 2016 (Die genauen Hinwiese bekommst Du in der schriftlichen Einladung)

  • 9:30 Willkommen
  • 10:00 Android Smartphone App programmieren
  • 12:15 Mittagessen
  • 13:00 LED-Uhr programmieren
  • 15:30 Verabschiedung

Anmelden kannst Du dich über den offiziellen Server für den Girls' Day.

Hier kannst Du schon sehen was Dein Girls' Team vorbereitet.

Wir freuen uns auf Deine Teilnahme!

Dein Ubiquitous Computing Team der HTWG Konstanz 
http://uc-lab.in.htwg-konstanz.de

 

Continue reading
Rate this blog entry:
0
2137 Hits 0 Comments

Getting Startet Digispark Girlsday

Damit ihr die Hardware zu Hause nutzen könnt, solltet ihr folgende Schritte beachten:

Der USB Stick mit dem Mikrokontroller (Digispark) benötigt die Arduino IDE 1.6.5 oder eine neuere Version.

Hier der Link zum Downloaden: https://www.arduino.cc/en/Main/Software

Installationsanleitung:
  1. Lade zuerst die Software von Arduino herunterladen: https://www.arduino.cc/en/Main/Software
  2. Danach benötigen wir noch die Treiber (Driver). Diese ebenfalls herunterladen, die Datei entpacken und installieren. Dafür nutzt man die „Install Drivers“ Datei, die man ausführen kann. Die Driver findet man hier: https://github.com/digistump/DigistumpArduino/releases/download/1.6.7/Digistump.Drivers.zip
  3. Arduino Software starten.
  4. Im Ardunio-Programm (die sogenannte 'IDE') auf das Menu 'Datei' und dann auf 'Voreinstellungen' klicken 

    Datei Voreinstell

  5. Unter „Zusätzliche Boardverwallter-URLs: “ den Link einfügen:

    http://digistump.com/package_digistump_index.json 

    Dann auf OK klicken.


    URL

      
  6. Gehe nach "Werkzeuge" dann "Boards" und wähle dann "Boardverwalter…". Im Auswahlmenü "Typ" den Eintrag "Beigetragenen" auswählen. Danch "Digistump AVR Boards" auswählen und auf "Installieren" klicken. Jetzt können wir den Downloadprozess beobachten. Wenn dieser beendet ist, sehen wir, dass es als Installiert markiert erscheint. Bei Windows kann sich ein Pop Up Fenster öffnen, wenn die Installation beendet ist, damit man die Treiber installieren/aktualisieren kann. Bitte auf "Weiter" klicken und die Installation erlauben.

    Board Install

  7. Sobald die Installation beendet ist, schließe das „Boardverwalter“ Fenster und wähle den Digispark aus.

    Board Select

Das war's - viel Spaß!

Continue reading
Rate this blog entry:
0
1413 Hits 0 Comments

#LetsHack #MyPersonalLEDWatch

Welcome to the Informatics

Unter dem Motto „Informatics on the move!“ des diesjährigen Girls’ Day hatten wir die Möglichkeit 20 Mädchen einen kleinen Einblick in die Welt der Informatik zu geben. Schon bei den ersten Entwürfen zum eigentlichen Programm, versuchten wir den schmalen Grat zwischen interessanten Themen und geringer Komplexität so gut es geht zu meistern.

Unser Schwerpunkt lag dabei auf aktuellen Themen der Informatik, sowie der Möglichkeit dem eigenen Schaffen eine persönliche Note zu geben.

Aus diesen Anforderungen entstanden dann zwei Themen. Zum einen das Erstellen einer eigenen App mit dem Ziel, Bilder aus dem eigenen Medienordner auf dem Smartphone zu laden, mit Witzelementen wie zum Beispiel einem gefälschten Hipster-Bart zu versehen und dieses Bild über die sozialen Netzwerke mit anderen zu teilen. Mittels der App Inventor Software der Universität MIT, konnten die Mädchen die Funktionalität mit vorgefertigten Logik-Bausteinen zusammenbasteln, während die Gestaltung des Designs der App komplett selbst überlassen wurde.

Nach diesem ersten Einblick in die Welt der Apps, dachten wir uns, wäre ein Einblick in die komplett andere Richtung sehr interessant. Wir stellten also eine LED-Uhr vor. Dieses sogenannte „Eingebette System“ sollte zeigen, wie einfach es ist, physische Bausteine wie Dioden anzusprechen und zu programmieren. Das mit 12 LEDs bestückte Board (siehe Bild Nr. 1), welches von uns zur Verfügung gestellt wurde, sollte nicht nur so programmiert werden, dass die aktuelle Uhrzeit angezeigt wird, sondern lies darüber hinaus den Mädchen alle Freiheiten der farblichen Gestaltung ihrer eigenen Uhr. Beispielsweise war es ein einfaches, die Uhrzeiten bis 12 Uhr mittags in Rot darzustellen und alle späteren in blau. Sowie Spezialeffekte, wie ein „Glücksrad“, falls eine Stunde vergangen war. Es waren der Fantasie keine Grenzen gesetzt.

LED-Watch Board

Bild 1: LED-Watch Board

Nach dem Girls’ Day gingen wir wieder gewohnt unserem täglichen Geschäft nach, bis nach einigen Tagen mehrere Rückfragen zu unserer Uhr von Lehrern, Eltern und den Mädchen selber kam, was uns sehr gefreut hat. Besonders da wir mit solch einer Resonanz nicht gerechnet haben. Da das Interesse so groß war, überlegten wir uns hier einen kleinen Blog zu veröffentlichen, der nicht nur den aktuellen Interessenten, sondern auch Anderen die Möglichkeit bietet, euch eine eigene Uhr mit persönlichem Farbverlauf zu basteln.

Damit ihr auch selber loslegen bzw. weiter machen könnt gibt es nochmal eine kurze Einführung zum Thema Hardware, was ihr alles benötigt, wo ihr die Bauteile findet und wie ihr diese miteinander verbindet. Danach wird kurz gezeigt, welche Software ihr auf eurem Rechner benötigt um eure Hardware programmieren und hochladen zu können. Danach kommen wir an das eigentliche Thema, der Programmcode für die persönliche LED-Uhr. Hier werden die wichtigsten Code-Segmente erklärt, sodass diese später ganz einfach, nach dem eigenen Geschmack, erweitert werden können.

Nun aber genug geredet, #LetsHack

 

#LetsHack #MyPersonalLEDWatch

So, nachdem nun alle Teile vorhanden und korrekt miteinander verbunden sind, sowie die benötigte Software und Treiber installiert wurden geht es nun ans Eingemachte. Wir erstellen eine neue .ino-Datei in der wir den Programmcode zu unserer LED-Watch schreiben werden. Den kompletten Code sehr ihr hier: 

// NeoPixel Ring Clock sketch (c) 2016 W. Daniel Scherz
// released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library
#include 

// Which pin on the Arduino is connected to the NeoPixels?
#define PIN            0

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS      12

// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use to send signals.
Adafruit_NeoPixel leds = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_RGB + NEO_KHZ800);

int delayval = 1000;

void setup()
{
  leds.begin(); // This initializes the NeoPixel library.
}

void loop() 
{
  startClock();
}

void startClock()
{
  boolean is_am = true;
  
  //WICHTIG: Setze hier deine gewuenschte Uhrzeit. z.B. t_stunde = 17,  t_minute = 45,  t_sekunde = 17
  int t_sekunde = 30;
  int t_minute = 13;
  int t_stunde = 23;

  //Zwischen 0:00 Uhr und 11:59 Uhr ist AM. Zwischen 12:00 und 23:59 Uhr ist PM.
  if(t_stunde >= 12)
  {
    t_stunde = t_stunde % 12;
    is_am = false;
  }

  while(true)
  {
    //Setze hier die Helligkeit deiner LEDs herunter sonst erblindest du auf Dauer! :-D
    leds.setBrightness(120);
    
    //  Hier wird zuerst die alte Anzeige geloescht
    leds.setPixelColor(t_sekunde/5, leds.Color(0,0,0)); // Moderately bright green color.
    leds.setPixelColor(t_minute/5, leds.Color(0,0,0)); // Moderately bright green color.
    leds.setPixelColor(t_stunde, leds.Color(0,0,0)); // Moderately bright green color.
    t_sekunde++;

    //Hier ist die Logik der Uhr. Wenn du das veraenderst, wird es ziemlich chaotisch. :-)
    if(t_sekunde == 60)
    {
      t_minute++;
      t_sekunde = 0;
    }
    if(t_minute == 60)
    {
      t_minute=0;
      t_stunde++;
    }
    if(t_stunde == 12)
    {
      t_stunde = 0;
    }

    if(t_stunde == 0 && t_minute == 0 && t_sekunde == 0)
    {
        is_am = !is_am;
    }
    
    delay(delayval);
      
    //Hier werden die Farben deiner Uhr gesetzt, je nachdem ob AM oder PM ist um den Tag und den Abend auf der Uhr unterscheiden zu koennen. :-)
    //Lege also hier die Farben für den Tag fest 
    //BGR anstatt RGB
    if(is_am)
    {      
      leds.setPixelColor(t_sekunde/5, leds.Color(0,255,0)); 
      leds.setPixelColor(t_minute/5, leds.Color(80,40,0)); 
      leds.setPixelColor(t_stunde, leds.Color(0,102,0)); 
    }
    //Lege Hier die Farben für die Nacht fest. 
    else
    {
      leds.setPixelColor(t_sekunde/5, leds.Color(0,0,255)); 
      leds.setPixelColor(t_minute/5, leds.Color(50,0,50)); 
      leds.setPixelColor(t_stunde, leds.Color(0,0,102)); 
    }

    //Hier werden die Farben fuer die Faelle gesetzt wenn die Zeiger uebereinanderlegen. 
    if(t_sekunde/5 == t_minute/5)
    {
      leds.setPixelColor(t_sekunde/5, leds.Color(10,10,0));
    }
      
    if(t_sekunde/5 == (t_stunde%12)) 
    {
      leds.setPixelColor(t_sekunde/5, leds.Color(10,0,10));
    }
        
    if(t_minute/5 == t_stunde%12) 
    {
      leds.setPixelColor(t_stunde%12, leds.Color(0,10,10));
    }
        
    if(t_sekunde/5 == t_minute/5 && t_sekunde/5 == t_stunde%12)
    {
      leds.setPixelColor(t_stunde%12, leds.Color(20,20,20)); 
    }       
    leds.show(); // This sends the updated pixel color to the hardware.
  }
}

Schauen wir uns jetzt mal den Programmcode im einzelnen an. Dabei fangen wir mit dem Kopf und der sogennaten "Initialisierungsphase" an. In den ersten beiden Zeilen sehen wir einen sogenannten Kommentar. Diese erkennt man immer durch die offensichtlichen "//" am Anfang einer Zeile. Damit wird bei der Ausführung gesagt, dass der Inhalt einer Zeile welche mit "//" beginnen, nicht zum ausführbaren Programm gehört und somit nicht ausgeführt wird. Kommentare können verwendet werden, um Informationen in den Code einzufügen, der diesen beispielsweise besser erklären soll für andere Entwickler. In unserem Beispiel steht in unserem Kommentar-Kopf wer der Autor ist und unter welcher Nutzungslizenz dieses Programmcode verwendet werden kann. In Zeile 3 findet ihr dann ein sogenanntes #include. Dieses besagt, dass eine externe Datei in unserem Beispiel die "Adafruit_NeoPixel.h" eingebunden wird. Beim Ausführen wird somit nicht nur unsere clock.ino Datei sondern auch die Adafruit_NeoPixel.h geladen. Der Vorteil davon ist, dass wir nun auf Inhalte dieser zugeladenen Datei zugreifen können.

// NeoPixel Ring Clock sketch (c) 2016 W. Daniel Scherz
// released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library
#include 

// Which pin on the Arduino is connected to the NeoPixels?
#define PIN            0

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS      12

// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use to send signals.
Adafruit_NeoPixel leds = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_RGB + NEO_KHZ800);

int delayval = 1000;

In Zeile 6 sehen wir das Schlüsselwort #define. Dieses wird verwendet um sogennante Konstanten zu setzen. Bei Konstanten handelt es sich um Platzhalter für konkrete Werte. Dabei wird nach dem define ein Platzhalterwort folgend von dem konkretem Wert gesetzt. Zum besseren Verständnis können wir es in unserem Beispiel folgendermaßen aussprechen: "Ich definiere, dass für das Platzhalterwort PIN der Wert 0 gesetzt wird". Ihr könnt nun in eurem Programmcode, das Wort PIN verwenden, was dann immer dem Wert 0 entspricht.

Für unsere LED-Watch sind die beiden Konstanten, welche in den Zeilen 6 & 9 definiert werden wichtig. Bei PIN handelt es sich um die Nummer des Kanals auf dem Board, welche unseren LED-Pixel-Ring anspricht. Bei NUMPIXELS handelt es sich um die Anzahl der LEDs auf dem Ring. In unserem Fall ist es 12, representativ für die Anzahl der Stundenwerte auf einer regulären Analog-Uhr. In Zeile 12 laden wir die einzelnen LEDs, dies ist notwendig damit wir eine Verbindung zu den einzelnen Lichtern haben. Dabei verwenden wir eine sogenannte Funktion, welche kleinere Programmteile beinhaltet. In diesem Fall greifen wir auf eine sogenannte "externe Funktion" zu. Dabei handelt es sich um eine Funktion, die sich in einer anderen Datei befindet. In unserem Fall in der Adafruit_NeoPixel.h. Von dort verwenden wir die Funktion Adafruit_NeoPixel und sagen ihr, dass wir 12 LEDs haben (NUMPIXELS) und diese über die Verbindung PIN (0) angesprochen werden. Anschließend setzen wir noch eine Variable mit dem Namen delayval in Zeile 14. Das Prinzip bei einer Variable ist ähnlich wie bei einer Konstanten. Der Unterschied hier besteht jedoch darin, dass sich eine Variable während der Programmausführung verändern kann. Der Wert 1000 der für delayval zugewiesen wird, repräsentiert die Anzahl der Milisekunden für eine Sekunde. Dies wird später verwendet um daraus unsere Minuten und Stunden zu "errechnen". Computer arbeiten nicht mit Sekunden sondern basieren bei Zeitintervallen auf Milisekunden. Somit wäre unsere Initialisierungsphase, also das setzen unserer Basiswerte, abgeschlossen und wir können mit der Funktionalität der LED-Watch fortfahren.

Nach der Initialisierungsphase wird eine sogenannte Vorbereitungsphase durchgeführt. Dabei werden Standardfunktionen ausgeführt, um den eigentlichen Programmablauf vorzubereiten. Wie bereits erwähnt sind Funktionen eine Art Zusammenfassung von Codesegmenten welche mit einem Namen versehen werden können um die Übersichtlichkeit zu erhöhen.

void setup()
{
  leds.begin(); // This initializes the NeoPixel library.
}
 
void loop() 
{
  startClock();
}

In Zeile 16 sehen wir die Funktion setup(), welche dazu dient den eigentlichen Start des Programms einzuleiten. Hier werden unserer LEDs in Zeile 18 angeschaltet, sodass wir diese später verwenden können. Die Funktion loop() (Zeile 21) ist unser eigentlicher Startpunkt. Alles was sich innerhalb dieser Funktion befindet, wird als "Programmausführung" bezeichnet. Hier befindet sich die eigentlich Funktionalität des Programms. In unserem Beispiel wird die Funktion startClock() aufgerufen, welche wir uns als nächstes anschauen werden.

Schauen wir uns nun die startClock() Funktion an. Hier findet unserer eigentlich Funktionalität statt. Dabei starten wir wieder mal mit einer Initialisierung. Dabei setzen wir in Zeile 28 die Variable is_am auf true. True bedeutet, dass diese Aussage wahr ist. In unserem Fall können wir es folgendermaßen sagen: Ich sage, dass die Aussage, welche Vormittags (is_am) ist, der Wahrheit (true) entspricht. Wahrheitswerte werden in der Informatik oftmals verwendet um (Wahrheits)prüfungen durchzuführen, was wir uns später anschauen werden. Im Anschluss setzen wir drei weitere Variablen: t_stunde, t_minute, t_sekunde. Dabei handelt ist sich um die Start- bzw. Wunschuhrzeit, die verwendet werden will für unsere LED-Watch. Diese Variablen werden später verwendet um die aktuelle Uhrzeit zu repräsentieren.

void startClock()
{
  boolean is_am = true;
   
  //WICHTIG: Setze hier deine gewuenschte Uhrzeit. z.B. t_stunde = 17,  t_minute = 45,  t_sekunde = 17
  int t_sekunde = 30;
  int t_minute = 13;
  int t_stunde = 23;
 
  //Zwischen 0:00 Uhr und 11:59 Uhr ist AM. Zwischen 12:00 und 23:59 Uhr ist PM.
  if(t_stunde >= 12)
  {
    t_stunde = t_stunde % 12;
    is_am = false;
  }

Kommen wir nun zur Zeile 36. Hier handelt es sich um eine sogennante Abprüfung (Bedingung), gekennzeichnet durch das Schlüsselwort if (engl. falls). Mit diesen Abprüfungen kann man validieren ob eine Aussage zutrifft oder nicht. In unserem Beispiel prüfen wir ab ob die Variable t_stunde > (größer) oder = (gleich) 12 ist. Dies wird gemacht um zu prüfen ob wir uns am Vor- bzw. Nachmittag befinden. Ist die Bedingung erfüllt wird der dahinterstehende Code, innerhalb der geschweiften Klammern, ausgeführt. In unserem Fall wird eine sogennante Modulo-Operation ausgeführt (t_stunde % 12). Dabei wird der Wert in t_stunde durch 12 geteilt, aber statt zu schauen was das Teilungsresultat ist, wird die Differenz von t_stunde und dem größten gemeinsamen Teiler betrachtet. Beispiel: In t_stunde befindet sich der Wert 17. Rechnen wir nun t_stunde % 12, erhalten wir als Ergebnis den Wert 5 (also den Rest der Division). Da, 17:12 = 1 => 17 - (12 * 1) = 5. Somit können wir sagen, dass 17 Uhr das selbe bedeutet wir 5 Uhr nachmittags. Anschließend überschreiben wir die Variable is_am mit false (unwahr) und berichten so, dass wir uns nicht im Vormittag befinden.

Betrachten wir uns nun die Logik der Uhr. Wir starten mit einer sogennanten Schleife. Bei einer Schleife handelt es sich um eine Art endliche Wiederholung von gleichen Aufgaben bzw. Programmcode, welcher sich in geschweiften Klammern dahinter befindet. In unserem Fall handelt es sich sogar um eine sogennante Endlosschleife da while(true) (Die schleife darf unendlich laufen) gegeben ist. Eine Endlosschleife kann vom eigenen Programm nicht beendet werden sondern lediglich vom Benutzer oder dem Computer auf dem das Programm läuft, wenn es das Programm beenden. Alle Zeilen innerhalb der Endlosschleife werden also permanent hintereinander ausgeführt.

In Zeile 45 setzen wir die Helligkeit der LEDs auf einen konkreten Wert. Im Anschluss überschreiben wir alle bis dahin leuchtenden LEDs (Zeilen 48 - 50) wieder zurück, sodass diese aussehen als wären sie aus. Eigentlich sind diese LEDs nicht aus, sondern werden jediglich mit der Farbe schwarz gesetzt. Dies seht ihr an der Anweisung leds.Color(0,0,0). Die drei Nullen stellen den sogennante RGB-Farbraum dar. Zum Erstellen einer Farbe wird auf die Mischung drei Grundfarben Rot, Grün und Blau zurückgegriffen. Dies ist ein herkömmliches Verfahren um Farben in Computern zu repräsentieren. Zahlreiche RGB Generatoren findet ihr im Internet. Im Anschluss wird unsere t_sekunde Variable um +1 hochgezählt. Der Einfachheithalber wird in der Informatik das hoch zählen um eins, durch ein "++" abgekürzt.

 while(true)
  {
    //Setze hier die Helligkeit deiner LEDs herunter sonst erblindest du auf Dauer! :-D
    leds.setBrightness(120);
     
    //  Hier wird zuerst die alte Anzeige geloescht
    leds.setPixelColor(t_sekunde/5, leds.Color(0,0,0)); // Moderately bright green color.
    leds.setPixelColor(t_minute/5, leds.Color(0,0,0)); // Moderately bright green color.
    leds.setPixelColor(t_stunde, leds.Color(0,0,0)); // Moderately bright green color.
    t_sekunde++;
 
    //Hier ist die Logik der Uhr. Wenn du das veraenderst, wird es ziemlich chaotisch. :-)
    if(t_sekunde == 60)
    {
      t_minute++;
      t_sekunde = 0;
    }
    if(t_minute == 60)
    {
      t_minute=0;
      t_stunde++;
    }
    if(t_stunde == 12)
    {
      t_stunde = 0;
    }
 
    if(t_stunde == 0 && t_minute == 0 && t_sekunde == 0)
    {
        is_am = !is_am;
    }
     
    delay(delayval);

Zwischen den Zeilen 54 - 72 findet die eigentlich Logik der Uhr statt. Wie ihr seht, werden hier einige unserer bereits erwähnten Abprüfungen vorgennommen. In unserer ersten Abprüfung (Zeilen 54 - 58) schauen wir ob unsere aktuelle Sekundenzahl gleich 60 entspricht. Also ob 60 Sekunden und somit 1 Minute vergangen sind. Ist dies der Fall erhöhen wir unsere Minuten um 1 (Zeile 56) und setzen unsere Sekunden wieder zurück auf 0 um zur nächsten Minute zu zählen. Die Abprüfung in den Zeilen 59 - 63 findet etwas ähnliches statt. Hier betrachten wir jedoch die Minuten. Falls 60 Minuten durchgelaufen sind, erhöhen wir unsere Stunden-Variable und setzen unsere Minuten-Variable um wieder bis zur nächsten Stunde zählen zu können. Daraufhin prüfen wir ab ob die Stundenanzahl bei 12 ist, ist dies der Fall setzen wir diesen Wert auf 0, gefolgt von der Abprüfung ob Stunden, Minuten und Sekunden alle 0 sind. Was bedeutet, dass wir entweder Mittag oder Mitternacht erreicht haben. Dies erreichen wir indem wir den aktuellen Wert nehmen der in is_am drinnen steht und den umgekehrten Wert (also wahr wird zu falsch) wieder reinspeichern. Dies wird bei der Programmierung durch das führende "!" Ausrufezeichen vor einem Variablennamen gekennzeichnet. Abgeschlossen wird dieser Code-Teil durch delay(delayval). Die Funktion delay, ist eine externe Funktion die verwendet werden kann. Diese unterbricht das laufende Programm für eine gewisse Zeit und zwar diejenige, die in der Variable delayval gegeben ist. In unserem Beispiel entspricht das dem Wert 1000. Somit wird das Programm um 1000 Milisekunden bzw. 1 Sekunde angehalten, bevor das Programm wieder von vorne anfängt. 

Nachdem wir uns nun um die Programmlogik gekümmert haben, betrachten wir nun den kreativen Part: Das färben unserer LEDs. Dabei verwenden wir den restlichen gegebenen Programmcode. Kümmern wir uns nun um unserer Farben. Dabei wollen wir die Farbgebung ändern, je nachdem ob es Vormittag oder Nachmittag ist. Dafür benötigen wir mal wieder einige Abprüfungen.

    //Hier werden die Farben deiner Uhr gesetzt, je nachdem ob AM oder PM ist um den Tag und den Abend auf der Uhr unterscheiden zu koennen. :-)
    //Lege also hier die Farben für den Tag fest 
    //BGR anstatt RGB
    if(is_am)
    {      
      leds.setPixelColor(t_sekunde/5, leds.Color(0,255,0)); 
      leds.setPixelColor(t_minute/5, leds.Color(80,40,0)); 
      leds.setPixelColor(t_stunde, leds.Color(0,102,0)); 
    }
    //Lege Hier die Farben für die Nacht fest. 
    else
    {
      leds.setPixelColor(t_sekunde/5, leds.Color(0,0,255)); 
      leds.setPixelColor(t_minute/5, leds.Color(50,0,50)); 
      leds.setPixelColor(t_stunde, leds.Color(0,0,102)); 
    }
 
    //Hier werden die Farben fuer die Faelle gesetzt wenn die Zeiger uebereinanderlegen. 
    if(t_sekunde/5 == t_minute/5)
    {
      leds.setPixelColor(t_sekunde/5, leds.Color(10,10,0));
    }
       
    if(t_sekunde/5 == (t_stunde%12)) 
    {
      leds.setPixelColor(t_sekunde/5, leds.Color(10,0,10));
    }
         
    if(t_minute/5 == t_stunde%12) 
    {
      leds.setPixelColor(t_stunde%12, leds.Color(0,10,10));
    }
         
    if(t_sekunde/5 == t_minute/5 && t_sekunde/5 == t_stunde%12)
    {
      leds.setPixelColor(t_stunde%12, leds.Color(20,20,20)); 
    }       
    leds.show(); // This sends the updated pixel color to the hardware.
  }
}

Betrachen wir uns erstmal die Zeile 79. Hier wird geprüft ob wir uns im Vormittag (is_am = true) oder im Nachmittag (is_am = false) befinden. Befinden wir uns im Vormittag, werden dementsprechend die Farben der LEDs gesetzt. Ist dies nicht der Fall, befinden wir uns also im Nachmittag. Man führt dann nicht der Teil in den geschweiften Klammern des if statt sondern den hinter dem else (andernfalls/oder) Keyword aus. Vorstellen kann man es sich so: "Wenn (if) es vormittags ist, dann für den code direkt hinter den geschweiften Klammern aus, andernfalls (else) den anderen". In den restlichen vier Abprüfungen (Zeilen 94 - 112) geht es darum abzuprüfen ob Zeiger übereinander stehen wie Beispielsweise 17:25 Uhr. Für solche Fälle werden die LEDs dementsprechend gefärbt. Last but not least der Befehl in Zeile 113: leds.show(). Diese Funktion muss aufgerufen werden um den LEDs mitzuteilen, dass es ein neues Farbschema gibt, was dargestellt werden soll. Ihr updated somit die LEDs zu euren gewünschten Farben, die ihr programmiert habt.

Thats It

Das wars, nun habt ihr das Basiswissen, was ihr benötigt wird um eure LED-Watch nach euren Wünschen zu gestalten. Ihr könnt eure eigenen Farbschemen definieren, könnt aber auch eigene Effekte einbauen wenn beispielsweise zwei Zeiger übereinander liegen, alle anderen LEDs anschalten und nur die überlappenden ausschalten usw. Wollt ihr statt einer Uhr vielleicht lieber einen Countdown-Timer? Kein Problem! Euch sind keine Grenzen gesetzt, was die Kreativität angeht. Bastelt und experimentiert herum. Das ist ja auch ein wesentlicher Teil, den die Informatik ausmacht. Habt ihr etwas cooles gebastelt? Dann teilt es mit uns, macht ein Foto oder Video und schickt es uns per Mail oder direkt über unsere Accounts auf Facebook, Twitter und Youtube. Wir freuen uns auf eure Beiträge und wünschen euch #HappyCoding

Continue reading
Rate this blog entry:
0
1585 Hits 0 Comments