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.

Bladuino – das kleine elektronische Gehirn

Gestern sind meine 10 Bladuino Pro mini angekommen. Der Bladuino ist, wie der Name vermuten lässt, ein Arduino-Klon.

Entstanden sind die Bladuino in einem Crowdfunding Projekt auf Indiegogo.


Ein Adapter zum Programmieren der Bladuinos war auch dabei. Dieser ist notwendig, da der Bladuino keine eigene USB-Schnittstelle hat. Der Adapter ist ein CP2102 von Silabs. Die Treiber gibt es hier: Treiberdownload beim Hersteller

Die Programme werden gewohnt über die Arduino IDE geschrieben und zum Bladuino hochgeladen. Hierbei muss man ein paar Dinge beachten.

Das richtige Bord auswählen: Der Bladuino ist ein Arduino Pro Mini 5 V mit einem ATmega 328
Port: Hier muss der vom System vergebene Port für den Adapter eingetragen werden. Wenn in der IDE sehr viele Ports angezeigt werden, kann man entweder im Gerätemanager den Port nachschauen, oder man zieht den Adapter einmal vom Computer ab und guckt nach, welcher der vielen Ports nicht mehr angezeigt wird. Danach den Adapter wieder reinstecken und Port wählen.

Der Adapter muss auch noch mit dem Bladuino verbunden werden. Laut Bladuino Projekt gilt folgende Belegung:

Pin-Belegung für den USB Adapter

Bladuino

Hier begannen dann meine Probleme. Nachdem ich den Adapter wie auf dem Bild gezeigt mit dem Bladuino verbunden habe, bekam ich immer eine Fehlermeldung, wenn ich ein Programm zum Bladuino transferieren wollte.

stk500_getsync(): not in sync: resp=0x00

In diversen Foren fand ich verschiedene Lösungswege, die bei dir jedoch nicht halfen. Dort wurde immer wieder darauf hingewiesen, dass man das richtige Bord und den richtigen Port auswählen muss. Dies war bei mir auf jeden Fall richtig eingestellt. Treiber waren auch installiert und Windows hat den Adapter erkannt. Auch mehrmaliges Versuchen inklusive ab und wieder einstecken des Adapters half nicht.

Dann fand ich den Hinweis, dass man bei einigen Bords einen manuellen Reset durchführen muss, wenn man ein Programm hochladen möchte. Eigentlich sollte das beim Bladuino nicht nötig sein, da dieser über einen Soft-Reset (Pin RST am Adapter) resettet werden soll. Also habe ich zu verschiedenten Zeitpunkte während des Hochladens den Resetknopf am Bladuino gedrückt. Es half einfach nicht!

Langsam begann ich glaube, dass der Adapter nicht richtig funktioniert, da dort die Daten LED niemals aufleuchtete. Dies lies mich vermuten, dass der Adapter keine Daten sendet. Aus Verzweiflung habe ich RX und TX auf einer Seite getauscht. Erst brachte es keinen Erfolg, aber als ich dann noch den manuellen Reset gemacht habe, wurde das Programm endlich übertragen.

Es traten also zwei Fehler auf

  • es muss ein manueller Reset durchgeführt werden
  • RX und TX sind an irgendeiner Stelle vertauscht

Der Bladuino hat noch jeweils einen weiteren Pin für RX und TX. Auch dort muss ich den Anschluss vertauschen. Es scheint so, als wäre die Beschriftung auf dem Adapter falsch.

Den Draht für RST (Reset) brauche ich nicht mehr anschließen, da eh ein manueller Reset durchgeführt wird. Schaden tut der Anschluss jedoch nicht. Die 5V des Adapters kann man statt mit dem RAW Pin des Bladuino auch mit VCC des Bladuinos verbinden. An den RAW Pin kann man bis zu 12 V anlegen. Dieser ist also ein bisschen sicherer, wenn die Eingangsspannung nicht geregelt ist. Bei dem Adapter sind die 5 V aus dem USB Anschluss stabil genug, um die direkt an VCC anzulegen.

 

EDIT 229.03.2014
Die Ersteller des Projektes haben nun eine eigene Seite erstellt: http://bladuino.com/