Technischer Blog hauptsächlich mit Themen zu 3D Druck
One of my favorite reasons for covering the 3D printing space is the fact that I get to report on some really inspiring stories. I’m an animal lover and love se
Quelle: Fred the Tortoise Receives a 3D Printed Shell After a Horrific Fire Destroys His Original
Ich hatte schon mal meinen Arbeitsplatz am 3D Drucker etwas ausgeräumt.
Die Halter für die beiden Lüfter, die auf die Mototrtreiber pusten, sind mir recht gut gelungen. Da habe ich nun noch ein paar mehr von ausgedruckt un den gesamten unteren Rand mit abgedeckt.
Die Halterungen habe ich aus ABS gedruckt. Noch während des Druckens sind Spannungsrisse im Modell entstanden. Der Funktion schadet es aber nicht wirklich und ans Brett geklemmt sieht man die Risse auch nicht mehr. Ich brauche einen konstant temperierten Druckraum.
Es sieht nun schon mal viel sauberer aus. Die Schalter für die Mikroschritte (rechts) haben ebenfalls ihren Platz an einem der Lüfterhalterelemente gefunden.
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.
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.
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.
Auch wenn die Tage mittlerweile wieder länger werden, sind sie immer noch sehr kurz. Mein Hundeblinklicht-Projekt schreitet voran. Der momentane Prototyp ist schon recht gut. Mit Ein-Aus-Schalter und einem Taster zum Umschalten der beiden Modi – Blinken und Dauerlicht.
Beim Blinken blinken die LEDs sehr hell. Das stört und blendet etwas, wenn der Hund an der Leine ist und ganz dicht neben einem läuft. Dafür ist der Dauerlicht-Modus. Hier leutet nur eine LED schwach.
So ganz bin ich mit dem Gehäuse nicht zufrieden. Es ist nun im Gegensatz zur Vorgängerversion 10 mm länger und 1 mm breiter geworden. Dafür ist es nun mit 13 mm recht flach geworden, aber ich habe noch kein gutes Konzept, wie ich das Licht sicher am Geschirr der Hunde befestigen kann. Auch die beiden seitlichen Arme werde ich noch einmal umkonstruieren. Den fertigen 6 mm außendurchmessenden Schlauch werde ich durch einen gedruckten Nylonschlauch ersetzen. So mein Plan jedenfalls. Ich habe noch nicht versucht, einen langen schmalen Schlauch zu drucken.
Im Innern des Schlauches soll eine LED leuchten und so den ganzen Schlauch erleuchten. Wenn es so läuft, wie ich es mir denke… Dann sitzen weiterhin an den Enden noch jeweils eine LED, so dass ich dann auf insgesamt 5 statt 3 externe LEDs komme.
Die CAD-Daten und den Arduino-Sketch zur aktuellen Version könnt ihr hier bekommen.
http://community.shapedo.com/guin/flashlight_for_my_dogs
Einen Notausschalter hatte ich schon fast von Anfang an. Bisher war der Schalter sehr provisorisch am Rahmen mit Kabelbinder festgebunden. Nun hatte ich noch eine Aufputzsteckdose mit FI Schalter in der Bastelkiste ligen. Die Steckdose habe ich ausgebaut. An dessen Stelle steckt nun der Notausschalter.
Damit der Schalter auch passt, musste ich einen kleinen Adapter drucken.
Der passt genaut an die Stelle der Steckdose und hat oben eine Durchführung für den Notausschalter.
An einer Seite habe ich noch ein Loch für ein Kaltgerätestecker gefräst. Dort kommt das Kabel mit der Stromzufuhr rein. Auf einer anderen Seite ist ein kleines Loch für eine Schraubklemme. Das Kabel, was dort durchführt, geht zu den beiden Netzteilen für meinen 3D Drucker. Auf der gegenüberliegenden Seite ist der FI Schaltert zugänglich.
Natürlich hätte ich auch die Steckdose drin lassen können und statt des Notausschalters hätte ich mit dem Taster am FI geschaltet. Aber so macht es mehr her und irgendwie musste ich den Notausschalter auch weiterhin verbauen.
Am gleichen Tag habe ich dann noch mein lautes 12 V Netzteil mit Lüfter gegen ein lüfterloses Modell ausgetauscht. Der PE der Netzzuleitung ist nun auch endlich fest mit den metallenen Teilen des 3D Druckers verbunden. Sonst wäre der FI auch sinnnlos gewesen.
Jetzt fehlt noch ein Rauchmelder, der die Stromzufuhr zum Drucker trennt, wenn Rauch erkannt wird. Fehlt noch ein kleiner Feuerlöscher.