ATtiny85 Ring Watch
Eigentlich total hässlich, aber die Idee finde ich toll.
Base on the previous Instructables – ATtiny Watch Core and more, I have made a real gadget, an ATtiny85 Ring Watch.
Quelle: ATtiny85 Ring Watch
Schlagwort: ATTiny
DEFCON Ampel, die Zweite
Um den Kollegen anzuzeigen, dass man gerade nicht unbedingt gestört werden möchte, habe ich eine kleine Ampel in Anlehnung an die DEFCON Einteilung (Grün und Blau sind getauscht) gebastelt.
Zuerst hatte ich als Gehirn der Schaltung einen Arduino Mini Pro verwendet. Da ich nur die 5V Version besitze und das Ganze mit einem kleinen Lithium-Akku betreiben wollte, brauchte ich auch noch einen Step-Up Wandler auf 5V. Die Billigdinger, die ich hier rumliegen habe, taugen aber leider nicht viel. Sie machen zwar, was sie sollen und es funktioniert auch, aber sie geben einen fiesen Pfeifton von sich. So kann die Ampel dann nicht auf dem Schreibtisch stehen.
Also habe ich mir eine andere Möglichkeit überlegt. Mein Hundeblinklicht habe ich auch von Arduino Mini Pro auf ATTiny85 gewechselt. So wollte ich es nun auch machen. Hab zwar nur noch einen ATTiny 45 hier liegen, der ist aber auch nicht viel anders als der 85er. Der ATTiny45 hat insgesamt 8 Pins. Zwei dienen der Spannungsversorgung und ein weiterer kann nicht so ohne weiteres als Aus- oder Eingang verwendet werden. Der RESET Pin. Den brauche ich, so wie er ist, zum Programmieren des ATTiny. Bleiben also noch 8 minus 3 also 5 Pins über. 3 LEDs und zwei Taster wären dann auf traditionelle Weise möglich. Das war mir bedeutend zu wenig. Immerhin hatte ich bereits 5 LEDs und 6 Taster in der ersten Version eingebaut.
Über Spannungsteiler kann man unterschiedliche Spannungen am Analogeingang anlegen und im Code auswerten. Das erfordert zwar ein bisschen mehr externe Beschaltung, dafür ist die Anzahl der Taster dann nicht mehr begrenzt (praktisch wird es bei > 20 Tastern schon schwierig). Das Ganze erfordert dann auch nur noch einen Pin.
Dann sind nun noch 4 Pins frei. 3 LEDs mit PWM sind mit Bordmitteln machbar oder ich verzichte auf PWM und habe dann 4 LEDs. Dennoch habe ich erst mal mit 3 LEDs und PWM angefangen. So hatten wenigstens alle 6 Taster eine Funktion.
Danach ist mir dann eingefallen, dass man LEDs antiparallel schalten kann. Einfach die Polarität tauschen und schon leuchtet die eine oder die andere LED. So wie bei Charlieplexing. In dem Fall musste ich mich dann aber vom integrierten PWM verabschieden. Mit Charlieplexing und PWM wären nur 4 LEDs möglich gewesen (beim ATTiny 45).
Statt die LED nun sanft ein und ausfaden zu lassen, blinken sie nun einfach. Mit zwei Tastern kann man die Blinkfrequenz verlangsamen oder beschleunigen. Mit übrigen zwei Tastern kann man nun das Tastverhältnis (Duty Cycle) zwischen An und Aus beeinflussen. Tja und wenn man nun die Blinkfrequenz ganz hoch setzt, hat man ein Software PWM 🙂 Ich könnte jetzt wieder das sanfte ein und ausfaden einbauen. Ich werd’s aber wohl lassen. Das Blinken und Blitzen hat auch was.
Hier der Code, den ich mit der Arduino IDE geschrieben habe. Wenn ich die Funktion analogRead(x) nun noch ersetzen kann, ist der Code auch mit anderen IDEs kompelierbar.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 |
/* DEFCON, a little traffic light like application 6 Buttons on one Pin and up to 6 LEDs on 4 Pins driven by one small ATTiny45 --- With the two big buttons you can switch from green to blue, orange, red and grey and back. With the little 4 way (actually 5 way) switch you can change blink speed and duty cycle of the blink. When the blink frequency is high enough you can use it as PWM for all connected LEDs. The buttons are connecte to just one pin (A2/PB4). With different voltage dividers per button this circuit measures different voltages on the conntected analogue pin. Depending on what voltage you measure a different action is called. @autor: Marcus Guin Kluetmann */ #define LED PORTB #define RED B0000100 #define ORANGE B0001101 #define GREEN B0000111 #define BLUE B0001011 #define GREY B0000010 #define LEDOFF B0000000 #define BUTTON A2 #define LEDS 5 #define MAXPWMCYCLES 1024 int SelectedLED; int lastButtonValue; int ButtonValue; int ReadValue; double PWMCycles; double DutyCycle; boolean RisingFallingFlag; double z; double y; void setup() { DDRB = B00001111; LED = LEDOFF;; SelectedLED = 1; ButtonValue = LOW; DutyCycle = 1; PWMCycles = 512; RisingFallingFlag = 1; z = 1; y = 1; ReadValue = 0; } void switchLED(int led){ if(z>PWMCycles){ RisingFallingFlag=false; y=1/DutyCycle; }else if(z<1){ RisingFallingFlag=true; y=DutyCycle; } if(!RisingFallingFlag){ LED = led; z-=y; }else if(RisingFallingFlag){ LED = LEDOFF; z+=y; } } void loop() { ReadValue = analogRead(BUTTON); if(ReadValue > 50 ) { if (ReadValue == lastButtonValue) { if (ReadValue < (ButtonValue-10) || ReadValue > (ButtonValue+10)) { // a little bit buffer so analogue value can shift a bit ButtonValue = ReadValue; if (ReadValue > 300 && ReadValue < 340) { if(SelectedLED > 1 ) SelectedLED--; _delay_ms(20); } if (ReadValue > 200 && ReadValue < 280) { if(SelectedLED < LEDS ) SelectedLED++; _delay_ms(20); } } } if (ReadValue > 500 && ReadValue < 520) { if(PWMCycles < MAXPWMCYCLES ) PWMCycles+=0.1; } if (ReadValue > 670 && ReadValue < 690) { if(PWMCycles > 0.9 ) PWMCycles-=0.1; } if (ReadValue > 940 && ReadValue < 980) { if(DutyCycle > 0.09 ) DutyCycle-=0.001; } if (ReadValue > 850 && ReadValue < 900) { if(DutyCycle < 4 ) DutyCycle+=0.001; } } switch(SelectedLED){ case 1: switchLED(GREEN); break; case 2: switchLED(BLUE); break; case 3: switchLED(ORANGE); break; case 4: switchLED(RED); break; case 5: switchLED(GREY); break; } lastButtonValue = ReadValue; } |
Hundeblinklicht Version 6
Mit dem Programm für das Blinklicht bin ich soweit zufrieden. Das Gehäuse lässt aber weiterhin Platz für Verbesserungen. Vor allem die Größe soll reduziert werden. Dies ist mir über die verscheidenen Versionen auch schon sehr gut gelaungen. Gerade der Sprung vom Arduino Mino Pro zum ATtiny und verkleinertem Akku hat das Gehäuse sehr schrumpfen lassen.
Zuerst hatte ich einen Arduino Mini Pro als Hirn für das Blinklicht benutzt. Der Arduino war überdimensioniert für die einfache Blinkaufgabe und hat auch zu viel Energie verbraucht.
Ein kleiner ATtiny ist völlig ausreichend und lässt das Gehäuse als auch den Stromverbauch kleiner werden.
Durch den verkleinerten Stromverbraucht konnte auch der Akku stark verkleinert werden. Ich verwende nun einen 3,7V 110 mAH Lithium Akku. Im Blinkbetrieb hat dieser Akku ca 12 Stunden durchgehalten.
Viel kleiner bekomme ich das Gehäuse nun nicht mehr. Der hintere schmale Teil wird vom Akku ausgefüllt und vorne sitzen der ATiny mit den ganzen Kablen und auch der Taster.
Jetzt muss ich mir immer noch eine gute Möglichkeit einfallen lassen, das Gehäuse bequem am Hundegeschirr zu befestigen. Bisher klebe ich den Blinki einfach mit Tesafilm an oder klette ein Klettband herum.
Für mich hilfreiche Links zum ATtiny
Ich benutze gerne den Arduino in seinen verschiedenen Formen. Alle Anschlüsse sind leicht erreichbar (steckbar) und die Programmierung mit der Arduino IDE ist für gewöhnlich auch ein Kinderspiel. Der Nachteil ist, dass so ein Arduino, auch in den kleinen Varianten, immer noch recht groß ist und auch viel Strom verbraucht. Also musste mal was Neues her. Am besten sollte es auch noch weitest gehend kompatibel mit dem Arduino sein. Da bin ich dann auch den ATtiny gestoßen. Immerhin werden auf dem Arduino auch die Chips von Atmel verbaut. Nur diesmal sollte es eben ein ATtiny statt des ATmega sein.
Den ATtiny gibt es in verschiedenen Ausführungen. Ich habe mir zum Testen einen ATtiny12, ATtiny45 und ATtiny85 besorgt. Jeweils in der Duchsteckversion mit 8 Beinchen. Von Außen sind alle Versionen gleich. Nur im Innern ergeben sich kleine Unterschiede. So hat beispielsweise der ATiny85 drei PWM Ausgänge und der ATtiny 45 nur 2.
Für mein Hundeblinklicht ist es wichtig, dass die Elektronik sparsam mit der Energie umgeht. Zusätzlich habe ich noch nach einer einfachen Möglichkeit gesucht, die Elektronik mit einem einfachen Taster statt eines Schalter abzuschalten. Der ATtiny funktioniert auch ohne Spannungsstabilisierung. 1,8 V bis 5,5 V Betriebsspannung benötigt der kleine Chip. Ideal für einen 3,7 V Lithium-Akku, dessen Spannung von 4,2 V bis ca 3,6 V geht.
Ich fassen einmal kurz meine erreichten Vorteile des ATtiny gegenüber des Arduinos auf.
- Einsparung des Schalters zum Abschalten der Elektronik
- Wegfallen des DC-DC Spannungswandlers von 3,7 V auf 5 V
- ATtiny ist bedeutend kleiner als ein ganzes Arduino Mini Bord
- ATtiny ist günstiger
- ATtiny ist stromsparender
Die Größeneinsparung ist schon enorm. Aber auch die Kosteneinsparung ist sehr gut. So ein Arduino Mini (Klon) kostet ca. 8 Euro, vielleicht auch nur 5 Euro. Der ATtiny nur um die 1 Euro. Kostenintensiv ist auch der DC-DC Wandler. Der von mir verwendete Pololu Wandler kostet um die 4 US$. Der eingesparte Schalter kostet nur ein par Cent. Aber man spart auch noch Platz im Gehäuse 🙂
Nun ist der ATtiny da. Wie soll der nun programmiert werden. Ein dafür geeigneten “Flasher” habe ich mir nicht gekauft. Mit einem Arduino soll das Ganze auch funktionieren. Also mal kurz rumgesucht und folgenden Link (neben anderen) gefunden: http://www.frag-duino.de/index.php/maker-faq/37-atmel-attiny-85-mit-arduino-arduinoisp-flashen-und-programmieren Dort wird beschrieben, was man machen muss, damit man mit Hilfe eines Arduinos den kleinen ATtiny mit Daten füttern kann. Zuerst hatte ich es mit einem Arduino Leonardo versucht, aber damit klappte es nicht. Mit einem Arduino Mega funktionierte es dann.
Danach habe ich nach einer Möglichkeit gesucht, den ATtiny in einen Energiesparmodus zu versetzten. Auch hier gibt es diverse Programmbeispiele. Angefangen habe ich mit diesem hier: http://www.arduino-hausautomation.de/2014/emils-ampel-attiny45-im-tiefschlaf/ Eine kleine Ampel wird per Knopfdruck eingeschaltet. Nach einer bestimmten Zeit wird der ATtiny wieder schlafen geschickt. Den dort abgebildeten Code musste ich noch ein bisshen anpassen, damit der ATtiny per Knopfdruck aufgeweckt und auch wieder schlafen geschickt werden kann.
Mega Duem
D53 Reset (SS)
D51 D11 (MOSI)
D50 D12 (MISO)
D52 D13 (SCK)
Gnd Gnd
+5 +5
Auch dieser Link war hilfreich: http://playground.boxtec.ch/doku.php/arduino/attiny Hier werden ein paar der ATtiny Typen verglichen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 |
/* 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. Die Methode goToSleep wurde hier entliehen http://www.arduino-hausautomation.de/2014/emils-ampel-attiny45-im-tiefschlaf/ */ #include <avr/sleep.h> #include <avr/interrupt.h> #include <util/delay.h> #include <avr/io.h> #define BODS 7 //BOD Sleep bit in MCUCR #define BODSE 2 //BOD Sleep enable bit in MCUCR uint8_t mcucr1, mcucr2; uint8_t PWM1 = PB0; // PWM LED uint8_t PWM2 = PB1; // PWM LED uint8_t LED = PB4; uint8_t buttonPin = PB2; uint8_t anzahlLED = 2; // hier die Anzahl der Array-Elemente eintragen uint8_t currentLED=0; long lauflichtTimer; int flashIntervall = 500; // Flash-Intervall uint8_t flashdauer = 50; uint8_t buttonState; // the current reading from the input pin uint8_t lastButtonState = LOW; // the previous reading from the input pin long lastDebounceTime = 0; // the last time the output pin was toggled long debounceDelay = 400; // the debounce time; increase if the output flickers uint8_t ledState = 0; boolean sleepMode = 0; ISR(INT0_vect) { analogWrite(PWM1, 10); analogWrite(PWM2, 10); digitalWrite(LED, LOW); _delay_ms(500); digitalWrite(PWM1, LOW); digitalWrite(PWM2, LOW); if(!digitalRead(buttonPin)){ analogWrite(LED, 15); // Wenn diese LED leuchtet, kann der Taster losgelassen werden, um den ATtiny aufzuwecken sleepMode = 0; while(!digitalRead(buttonPin)); } } void goToSleep(void) { GIMSK |= _BV(INT0); //enable INT0 MCUCR &= ~(_BV(ISC01) | _BV(ISC00)); //INT0 on low level ACSR |= _BV(ACD); //disable the analog comparator ADCSRA &= ~_BV(ADEN); //disable ADC set_sleep_mode(SLEEP_MODE_PWR_DOWN); sleep_enable(); //turn off the brown-out detector. //must have an ATtiny45 or ATtiny85 rev C or later for software to be able to disable the BOD. //current while sleeping will be <0.5uA if BOD is disabled, <25uA if not. cli(); mcucr1 = MCUCR | _BV(BODS) | _BV(BODSE); //turn off the brown-out detector mcucr2 = mcucr1 & ~_BV(BODSE); MCUCR = mcucr1; MCUCR = mcucr2; sei(); //ensure interrupts enabled so we can wake up again sleep_cpu(); //go to sleep cli(); //wake up here, disable interrupts GIMSK = 0x00; //disable INT0 sleep_disable(); sei(); //enable interrupts again (but INT0 is disabled from above) } void setup() { DDRB &= ~(1 << buttonPin); // pinMode(buttonPin, INPUT_PULLUP); PORTB = B0000100; //PORTB |= (1 << buttonPin); // enable pull-up resistor DDRB |= 1<<PB0; //pinMode(PWM1, OUTPUT); DDRB |= 1<<PB1; //pinMode(PWM2, OUTPUT); DDRB |= 1<<PB3 | 1<<PB4 | 1<<PB5; lauflichtTimer = millis(); } 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(); } } } // set the LED-Mode if (ledState==1){ analogWrite(LED, 2); lauflicht(); }else if(ledState==2){ dauerLicht(); }else if(ledState==3){ sleepMode=1; ledState=1; } while(sleepMode==1){ goToSleep(); _delay_ms(200); digitalWrite(LED, LOW); } // save the reading. Next time through the loop, // it'll be the lastButtonState: lastButtonState = reading; } void off(){ digitalWrite(PWM1, LOW); digitalWrite(PWM2, LOW); digitalWrite(LED, LOW); //PORTB = B0000100; //PORTB &= ~(1<<PB1); //PORTB &= ~(1<<PB0); } // LED soll im Dauerbetrieb schwach leuchten void dauerLicht(){ analogWrite(PWM1,10); analogWrite(PWM2,10); analogWrite(LED,2); } // Lässt die LEDs in der Reihenfolge, die im Array angegeben ist, für "flashdauer" // mit der Intensität "hell" nacheinander aufleuchten. // in der restlichen Zeit leuchten die LEDs mit der Intensität "dunkel" void lauflicht() { long time = millis(); if(time-lauflichtTimer>currentLED*flashIntervall && time-lauflichtTimer < currentLED*flashIntervall+flashdauer){ digitalWrite(currentLED, HIGH); } //PORTB |= 1<<currentLED; } if(time-lauflichtTimer>currentLED*flashIntervall+flashdauer && time-lauflichtTimer < (currentLED+1)*flashIntervall){ analogWrite(currentLED++,5);}//PORTB &= ~(1<<currentLED++); } if(time-lauflichtTimer>anzahlLED*flashIntervall){lauflichtTimer=millis();currentLED=0;} } |
Um den Code auf den jetzigen Stand zu bringen, musste ich einiges lesen. Auch das anfangs kryptisch wirkende Datenblatt des ATtiny hat sich mir ein wenig geöffnet. Hier ist noch ein Quellcode zu finden, in dem die Verwendung der Register ausführlich beschrieben ist: http://matt16060936.blogspot.de/2012/04/attiny-pwm.html
Zu guter Letzt habe ich mich noch mit den Interrupts auseinander gesetzt. http://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html
Meine Methode “lauflicht()” ist so gestaltet, dass die ohne die Funktion delay auskommt. So war es möglich, schnell auf einen Tastendruck zu reagieren. Bei Verwendung von delay hätte der Taster während des delays nicht reagiert. Mittlerweile müsste ich soweit sein, dass ich den Taster komplett als Interrupt definiere. Dann müsste der ATtiny auch während der Wartephase reagieren. Das probiere ich später noch mal aus.
Hundeblinklicht V5 – Nachtrag
Im letzten Code gab es ein paar Unstimmigkeiten. Beim Testen habe ich festgestellt, dass durch die Schaltung selbst im Power Down Modus immer noch etwas über 1 mA fließt. Der Grund dafür war ganz einfach. Statt in den Power Down Modus zu gehen, wurden einfach nur die LEDs ausgeschaltet. Von Außen macht das keinen Unterschied, aber der Stromverbraucht ist schon enorm unterschiedlich.
Den Code habe ich nun etwas geändert. Leider funktioniert mein Code nun nicht mehr mit dem ATTiny45. Statt dessen habe ich nun den ATTiny85 eingebaut. Der Stromverbrauch im Power Down Modus liegt nun bei 0,1 µA. Diesen Wert zeigt jedenfalls mein Messgerät an.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 |
/* 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. Die Methode goToSleep wurde hier entliehen http://www.arduino-hausautomation.de/2014/emils-ampel-attiny45-im-tiefschlaf/ */ #include <avr/sleep.h> #include <avr/interrupt.h> #define BODS 7 //BOD Sleep bit in MCUCR #define BODSE 2 //BOD Sleep enable bit in MCUCR uint8_t mcucr1, mcucr2; int PWM1 = 0; // PWM LED int PWM2 = 1; // PWM LED int currentLED=0; long lauflichtTimer; int flashIntervall = 500; // Flash-Intervall int flashdauer = 50; int hell = 255; // Maximalhelligkeit der PWM LED int dunkel = 2; // Minimalhelligkeit der PWM LED int mittel = 5;// 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 = 250; // the debounce time; increase if the output flickers int ledState = 0; ISR(INT0_vect) { } void goToSleep(void) { GIMSK |= _BV(INT0); //enable INT0 MCUCR &= ~(_BV(ISC01) | _BV(ISC00)); //INT0 on low level ACSR |= _BV(ACD); //disable the analog comparator ADCSRA &= ~_BV(ADEN); //disable ADC set_sleep_mode(SLEEP_MODE_PWR_DOWN); sleep_enable(); //turn off the brown-out detector. //must have an ATtiny45 or ATtiny85 rev C or later for software to be able to disable the BOD. //current while sleeping will be <0.5uA if BOD is disabled, <25uA if not. cli(); mcucr1 = MCUCR | _BV(BODS) | _BV(BODSE); //turn off the brown-out detector mcucr2 = mcucr1 & ~_BV(BODSE); MCUCR = mcucr1; MCUCR = mcucr2; sei(); //ensure interrupts enabled so we can wake up again sleep_cpu(); //go to sleep cli(); //wake up here, disable interrupts GIMSK = 0x00; //disable INT0 sleep_disable(); sei(); //enable interrupts again (but INT0 is disabled from above) } void setup() { pinMode(buttonPin, INPUT_PULLUP); // interner PullUp Widerstand wird genutzt. pinMode(PWM1, OUTPUT); pinMode(PWM2, OUTPUT); pinMode(3, OUTPUT); pinMode(4, OUTPUT); lauflichtTimer = millis(); digitalWrite(3, LOW); digitalWrite(4, LOW); } 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; //if(ledState>3) ledState=0; //off(); // beim Statuswechsel werden alle LEDs ausgeschaltet. } } } // set the LED-Mode if (ledState==1) lauflicht(); else if(ledState==2) dauerLicht(); else if(ledState==3) { off();goToSleep();ledState=1;lauflicht();} // save the reading. Next time through the loop, // it'll be the lastButtonState: lastButtonState = reading; } // Beim Umschalten zwischen den Modi sollen die LED alle abgeschaltet werden. void off(){ digitalWrite(PWM1, LOW); digitalWrite(PWM2, LOW); } // Nur eine LED soll im Dauerbetrieb schwach leuchten void dauerLicht(){ analogWrite(PWM2, mittel); analogWrite(PWM1, mittel); } // Lässt die LEDs in der Reihenfolge, die im Array angegeben ist, für "flashdauer" // mit der Intensität "hell" nacheinander aufleuchten. // in der restlichen Zeit leuchten die LEDs mit der Intensität "dunkel" void lauflicht() { long time = millis(); int array[8] = {PWM1, PWM2}; int anzahlLEDinArray = 2; // hier die Anzahl der Array-Elemente eintragen if(time-lauflichtTimer>currentLED*flashIntervall && time-lauflichtTimer < currentLED*flashIntervall+flashdauer){ analogWrite(array[currentLED], hell);} if(time-lauflichtTimer>currentLED*flashIntervall+flashdauer && time-lauflichtTimer < (currentLED+1)*flashIntervall){ analogWrite(array[currentLED++], dunkel);} if(time-lauflichtTimer>anzahlLEDinArray*flashIntervall){lauflichtTimer=millis();currentLED=0;} } |
Die Stromsparfunktion müsste eigentlich auch mit dem ATTiny45 funktionieren. Vielleicht finde ich noch heraus, was da schief läuft.
Hundeblinklicht, Version 5 – es wird Tiny
Der kleine Arduino, den ich bisher in den Hundeblinklichtern verbaut habe, war einfach zu groß und auch zu teuer. Ein kleiner ATTiny45 reicht für das bisschen Blinken völlig aus. Man könnte die Funktion natürlich auch als diskrete Schaltung aufbauen. Nachteil ist nur, dass diese Schaltung mit meinen hier vorhandenen Bauteilen alles andere als stromsparend ist. Der kleine ATTiny hingegen ist im Betrieb schon stromsparend und kann sogar noch in einen Schlafmodus versetzt werden. Somit erspare ich mir einen Schalter, mit dem ich die Stromzufuhr unterbechen muss. Der bereits vorhandene Taster schaltet nun zwischen den verschiedenen Modi durch. 1. Blinkmodus mit sehr hellen Blinkimpulsen. 2. Dauerlicht, das nicht ganz so hell ist, damit es nicht blendet. 3. Aus: der ATTiny wird in den Schlafmodus versetzt. Im Schlafmodus soll der Stromverbrauch so gering sein, so dass der verwendete Akku sehr lange hält. Laut dieser Seite http://www.mikrocontroller.net/articles/Sleep_Mode#Power_Down_Mode fließen nur um die 0,3 µA. Mein Messgerät zeigt in diesem Modus allerdings immer noch 1 mA an. Leider bin ich mir auch nicht so ganz sicher, ob ich den ATTiny richtig programmiert habe. Die Funktion für den Schlafmodus (Methode goToSleep)habe ich aus dieser Seite entnommen: http://www.arduino-hausautomation.de/2014/emils-ampel-attiny45-im-tiefschlaf
Vielleicht mache ich da was falsch. Viel Ahnung habe ich noch nicht.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 |
/* 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. Die Methode goToSleep wurde hier entliehen http://www.arduino-hausautomation.de/2014/emils-ampel-attiny45-im-tiefschlaf/ */ #include <avr/sleep.h> #include <avr/interrupt.h> #define BODS 7 //BOD Sleep bit in MCUCR #define BODSE 2 //BOD Sleep enable bit in MCUCR uint8_t mcucr1, mcucr2; int PWM1 = 0; // PWM LED int PWM2 = 1; // PWM LED int currentLED=0; long lauflichtTimer; int flashIntervall = 500; // Flash-Intervall int flashdauer = 50; int hell = 255; // 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 = 250; // the debounce time; increase if the output flickers int ledState = 0; void goToSleep(void) { //GICR |= (1 << INT0); // externen Interrupt freigeben GIMSK |= _BV(INT0); //enable INT0 MCUCR &= ~(_BV(ISC01) | _BV(ISC00)); //INT0 on low level ACSR |= _BV(ACD); //disable the analog comparator ADCSRA &= ~_BV(ADEN); //disable ADC set_sleep_mode(SLEEP_MODE_PWR_DOWN); sleep_enable(); //turn off the brown-out detector. //must have an ATtiny45 or ATtiny85 rev C or later for software to be able to disable the BOD. //current while sleeping will be ~0.5uA if BOD is disabled, ~25uA if not. cli(); mcucr1 = MCUCR | _BV(BODS) | _BV(BODSE); //turn off the brown-out detector mcucr2 = mcucr1 & ~_BV(BODSE); MCUCR = mcucr1; MCUCR = mcucr2; sei(); //ensure interrupts enabled so we can wake up again sleep_cpu(); //go to sleep cli(); //wake up here, disable interrupts GIMSK = 0x00; //disable INT0 sleep_disable(); sei(); //enable interrupts again (but INT0 is disabled from above) } void setup() { pinMode(buttonPin, INPUT_PULLUP); // interner PullUp Widerstand wird genutzt. pinMode(PWM1, OUTPUT); pinMode(PWM2, OUTPUT); lauflichtTimer = millis(); } 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; if(ledState>=3) ledState=0; off(); // beim Statuswechsel werden alle LEDs ausgeschaltet. } } } // set the LED-Mode if (ledState==1) lauflicht(); else if(ledState==2) dauerLicht(); else if(ledState==3) goToSleep(); // save the reading. Next time through the loop, // it'll be the lastButtonState: lastButtonState = reading; } // Beim Umschalten zwischen den Modi sollen die LED alle abgeschaltet werden. void off(){ digitalWrite(PWM1, LOW); digitalWrite(PWM2, LOW); } // Nur eine LED soll im Dauerbetrieb schwach leuchten void dauerLicht(){ analogWrite(PWM2, 5); analogWrite(PWM1, 5); } // Lässt die LEDs in der Reihenfolge, die im Array angegeben ist, für "flashdauer" // mit der Intensität "hell" nacheinander aufleuchten. // in der restlichen Zeit leuchten die LEDs mit der Intensität "dunkel" void lauflicht() { long time = millis(); int array[8] = {PWM1, PWM2}; int anzahlLEDinArray = 2; // hier die Anzahl der Array-Elemente eintragen if(time-lauflichtTimer>currentLED*flashIntervall && time-lauflichtTimer < currentLED*flashIntervall+flashdauer){ analogWrite(array[currentLED], hell);} if(time-lauflichtTimer>currentLED*flashIntervall+flashdauer && time-lauflichtTimer < (currentLED+1)*flashIntervall){ analogWrite(array[currentLED++], dunkel);} if(time-lauflichtTimer>anzahlLEDinArray*flashIntervall){lauflichtTimer=millis();currentLED=0;} } |
Ich bin aber schon mal froh, dass der Schalter nun weg ist. Dieser war schwierig vor Wasser zu schützen.
Der Tester liegt im Innern des Gehäuses und kann duch Eindrücken des Gehäusedeckels (0,4 mm dickes Nylon) betätigt werden.
Die seitlichen Arme habe ich nun auch wieder durch einen fertigen Schlauch ersetzt. Viel stabiler und transparenter. Es sind noch Pins am ATTiny frei. Da könnte ich noch eine Akkuanzeige einbauen. Wenn die Spannung des Akkus auf einen bestimmten Wert absinkt, fängt eine rote LED an zu blinken.