Aus DEFCON wird Busy Lamp

Der Anfang der Busy Lamp

Aus dem  Hundeblinklicht ist DEFCON entstanden. Nun wird aus DEFCON die Busy Lamp. Eigentlich ist es nur eine simple Umbenennung. Der Begriff DEFCON war für die Signallampe dann doch nicht ganz korrekt.

Einige Iterationen der Busy Lamp

Das Hundeblinklicht

Ich hatte zuerst mit ein paar LEDs und einem kleinen Arduino Klon rumgespielt. Das war im Herbst 2014. Die Tage wurden kürzer und unsere Hunde waren beim Spazieren gehen nicht mehr gut zu sehen. Aus der Spielerei ist dann ein praktischer Nutzen entstanden. Mit den LEDs, die man am Hundegeschirr befestigt hat, waren die Hunde dann wieder im Dunkeln sichtbar. Ein kleiner Kniff hat geholfen, dass die LEDs nicht im langen Fell verschwunden sind, wie sonst alle Hundelichter, die wir vorher gekauft hatten. Das Gerät hat einfach ein paar länge Arme auf zwei Seiten bekommen. Auf diese Weise ragt mindestens einer der Arme aus dem Fell hervor und ist somit sichtbar. Die Versionen sind dann immer kleiner und stabiler geworden. Selbst der Lithium-Akku ist nun kleiner als die Fingerspitze des kleinen Fingers. Trotzdem kann die Lampe ca. 48 Stunden lang am Stück betrieben werden.

 

Im Frühling 2015 war dann Version 6 fertig, die immer noch in Gebrauch ist.

DEFCON

Im Spätsommer 2015 fing das DEFCON Projekt an. Daraus ist dann ein Signallicht entstanden, mit dem man anderen mitteilen konnte, ob man gerade gestört werden  darf oder nicht. Den Begriff „Busy Lamp“ kannte ich da gar nicht, bzw. ich wusste nicht, dass es sowas in der Art schon gibt. Die letzte Version der DEFCON Lampe (erstes Bild, zweite von links), hatte dann einen ATTiny 85 statt eines Arduino Klones.

Das hatte Ersten den Vorteil, dass es viel günstiger wurde und zweitens wurde es auch einfacher aufzubauen. Der ATTiny läuft direkt mit der Spannung von 3.7 V aus dem Lithiumakku. Mit dem Arduino, der mindestens 5 V benötigt, musste ich die Akku-Spannung erst von 3.7 V auf 5 V bringen.

Der Nachteil war, dass die Programmierung etwas aufwändiger wurde. Aber das hatte ich als Herausforderung gesehen und so viele Funktionen wie möglich auf den kleinen Chip mit den 8 Beinchen gepackt. Sechs Taster und fünf LEDs auf nur 8 Anschlüsse, wovon zwei schon für die Stromversorgung sind und einer für ein Resest, bleiben Effektiv nur 5 Pins zum belegen übrig.

Die Busy Lamp

Erste in diesem Herbst (2017) bin ich dazu gekommen, die Idee der DEFCON Lampe weiterzuentwickeln. Das erste Gehäuse habe ich von der letzten Version der DEFCON Lampe (erstes Bild, zweite von Links) abgeleitet. Herausgekommen ist dann ein mehrteiliges Gehäuse (erstes Bild, Mitte). Sinn und Zweck der Aufteilung war, dass bei einem Fehldruck nicht so viel weggeschmissen werden muss und dass man den oberen Teil mit den LEDs abtrennen kann und in einiger Entfernung zu den Tastern aufstellen kann. LED Teil und Taster-Teil werden durch ein paar dünne Leitungen verbunden. Sehr schnell folgte dann eine etwas fortgeschrittenere Version.

Gedruckte Teile der Busy Lamp

Das wurde dann aber dann irgendwie zu viele Einzelteile, die zwar schon zusammengepasst haben, aber dann im Zusammenbau zu viel Arbeit machten.

Zusammengebaute Busy Lamp

Also noch einmal ans Zeichenbrett und alles einfacher machen. Herausgekommen ist dann ein Gehäuse, was dann nur noch aus 4 gedruckten Teilen besteht. Hinzu kommt, dass auch nur noch zwei Taster, statt der zuvor genutzten 4 Taster benutzt werden. Das Gehäuse ist nun viel kleiner, was die Druckzeit und die Materialkosten enorm senkt.

Aktuelle Version der Busy Lamp – im DnD Modus

Das Teil mit den LEDs und das Teil mit den beiden Tastern sind über Magnete miteinander verbunden. Über das Kabel, was vorne rausguckt, gehen dann die Signale für die LEDs. Wenn man die beiden Teile trennt, kann man die LEDs an einer anderen magnetischen Fläche aufstellen. Beispielsweise sind die Monitore bei uns in der Firma am Rand magnetisch, so dass die LEDs oben am Monitor mit den Magneten halten. So sind sie dann auch für alle anderen gut sichtbar.

Das Gehirn

Als Gehirn habe ich einen Teensy LC benutzt. Man kann auch andere noch günstigere Boards nutzen. Ich fand nur gut, dass ich alle 8 LEDs, die in der Busy Lamp verbaut sind, mit einem eigenen PWM Kanal ansteuern kann. Insgesamt stehen hier 10 PWM Kanäle zur Verfügung. Mehr als genug also. Mit seinen 48 MHz Taktrate ist der kleine Teensy LC auch sehr schnell und trotzdem noch sparsam im Stromverbrauch.

In einer ganz frühen Version hatte ich noch einen Adafruit Feather M0 mit Radio Package benutzt. Da sollten die LEDs und die Taster ohne Kabel per Funk miteinander verbunden sein. Hat auch geklappt. War aber nur zu teuer, auch wenn diese Boards echt vollgepackt sind mit Features. Z.B. integriertes Lithium-Ladegerät.

Konnektivität

Ja, schönes Wort. Die Busy Lamp lässt sich auch mit dem Computer verbinden. Über ein kleines selbst geschriebenes Programm kann der Status der Busy Lamp dann über Computer verändert werden. Zusätzlich kann man meine Busy Lamp auch mit Skype verbinden. Die Busy Lamp zeigt dann den Status an, den man auch in Skype hat. In die andere Richtung geht es auch. Ändert man den Status der Lampe per Tastendruck, ändert sich auch entsprechende der Status in Skype.

Fazit

Mittlerweile haben alle Kollegen in meiner Abteilung in der Firma diese Busy Lamp. Jetzt läuft die Beta im Feld. Wir haben uns darauf geeinigt, was die Farben der Busy Lamp bedeuten sollen. Ich bin gespannt, ob es läuft wie erwartet. Halten sich die Leute an die Farben? Wird die Busy Lamp überhaupt genutzt? Treten Bugs in der Software auf? Wie lange hält die Hardware?

Blinklicht für Hunde

Es ist dunkel. Wenn man nicht vor 16 Uhr mit den Hunden draußen war, muss man selber für Licht sorgen. Unsere Hunde haben ein kleines Licht an ihrem Geschirr hängen. Nur wird dieses Licht durch das lange Fell überdeckt und das Licht ist auch nicht von allen Seiten sichtbar.  Wäre schön, wenn man das ändern könnte, damit die Hunde von anderen Verkehrsteilnehmern besser wahrgenommen werden können.

Ich habe hier noch einige LED rumliegen, auch ein paar Arduino-Klone habe ich noch auf Lager. Also schnell ein kleines Gehäuse ausgedruckt und die Elektrik reingequetscht. Als Spannungsquelle nutze ich einen kleinen 300 mAh Lithuim-Akku. Bei meiner gegenwärtigen Konfiguration hält dieser 3 Stunden durch. Das ist ausreichend für einen Spaziergang. Die Spannung des Akkus (3.6V -4.2V) wird durch einen Pololu 5V Step-Up Schaltregler (U1V11F5) auf 5V gebracht. Damit funktioniert der Bladuino, der eine Betriebsspannung von 5V bis 12V hat.

An die PWM Ausgänge (Pin 3, 5, 6, 9, 10 und 11) habe ich jeweils eine LED angeschlossen. Diese lassen sich nun bequem mit digitalWrite(LED, VALUE); in der Helligkeit regeln.  Dies ist auch wichtig, da die Ausgänge mit 5 V laufen. Die LED haben eine Betriebsspannung von ca 2,6V. Da ich die LED ohne Vorwiderstand eingelötet habe, fließt bei maximaler Helligkeit ein zu hoher Strom, der die Lebensdauer der LED herabsetzt.

 

Geschlossener Blinker
Geöffneter Blinker ohne Akku.

In dem Video habe ich einen größeren Akku angeschlossen, da der kleine nach 3 Stunden Dauertest erst mal wieder aufgeladen werden musste.

Hier das Programm, was ich zur Zeit nutze.

/*
hundeblink
@autor: Marcus Guin Kluetmann

Für die Funktion des Buttons wurde das „Debounce“ Beispiel

http://www.arduino.cc/en/Tutorial/Debounce
created 21 November 2006
by David A. Mellis
modified 30 Aug 2011
by Limor Fried
modified 28 Dec 2012
by Mike Walters

genutzt und angepasst.

*/
int PWM1 = 3; // PWM LED
int PWM2 = 5; // PWM LED
int PWM3 = 6; // PWM LED
int PWM4 = 9; // PWM LED
int PWM5 = 10;// PWM LED
int PWM6 = 11;// PWM LED
int LED1 = 4;
int LED2 = 7;
int LED3 = 12;
int LED4 = 13;
long flash;
long blinki = 4000; // Flash-Intervall
int hell = 250; // Maximalhelligkeit der PWM LED
int dunkel = 2; // Minimalhelligkeit der PWM LED
int mittel = 10;// Mittlere Helligkeit nach dem Blitz für PWM LED
int buttonPin = 2;
int buttonState; // the current reading from the input pin
int lastButtonState = LOW; // the previous reading from the input pin
long lastDebounceTime = 0; // the last time the output pin was toggled
long debounceDelay = 50; // the debounce time; increase if the output flickers
int ledState = LOW;

// the setup function runs once when you press reset or power the board
void setup() {
pinMode(buttonPin, INPUT_PULLUP); // interner PullUp Widerstand wird genutzt.
pinMode(PWM1, OUTPUT);
pinMode(PWM2, OUTPUT);
pinMode(PWM3, OUTPUT);
pinMode(PWM4, OUTPUT);
pinMode(PWM5, OUTPUT);
pinMode(PWM6, OUTPUT);
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(LED3, OUTPUT);
pinMode(LED4, OUTPUT);
flash = millis();
}

// the loop function runs over and over again forever
void loop() {
// read the state of the switch into a local variable:
int reading = digitalRead(buttonPin);

// check to see if you just pressed the button
// (i.e. the input went from LOW to HIGH), and you’ve waited
// long enough since the last press to ignore any noise:

// If the switch changed, due to noise or pressing:
if (reading != lastButtonState) {
// reset the debouncing timer
lastDebounceTime = millis();
}

if ((millis() – lastDebounceTime) > debounceDelay) {
// whatever the reading is at, it’s been there for longer
// than the debounce delay, so take it as the actual current state:

// if the button state has changed:
if (reading != buttonState) {
buttonState = reading;

// only toggle the LED if the new button state is HIGH
if (buttonState == HIGH) {
ledState = !ledState;
off(); // beim Statuswechsel werden alle LEDs ausgeschaltet.
}
}
}

// set the LED-Mode
if (ledState) normalBlink();
else licht();
// save the reading. Next time through the loop,
// it’ll be the lastButtonState:
lastButtonState = reading;
}

void off(){
// Vor dem Umschalten von Blinken auf Dauerlicht sollen alle LED dunkel sein.
digitalWrite(LED1, LOW);
digitalWrite(LED2, LOW);
digitalWrite(LED3, LOW);
digitalWrite(LED4, LOW);
digitalWrite(PWM1, LOW);
digitalWrite(PWM2, LOW);
digitalWrite(PWM3, LOW);
digitalWrite(PWM4, LOW);
digitalWrite(PWM5, LOW);
digitalWrite(PWM6, LOW);
}

void licht(){
// Die 4 nicht PWM LEDs werden eingeschaltet.
digitalWrite(LED1, HIGH);
digitalWrite(LED2, HIGH);
digitalWrite(LED3, HIGH);
digitalWrite(LED4, HIGH);

}

void normalBlink(){
if(millis()-flash>blinki){
if(millis()-flash>(blinki+10)) flash = millis(); // Nach 10 Millisekunden soll der Blitz wieder ausgehen
analogWrite(PWM1, hell);
analogWrite(PWM2, hell);
analogWrite(PWM3, hell);
analogWrite(PWM4, hell);
analogWrite(PWM5, hell);
analogWrite(PWM6, hell);
}else if(millis()-flash>(blinki/4)){
// Nach dem Blitz leuchten die PWM LEDs etwas heller,
// danach werden sie auf ein Minumum abgedunkelt.
analogWrite(PWM1, dunkel);
analogWrite(PWM2, dunkel);
analogWrite(PWM3, dunkel);
analogWrite(PWM4, dunkel);
analogWrite(PWM5, dunkel);
analogWrite(PWM6, dunkel);
}else {
analogWrite(PWM1, mittel);
analogWrite(PWM2, mittel);
analogWrite(PWM3, mittel);
analogWrite(PWM4, mittel);
analogWrite(PWM5, mittel);
analogWrite(PWM6, mittel);
}
}

Den Taster zum Umschalten von Blink- auf Dauerlicht habe ich nicht dauerhaft angeschlossen.

Als nächstes muss ich ein stabiles Gehäuse für den Ausseineinsatz ausdrucken.