Technischer Blog hauptsächlich mit Themen zu 3D Druck
Modelle in Wireframe umwandeln und dann materialsparend ausdrucken gibt es ja schon länger. Aber so wie es Stefanie Müller und Team vom HPI gemacht haben, ist e mir noch nicht unter die Augen gekommen.
Quelle: Open / Close Clockwork Sign by Ikeda Yosuke – Homeli
Sogar ohne 3D Drucker wäre das einfach herstellbar 🙂
Ich habe meine 0.8mm Düse für den 3D Drucker wieder eingebaut. Was kann man gut mit dieser Düse machen? Naja, auf Grund der dicken Wände lassen sich damit gut einwandige Modelle drucken.
Zuerst habe ich mit etwas ganz Einfachem angefangen. Ein Sechseck, das noch oben weiter wird. Mir war das dann zu langweilig.
Also habe ich hier und da ein bisschen am 3D Modell herumgezerrt und heraus kam dieses tassenähnlihce Gebilde. Der Zacken hinten hat mich an einen Henkel erinnert. Nur kann man diesen hier nicht wirklich anfassen, da sich der Zapfen nach oben verjüngt und die Finger daran abrutschen.
Gleich ein neuer Versuch. Der Henkel ist nun henkeliger geworden. Jedenfalls rutscht man nun nicht mehr daran ab.
Alle Becher sind 5 cm hoch und haben einen Grundduchmesser von ca 8 cm. Gedruckt wurden sie in PLA in 0,2 mm Schichthöhe… So wirklich einzelne Schichten im klassischen Sinne gibt es aber nicht. Der Vorteil von einwandingen Modellen ist, dass man diese auch spiralförmig von unten nach oben hochdrucken kann. Statt also nach einer Umrundung den Druckkopf um 0,2 mm anzuheben, wird nun kontinuierlich der Kopf angehoben, während der Druckkopf seine Kreise zieht. Dies zieht einen optischen Vorteil nach sich. Es entsteht keine Naht an der Stelle, wo der Kopf angehoben wird und eine neue Schicht entsteht.
Die Wandstärke liegt bei ungefähr 0,9 mm. Das gibt ein Objekt dieser Größe genügend Stabilität. Da eine Umrundung recht schnell abgefahren ist, hat das Material, gerade bei dieser Dicke, nicht genügend Zeit, abzukühlen und fest zu werden. Hier musste ich mit zwei Lüftern für einen ausreichenden kühlenden Luftstrom sorgen.
Was kann diese Düse nicht? Kleine Objekte drucken. Nicht nur weil die Düse zu groß wäre, denn dies spielt bei einem Kreis oder Viereck keine große Rolle, sondern weil viel Material aus der Düse herauskommt, das erst einmal abkühlen muss. Kleine Objekte können gar nicht langsam genug gedruckt werden, damit diese Wartezeit erreicht wird. Zudem überträgt die große Fläche der Düse auch sehr viel Wärme auf die darunter liegenden bereits verfestigten Schichten, so dass diese wieder weich werden.
Hier die STL Datei: http://community.shapedo.com/guin/simple_cup
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.
Mittlerweile habe ich nun schon ein paar Schrittmotortreiber, auch Stepsticks oder Stepper Driver genannte, ausprobiert. Zuerst hatte ich die Pololu A4988 in meinen 3D Drucker. Einer davon hatte sich schon nach relativ kurzer Zeit verabschiedet. Thermische Probleme schätze ich mal. Ich habe mich dann nach robusteren Alternativen umgeschaut. Dabei sind mit dann die DRV8825 ins Auge gefallen. Wichtig war mir, dass die Treiber kompatibel zu den vorherigen sind, damit ich nicht erst noch etwas umlöten muss. Damals war ich noch ganz neu im Thema 3D Druck und deren Technik und ich hätte mir nicht zugetraut, größere Umbauarbeiten vorzunehmen. Die DRV8825 können ein bisschen mehr Strom liefern. 1 Ampere zu 1,5 Ampere Dauerstrom. Satte 50% mehr. Beim Spitzenstrom liegen beide mit 2 A zu 2,2 A schon wieder dichter zusammen. Aber es kommt eben nicht nur auf die maximalen Spitzen an. Die DRV8825 haben auch noch dne Vorteil, dass sie bis zu 32 Microsteps (je Vollschritt) steuern können. Allerdings hatte ich das nie genutzt. Ich bin bei den 16 Microsteps, die auch beim A4988 möglich waren, geblieben.
Dann kamen im Herbst 2014 die „Silencioso“. Bis zu 128 Microsteps waren mit diesem Treiber möglich. Je mehr Microsteps, desto genauer kann der Drucker arbeiten. Theoretisch jedenfalls. Mal davon abgesehen, dass die Mechanik der Hobby- und Semiprofessionellen 3D Drucker keine Auflösungen im einstelligen Micromillimeterbereich zulassen, gibt es auch noch Fallstricke bei den Treibern, wie sie die Microsteps umsetzen. Um diese „Unzulänglichkeiten“ zu zeigen, hat der User Willy aus dem RepRap Forum einen Schrittmotor-Tester gebaut.
Hier ein schönes Video von Willy aus dem RepRap-Forum.
Kurz gesagt: Microstep ist nicht gleich Microstep.
Über das RepRap Forum bin ich auf Angelo mit seinen Silencioso gestoßen. Nicht gerade günstig diese Treiber, aber versprochen wird, bzw wurde viel. Der anfängliche Preis von ca. 40 Euro je Treiber war dann doch auch erst mal abschreckend. Die DRV8825 kosten immerhin unter 10 Euro je Stück. Als der Preis dann auf 25 Euro gesenkt wurde, habe ich mir die Silencioso auch mal bestellt. 3 Stück brauche ich für meinen Delta-Drucker. Das ist auch schon mal eine Menge Geld. Die Silencioso werden nicht wie meine vorherigen Treiber auf mein RAMPS gesteckt. Ein kleines bisschen Bastelarbeit war nötig. Aber das war nicht weiter schlimm. Doof war nur, dass mal gleich zwei von drei Treibern defekt waren. Zum Glück war es „nur“, dass die Treiber nicht stromlos geschaltet werden konnten. D.h. auch wenn die Motoren abgeschaltet sein sollten, konnte man die Achsen an den defekten Treibern nicht bewegen. Aber man konnte immerhin drucken. Kurz darauf habe ich noch mal zwei neue Silencioso bestellt. Und schon wieder ein Treiber von zwei defekt. Diesmal hat der eine defekte Treiber gar nicht funktioniert. 5 gekaufte Treiber und 2 funktionieren. Na super. Da war meine Freude groß.
In dieser Zeit hatte ich mit dann auch einen Arduino DUE und ein RADDS gekauft. Mein zuvor verwendeter Arduino Mega war zu langsam. Bei 64 Microsteps konnte ich nur noch sehr langsam drucken. Selbst bei 32 Microschritten durfte ich nicht zu schnell drucken. Viele fragen sich nun bestimmt, warum schon bei 32 Microschritten Geschwindigkeitsprobleme auftraten. Das liegt daran, dass ich 0,9° statt der üblichen 1,8° Schrittmotoren habe. Der Arduino muss also schon mal von Grund auf doppelt so viele Schritte bei 0,9° berechnen. Auch bei dem RADDS hat mich mein Unglück übrigens nicht verlassen, denn auch dieses war defekt. Nach langem Hin und Her, auch in einer Telefonkonferent mit Marcus Littwin, dem Entwickler hinter Repetier, stellte sich heraus, dass das EEPROM auf dem RADDS defekt ist. Mit dem Ersatz-DUE von Angelo lief es dann erst mal wieder einigermaßen. Nach dieser Odyssee hat mich die Motivation verlassen und ich habe erst mal alles Rund ums Thema 3D Druck liegen gelassen. Zumal die Geldreserven auch zuneige gingen.
Warum habe ich die defekten Silencioso nicht reklamiert? Ja, manchmal frage ich mich das auch. Hätte ich diese Treiber in einem mir anonymen Shop gekauft, hätte ich sie auf jeden Fall reklamiert. In diesem Fall hatte ich sie bei Angelo gekauft. Er hat mir bei allgemeinen 3D Druck Sachen und auch versucht bei meinen speziellen Problemen mit den Treibern und dem Arduino DUE zu helfen. So habe ich das Geld als Entwicklungshilfe für die RepRap Community abgeschrieben. Auch Repetier hat eine kleine Spende bekommen, da er mir ermöglicht hat, die Firmware so zu ändern, dass ich mit dem defekten Arduino DUE drucken konnte.
Was Moralisches:
Open Source bedeutet eben nicht, dass alles kostenlos ist. Es gibt viele Menschen, die ihren Lebensunterhalt mit Open Source Produkten verdienen (müssen). Auch Menschen, die nichts mit ihrer Arbeit für die Open Souce Community verdienen wollen, sollte man dann auf eine andere Weise würdigen. Diese Menschen, ob nun mit oder ohne kommerzielle Interessen, investieren viel Zeit in ihre Projekte, damit die breite Masse ein auf sie anpassbares Produkt bekommen. Also bitte nicht einfach immer nur die „kostenlosen“ Dinge abgreifen und dann auch noch beschweren. Statt mit Geld kann man natürlich auch mit Beteiligung helfen. Man kann testen, so wie ich es hier mache, oder man hilft bei der Entwicklung.
So, Moral Ende.
Also die Silencioso sind leise und die Druckergebnisse sind auch gut, wenn die Treiber funktionieren. Bei einem der funktionierenden Treiber stellte sich noch ein anderes Problem heraus. Wie ich schon schrieb, werden die Silecioso nicht auf das RAMPS oder RADDS gesteckt, sondern hinten mit einem Gehäuse an die Schrittmotoren geschraubt. Eigentlich keine schlechte Idee. Bei meinem nur ungünstig, da ich dann nur noch schwer an die Stelpoti für Strom und Decay komme. Auch die Schalter zum Einstellen der Mikoschritte sind nur schwer erreichbar. Aber weiter zum Problem. Die Platine mit dem Treiber wird in ein lackiertes Metallgehäuse gelegt. Bei einigen Treibern passt die Platine allerdings nur sehr stramm in das Gehäuse. An einer Stelle hat die Platine an der Seite einen Messpunkt (für Vref, Motorstrom). Dieser Messpunkt kann sich mit der Zeit duch Vibration der Schrittmotoren duch den Lack schleifen und eine Verbindung kommt zustande. Über das Gehäuse und den Schrauben wird dann weiter eine Verbindung zum Gehäuse der Schrittmotoren hergestellt. Diese wiederum sind mit dem Metallrahmen des Druckers verbunden und der Metallrahmen liegt auf Masse. Der Messpunkt hat eine positive Spannung, so dass nun eine Menge Strom abfließt und der Treiber dann heiß wird und sich abschaltet. Meine Notlösung war nun erst einmal, dass ich die Treiber nicht mehr an die Schrittmotoren geschraube habe. Das hat funktioniert. Sieht aber mehr als bescheiden aus. 😉
Während dieser ganzen Umbauarbeiten habe ich immer wieder mal ein Ton-Video aufgenommen, damit man mal den Lautstärkeunterschied zwischen den Treibern hören kann. Zuerst der Arduino Mega mit den DRV8825, dann Arduino Mega mit den Silencioso mit verschiedenen Mikroschritten und zu Guter letzt der Arduino DUE mit dem RADDS plus Silencioso.
Das Video habe ich bei Youtube hochgeladen und ihr könnt es euch auch hier anschauen.
Eigentlich wollte ich nur einmal kurz das Video hier vorstellen, aber dann ist der Text doch ein bisschen länger geworden als erwartet.
Gestern ist meine Stellschraube für eine Bremse abhanden gekommen. Vermutlich war sie schon zu weit rausgedreht und hat sich dann durch Vibration ganz gelöst. So auf die Schnelle bekommt man kein neue Stellschraube und ohne lässt wird nicht genügend Druck auf die Bremse aufgebaut.
Was also tun. Eine neue habe ich bestellt. Die kommt aber erst in den nächsten Tagen. Ich habe mir eine Stellschraube erstellt und dann in Nylon ausgedruckt.
Wie man auf dem Bild sehen kann, hat es funktioniert 🙂
Die CAD Daten für eine M10 Stellschraube habe ich bei ShapeDo hochgeladen.
http://community.shapedo.com/guin/brake_adjustment_screw
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
Im ersten Teil habe ich angefangen, die Entwicklung des Gehäuses des Arcade Pis zu beschreiben.
Der Arcade Pi ist nun fertig aufgebaut und funktioniert auch.
Ist das Projekt nun erfolgreich abgeschlossen?
Ein klares NEIN, da es noch viele kleine und große Sachen gibt, die mich stören. Sobald es dann die Zeit und Motivation zulässt, werde ich die Kinderkrankheiten auch noch beseitigen. Bis dahin beschreibe ich erst einmal, was ich gemacht habe.
Als erstes habe ich mir überlegt, was und wo alles in den Arcade Pi rein muss. Das Gehäuseoberteil sah dann so aus.
Mit am meisten Probleme hat das Steuerkreuz gemacht (hier auf der rechten Seite zu sehen). Es hat immer wieder gehakt. Ein paar Stuerkreuz Varianten habe ich ausgedruckt.
Ganz rechts ist das Modell, was auch aktuell in ähnlicher Form verwendet wird.
Unter dem Steuerkreuz befinden sich 4 kleine Taster (orange), die auf eine kleine Lochrasterplatine aufgelötet sind. Je nachdem in welche Richtung man das Steuerkreuz drückt, werden ein bis zwei der kleinen Taster betätigt. Damit das ganze auch ein bisschen stabilisiert ist, ist in der Mitte noch eine Feder angebracht (nicht im Bild zu sehen), die das Kreuz immer wieder in die Mittelposition zurück drückt.
So sieht das ganze eingebaut aus.
Die blauen Buttons waren da schon wesentlich einfacher. Von der Platinenrückseite aus betrachtet, sieht das aber auch nicht viel anders aus, als beim Steuerkreuz.
Dann bin ich noch auf die gloreiche Idee gekommen, dass der Arcade Pi einen eingebauten Lautsprecher braucht.
Das hätte ich mir auch sparen können. Da ich das ganze an den Klinkenausgang des Raspberry Pis angeschlossen habe, ist die Qualität der Soundausgabe nicht besonders gut. Ausserdem ist der Lautsprecher zu hoch, so dass dieser gegen den Akku stößt, wenn man das Gehäuse sauber zusammen schauben will.
Den normalen Kopfhörerausgang gibt es auch noch.
Insgesamt war es doch recht viel Verkabelung. Jeder Taster hat seine eigene Leitung. Das macht auf Seite des Stuerkreuzes schon 4 für das Steuerkreuz plus 2 für die gelben Taster plus 1 mal Masse. 7 Kabel also. Für die 4 blaue Knöpfe sind es insgesamt 5 Käbelchen. Innen sieht es entsprechend voll aus.
Der Akku, das rosa Teil, gehört oben in die Ausbuchtung. Aufgeklappt sind nur die Kabel zu kurz, so dass der Akku für’s Foto anders platziert werden musste.
Die SD Karte kann man wechseln.
Auf der abgewandten Seite ist noch einer der beiden USB Port zugänglich und ebenso die LAN Buchse.
Was für Teile habe ich in meinem Arcade Pi eingebaut.
Was würde ich anders machen?
Super wäre es, wenn ich einen bezahlbaren kleinen (3 Zoll bis 3.5 Zoll Diagonale) HDMI Monitor finden würde.
Der wäre zu groß und verbraucht zu viel Strom. Und kostet auch um die 100 Eruo.
