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.

Einmal Unterbodenwäsche bitte – Chassis für einen Roboter

Ich konnte endlich meinen kleinen fahrenden Roboter weiterbauen. An elektrischen Komponenten habe ich so gut wie alles. Nun habe ich einen Prototypen des Unterbodens gedruckt. Die Form ist recht simple. Aber der Druck war nicht ganz so einfach. Der Unterboden hat eine Fläche von ca 12 cm x 15 cm. Ab ca 8 mm Druckhöhe fing das ganze Modell an, stark zu verbiegen (warpen). Erst den dritten Versuch konnte ich bis zum Ende drucken lassen.

Chassis

Die vier Motoren schnappen gut in die dafür vorgesehenen Halterungen. Ein kleiner Arduino fungiert als Hirn. Die grüne Platine daneben ist ein Motortreiber (H-Brücke). Es fehlt noch ein Funkmodul (die erste Version soll erst mal nur fernsteuerbar sein) und der Akku, welcher oben festgeschnallt wird.

Später kommen noch IR- und Ultraschall-Sensoren hinzu.

Ziel ist es später, dass der Roboter dann vor einem näher kommenden Objekt davon fährt und bei Umrundungen stehen bleibt. Ein Schafersatz für meine Hunde.