Prusa-Upgrade, Teil 1: Warm, vernetzt und Full Metal

Das Gehäuse ist fertig! Der Prusa i3 (rechts) soll bald in sein neues Heim einziehen…

Der Plan

Mit meinem Prusa i3 3D-Drucker bin ich eigentlich sehr zufrieden, denn er werkelt in der Bastelkammer mehr oder weniger zuverlässig vor sich hin. Leider produzieren aber gerade die Schrittmotoren mit ihrer „Musik“ eine ziemlich nervige Geräuschkulisse, die es mitunter schwer machen, konzentriert in der Werkstatt parallel Basteleien nachzugehen.

Vor diesem Hintergrund habe ich mich nach einem mehr oder weniger geräuschhemmenden Gehäuse umgesehen, und bin bei einer schicken Holzkonstruktion hängengeblieben. Dieses Druckerhäuschen erfüllt dabei mehrere Aufgaben: Es dämpft (hoffentlich) die Druck-Geräusche etwas, hält die Umgebungstemperatur in der Nähe des Druckers weitestgehend konstant (wichtig für den Druck, wenn die Umgebungstemperatur deutlich geringer ist, wie es in der Bastelkammer schon mal vorkommen kann – es ist ja kein Wohnzimmer) und schützt den Drucker zudem vor Staub und sonstigen Verschmutzungen, die so in einer Werkstatt herumwirbeln können.

Aus einem Meter Abstand macht der Drucker schon Lärm…

Zunächst dachte ich eigentlich nur an den Bau eines entsprechenden Gehäuses, doch es keimte dann bei mir der Entschluss, meinen Prusa einem Upgrade zu unterziehen, bei dem es nicht nur bei einem Gehäuse bleiben soll.

Da der Drucker in der Bastelkammer steht, ich dort aber nicht bei jedem (längeren) Druck anwesend sein will, wollte ich eine Art Fernsteuerung und Überwachungsmöglichkeit. Bei meinen Recherchen zu dem Thema stieß ich auf die Software Octoprint, die auf einem Raspberry Pi läuft. Mit diesem Setup kann der Drucker via Wlan überwacht und gesteuert werden, eine angeschlossene USB-Kamera liefert sogar Live-Bilder oder ermöglicht Zeitraffer-Aufnahmen des Druckprozesses zu machen. Diese Erweiterung wollte ich daher ebenfalls vornehmen, da ich noch ein Raspberry Pi B ungenutzt liegen habe.

Um den Drucker später im Gehäuse unterzubringen und betreiben zu können, ist auch die Verlängerung der Verkabelung nötig, da ich das ATX-Netzteil und die Arduino-Ramps-Steuerung außerhalb des Gehäuses anbringen möchte – insb. unter dem Gesichtspunkt der Kühlung sollen diese Komponenten nicht innerhalb des Gehäuses untergebracht werden. Daher muss mehr oder weniger die gesamte Verkabelung angefasst werden – eine gute Gelegenheit das Hotend auch gleich zu tauschen – bisher nutze ich noch mein China-PLA-Hotend – mit diesem bin ich prinzipiell sehr zufrieden. Dennoch möchte ich zukünftig neben PLA auch ABS, Nylon usw. verarbeiten können. Daher wird dieses nun gegen mein E3D Ganzmetall-Hotend ausgetauscht, welches schon seit einiger Zeit im Regal auf seinen Einsatz wartet. Mit dem E3D ist dann auch der Druck von Nylon und ABS sowie neuer PLA-Mischungen mit Kohlefaser möglich.

E3D-Hotend: Noch verpackt warten die Einzelteile auf die Montage…

 

Das Gehäuse entsteht

Zurück zum oben erwähnten Gehäuse. Da ich mein Prusa mit einer Versteifung versehen habe konnte ich die recherchierten Konstruktionsdaten nicht einfach übernehmen. Zudem hängt die Konstruktion auch vom verfügbaren Material ab. Aus dem Grund habe ich mich nach Ermittlung der nötigen Innenmaße an die Konstruktion meines Gehäuses gemacht, dabei habe ich mich aber stark an das o.g. Design angelehnt, wobei ich noch eine zusätzliche Wartungsklappe in der Rückwand hinzugefügt habe, um ggf. an den Drucker auch von der Rückseite gelangen zu können. Abweichend von dem ursprünglichen Design nutze ich meine bisherige Filament-Halterung weiter. Das Gehäuse selbst basiert auf zwei Holzarten: MDF (in den Stärken 13mm und 19mm) sowie Birken-Multiplex (18mm). Für die Montage des Netzteiles und der Arduino-Ramps-Kombination nutze ich diese Halterungen. Im Inneren des Case werde ich noch LED-Lichtstreifen zur Beleuchtung einkleben und die USB-Kamera anbringen.

So sieht die das entworfene Gehäuse aus:

CAD-Modell: Die Vorderansicht. Vorne wir das Gehäuse mit einer durchsichtigen PS-Platte, die einfach nur eingelegt wird, verschlossen.

CAD-Modell: Seitenansicht des Gehäuses. Gut zu erkennen ist die Anordnung der einzelnen Holzteile.

CAD-Modell: Ansicht auf die Rückwand – gut zu erkennen ist die Aussparung, die für die Wartungsklappe ist.

CAD-Modell: Die Wartungsklappe (grün) ist eingefügt.

Die Konstruktionszeichnungen werde ich hier demnächst einstellen.

Update zum Bau des Gehäuses (I):

In den letzten Tagen habe ich mir passendes Holz im Baumarkt beschafft und dort auch gleich grob rechtwinkelig zuschneiden lassen. Anschließend ging ich daran, die einzelnen Platten anzuzeichnen und an der Kreissäge in die richtigen Geometrien zu sägen. Den Ausschnitt der Rückwand und die Ausklinkungen der inneren Seitenplatten machte ich mit der Stichsäge. Die großen Löcher in den Platten sind mittels Forstner-Bohrer gemacht. Die Aussparung für die Wartungsklappe in der Rückwand ist mit der Oberfräse gemacht.

Die Montage habe ich nun auch fast erledigt: Die Platten sind stumpf mit Schrauben verbunden (vorher habe ich alle Schraubenlöcher vorgebohrt: 0,7x Aussenduchmesser ergbit den Durchmesser für das Kernloch bei Spax-Schrauben und mit einem Kegelsenker entsprechend abgesenkt) und die Kontaktflächen zusätzlich mit Leim versehen. Die Birken-Multiplexplatten werden nach dem Lackieren (inkl. Vorstreichen) mit den inneren MDF-Platten von innen per Spax-Schrauben befestigt.

Hier mal einige Bilder zum Bau:

Übertragen der Schnittkanten von der Zeichnung auf die einzelnen Teile.

Die Maße werden angerissen.

Die Ausfräsung für die Wartungklappe in der Rückwand muss nachgearbeitet werden.

Zusähen der einzelnen Teile: Auch an der Kreissäge wird gearbeitet – hier entsteht eine 70°-Schräge an der Stirnseite einer Leiste.

Die Wartungklappe.

Die einzelnen Teile sind angefertigt.

Profilansicht der oberen und unteren Leiste – die Geometrie ist an der Kreissäge entstanden.

Anpassen: Bodenplatte und untere Leiste passen gut zusammen.

Die Teile sind verleimt und verschraubt.

Die obere Leiste ist verschraubt. Zu erkennen ist ein Lücke an der inneren Seitenwand – ich habe die Ausklinkung zu großzügig ausgesägt…

Holzspachtel dient zum ausgleichen von Unebenheiten, Kanten und zum verdecken der Senkkopfschraubenköpfe.

Der Holzspachtel ist angeschliffen, aber noch nicht ganz eben. Der Schraubenkopf ist nicht mehr zu sehen.

Die Lücke, die durch meinen Fehler beim Ausklinken entstand ist mit Holzspachtel gefüllt.

Mit Feinspachtel muss der Übergang noch geglättet werden – nur Holzspachtel reichte nicht.

Zwischenstand: Der Korpus ist fertig, die Schraubenköpfe und Lücken verspachtelt.

Update (II): Lackieren, Frontscheibe…

Lackiermaterial: Die MDP-Platten habe ich vorgestrichen und dann mit Acryl-Lack in drei Schichten mit der Rolle lackiert.

Frisch lackiert – drei Schichten müssen es schon sein…

Die Füße sind eigentlich Türstopper – aber sie erfüllen ihren Zweck.

Die „Füße“ sind mit normalen Spax-Schrauben in den Boden geschraubt.

Klarlack für die Birken-Multiplexseitenplatten. Da Öl verdunsten kann, habe ich mich für den Klarlack entschieden.

Rückansicht – die Wartungklappe fehlt noch.

Die Polystyrol-Platte ist mit einer kleinen Kreissäge zugesägt.

Die Handgriffe sind aus dem Baumarkt. Die mitgelieferten Schrauben sind zu groß und daher gegen kürzere Schrauben getauscht.

Für die Montage der Griffe an der PS-Platte habe ich Kegelsenkungen auf der Rückseite angebracht.

Schön anzusehen – die durchsichtige Frontseite mit Griff.

Eingetroffen: LED-Streifen, weiß, für die Innenbeleuchtung:

LED-Streifen für die Innenbeleuchtung – noch in antistatischer Verpackung.

Für die feste Montage des Prusa i3 im Gehäuse werde ich diese Befestigungen nutzen, die ich bei thingiverse gefunden habe – den Drucker werde ich schon einmal anwerfen…

Leider ist die o.g. Befestigung für M8-Gewindestangen konstruiert – ich habe aber M10-Gewindestanden verbaut. Aus dem Grund habe ich geschwind eine passende Befestigung konstruiert:

CAD-Modell der Prusa i3-Befestigung (für M10-Gewindestange).

Die Druckdaten dazu stelle ich demnächst bei thingiverse ein – nun drucke ich mal vier Halterungen in knapp 3h (PLA, 30% Infill, 0.2mm Layer).

Update: Die Halterungen sind gedruckt:

Zur Befestigung des Prusa im Gehäuse habe ich drei entsprechende Halterungen gedruckt.

Befestigung am vorderen Teil des Druckers.

Hinten wird der Drucker mit zwei Halterung fixiert.

 

Update (III): Gehäuse-Zeichnungen (Veröffentlicht unter der CC-Lizenz by-nc-sa):

Hier kommen die Zeichnungsblätter der einzelnen Holzteile für das Gehäuse – viel Spaß beim Nachbau…

       

Oder als DXF-Files sind die Zeichnungen hier zu finden.

 

Die Fernsteuerung mit Octoprint

Um Octoprint einzusetzen ist neben dem 3D-Drucker noch entsprechende Hardware erforderlich, dies sind:

• Rapsberry Pi B/ B+ oder 2
• USB-Kamera
• Wlan-Stick (alternativ LAN)
• SD-Karte (16GB)
• USB-Netzteil (mind. 1A)
• USB-Kabel (um den RPi später mit dem 3D-Drucker zu verbinden)
• (SD-Karten-Reader, HDMI-Kabel, USB-Tastatur – nur zum ersten Setup nötig)

Octoprint mit dem nötigen Zubehör: SD-Karte, Raspberry Pi B, USB-Wlan-Adapter, USB-Kamera, USB-Hub, Steckernetzteil (von vorne links im Uhrzeigersinn).

 

Softwareseitig ist die Sache sehr einfach. Auf der Website von Octoprint  findet sich ein fertiges, extra für den RPi angefertigtes Disk-Image namens Octopi. Diese ist herunter zu laden und mit einer geeigneten Image-Writer-Software auf der SD-Karte zu installieren. Ich nutze dazu die Software Win32 Disk Imager. Nach erfolgreicher Installation ist die Erst-Konfiguration des Linux-Systems vorzunehmen. Ist das erledigt und die LAN oder WLAN-Verbindung steht, kann über den Browser Octoptint direkt aufgerufen werden.

Wie man das alles macht, wird in diesem Video gut erläutert, bzw. kann hier nachgelesen werden:

 

Test des Octoprint-Setups – auch der Stream funktioniert jetzt mit der 5€ China-USB-Kamera…

Ich werden dieses Posting jeweils dem Projektfortschritt anpassen – also schaut einfach von Zeit zu Zeit hier vorbei.

Soweit für heute

Horrido und stay tuned!

ROVER Bot: Meine erste Arduino-Roboter-Versuchsplattform

Probesitzen: Das Arduino-Board ist probehalber auf dem Rover-Chassis platziert…

 

Arduino-Projekte haben in der Regel den Charme, dass es interdisziplinare Vorhaben sind. Es geht sowohl um die elektronische Anbindung von Sensoren und Aktuatoren, der Verbindung mit Hardware und dazu Software-Code, der alles zusammen zu einer funktionierenden Einheit werden lässt.

Vor diesem Hintergrund habe ich ein kleines Arduino-Rover-Projekt begonnen, um mich etwas intensiver mit dem Zusammenspiel von diesen Dingen zu beschäftigen und meine Kenntnisse bei der Programmierung zu entwickeln.

Die Frage ist: Was braucht es für einen Rover, mit dem man einfach und unkompliziert experimentieren will ohne dafür ein Stange Geld auf den Tisch zu legen?

Einen Arduino: Aus zurückliegender Zeit habe ich noch ein Arduino Duemilanove , mit dem ich vor 6 Jahren einen Quadrocopter aufbaute, diesen jedoch irgendwann wieder zerlegte.

Einen Antrieb: Da ich keine Getriebe-Motoren habe, aber noch einige 3003-Servos, sollten diese so umgebaut werden, dass sie nicht mehr als Steller sondern als Antriebseinheiten einsetzbar sind – Stichwort ist hier: Servo Hacking.

Ein Fahrgestell: Für einen Rover braucht es natürlich ein passendes Fahrgestell. Dieses fand ich bei thingiverse – denn ich hatte noch Laufwerksrollen und Ketten eines Tamiya-Kits in der Bastelkammer.

Einen Sensor: Dazu benutze ich ein Ultraschall-Sensor (HC-SR04), der montiert auf einem Servo, als „Radar“ zur Hinderniserkennung den kleinen Rover vor Überraschungen bewahren soll. Zur Montage des Sensors habe ich diese Halterung, die ich ebenfalls bei thingiverse fand, vorgesehen.

Einen Code: Es ist für ich zunächst ein Puzzle, bei dem ich zu aller erst im Netz recherchiere, wie solche Roboter bisher mit den Teilen, die ich habe, von anderen umgesetzt wurde. Dabei suche ich mir die Code-Teile zusammen, die ich meiner Meinung nach gebrauchen kann.

 

Perspektivisch möchte ich die Rover-Plattform zum Experimentieren nutzen, und dabei unterschiedliche Sensoren kennenlernen und die Einbindung in einen Roboter erarbeiten. Zum jetzigen Zeitpunkt erscheint mir insbesondere ein LIDAR lite Sensor zum Abtasten der Umgebung interessant zu sein. Aber auch die Kombination des Arduino mit einem Raspberry Pi B+ oder 2 und einer Pi-Kamera , deren Bilder dann per Wifi gestream werden sind Erweiterungen, die ich vielleicht zu einem späteren Zeitpunkt in Angriff nehmen möchte.

 

Aktuell habe ich die o.g. Teile gedruckt, entgratet und zur Probe vormontiert – hier mal ein Blick auf die bisherigen Bastel-Schritte:

Druck und Montage des Fahrgestells…

Die Chassis-Teile für den Rover werden mit einer Layerhöhe von 0,2mm und einem Infill von 30% in PLA gedruckt.

Alle Fahrgestell-Teile sind mit Rand gedruckt, um die Haftung auf dem Druckbett zu verbessern.

Die gedruckten Rover-Teile…

Probemontage des Chassis nach dem Entgraten – die Teile passen gut zusammen. Bei der Endmontage werden die Einzelteile miteinander verklebt.

Die Laufrollen inkl. der Schrauben sind aus dem Tamiya-Kit.

…es folgte das Servo Hacking…

Übersichtlich: Zur Demontage des Servos ist nicht viel Werkzeug nötig…

Servo Hacking: Das Servo-Gehäuse ist aufgeschraubt. Zu erkennen ist links der Motor und rechts die Steuerplatine, unter der das Potentiometer montiert ist.

Servoplatine und das darunterlegende Potentiometer, welches im Servogehäuse mittels Schnapphaken gehalten wird, sind demontiert.

Entfernt: Das Potentiometer ist von der Steuerplatine abgetrennt.

Das Ausmessen des Potentiometers ergibt einen Gesamtwiderstand von 5k Ohm.

 

Um in etwa die Mitte des Potentiometerwertes zu treffen nutze ich zwei Festwiderstände mit 2,4 k Ohm Nennwiderstand.

Austausch: 5 K Ohm-Poti wird gegen zwei 2,4 k Ohm Festwiderstände getauscht.

Ohne Dritte-Hand geht das Löten leider nicht…

Verlötet: Die beiden 2,4k Ohm Ersatzwiderstände sind statt des Potentiometers an den drei Pins fliegend verlötet.

Nach dem Anbringen des Widerstandsnetzwerks wird der Servo mittels Tester ausprobiert – nun dreht er wie ein Motor.

Das gedruckte zweiteilige Antriebsrad passt gut auf den Servo.

Es folgte die Montage der Servo-Antriebsmotoren und der Ketten…

Ansicht auf den Rover von oben. Zu erkennen ist die Spurweiten-Differenz zwischen Antriebsrädern und den Ketten. Um die Ketten in Flucht zu den Antriebsrädern zu bringen werden gedruckte Distanzschreiben genutzt.

Kleinteile: Die gedruckten Distanzscheiben zur Einstellung der Spurweite der Ketten.

Alles ist an seinem vorgesehenen Platz: Rover ist bereit für die Steuerungselektronik.

Zwischenzeitlich habe ich an dem Bot etwas weitergearbeitet. Zunächst habe ich mir eine Halterung für den noch vorhandene Ultraschall-Sensor gedruckt:

Für ein späteres Upgrade: Schwenkbar ausgelegter Ultraschallsensor. Die Halterung ist gedruckt.

Der Sensor passt genau in die gedruckte Halterung.

Die einfache Schaltung ist zunächst mit einem Steckboard realisiert.

 

Anschließend habe einen ersten Fahrtest (noch ohne Sensor) gemacht, die aber ernüchternd war: Die eine Kette läuft regelmäßig von den Laufrollen und am anderen Kettenlaufwerk ist die Lagerung der vorderen Rolle gebrochen.

Die linke vordere Laufrolle ist samt Lager aus dem gedruckten Teil herausgebrochen….

Getestet habe ich mit diesem Code, den ich im Netz gefunden habe:
//———————————————————————————
// START OF ARDUINO CONTROLLED SERVO ROBOT (SERB) PREAMBLE
#include <Servo.h>

#define LEFTSERVOPIN 10
#define RIGHTSERVOPIN 9

Servo leftServo;
Servo rightServo;

int speed = 100; //sets the speed of the robot (both servos) a percentage between 0 and 100

// END OF ARDUINO CONTROLLED SERVO ROBOT (SERB) PREAMBLE
//———————————————————————————
/*
* sets pins to appropriate states and attaches servos. Then pauses
* for 1 second before the program starts
*/
void setup()
{
serbSetup(); //sets the state of all neccesary pins and adds servos to your sketch
randomSeed(analogRead(0)); //sets the random number seed with something mildly random
delay(1000);
}

/*
* turns the robot either left or right (randomly) for a period between
* 0.1 and 1 second. Before going forward for a random time period
* between 1 and 4 seconds. Before pausing for two seconds then starting
* again.
*/
void loop()
{
turnRandom(100,1000); //Turns randomly left or right for a random time period between .1 second and one second
goForwardRandom(1000,2000); //Goes forward for a random time period between 1 and 2 seconds
goStop(); //Stops the robot
delay(2000); //pauses for 2 seconds (whilst stopped)
}

/*
* turns the robot randomly left or right for a random time period between
* minTime (milliseconds) and maxTime (milliseconds)
*/
void turnRandom(int minTime, int maxTime){
int choice = random(2); //Random number to decide between left (1) and right (0)
int turnTime = random(minTime,maxTime); //Random number for the pause time
if(choice == 1){ goLeft();} //If random number = 1 then turn left
else {goRight();} //If random number = 0 then turn right
delay(turnTime); //delay for random time
}

/*
* goes forward for a random time period between minTime (milliseconds)
* and maxTime (milliseconds)
*/
void goForwardRandom(int minTime, int maxTime){
int forwardTime = random(minTime,maxTime); //determine a random time to go forward
goForward(); //sets the SERB forward
delay(forwardTime); //delays for random time period
}

//————————————————————————————————————
//START OF ARDUINO CONTROLLED SERVO ROBOT (SERB) ROUTINES

/*
* sets up your arduino to address your SERB using the included routines
*/
void serbSetup(){
setSpeed(speed);
pinMode(LEFTSERVOPIN, OUTPUT); //sets the left servo signal pin to output
pinMode(RIGHTSERVOPIN, OUTPUT); //sets the right servo signal pin to output
leftServo.attach(LEFTSERVOPIN); //attaches left servo
rightServo.attach(RIGHTSERVOPIN); //attaches right servo
goStop();
}
/*
* sets the speed of the robot between 0-(stopped) and 100-(full speed)
* NOTE: speed will not change the current speed you must change speed
* then call one of the go methods before changes occur.
*/
void setSpeed(int newSpeed){
if(newSpeed >= 100) {newSpeed = 100;} //if speed is greater than 100 make it 100
if(newSpeed <= 0) {newSpeed = 0;} //if speed is less than 0 make it 0
speed = newSpeed * 0.9; //scales the speed to be between 0 and 90
}

/*
* sends the robot forwards
*/
void goForward(){
leftServo.write(90 + speed);
rightServo.write(90 – speed);
}

/*
* sends the robot backwards
*/
void goBackward(){
leftServo.write(90 – speed);
rightServo.write(90 + speed);
}

/*
* sends the robot right
*/
void goRight(){
leftServo.write(90 + speed);
rightServo.write(90 + speed);
}

/*
* sends the robot left
*/
void goLeft(){
leftServo.write(90 – speed);
rightServo.write(90 – speed);
}

/*
* stops the robot
*/
void goStop(){
leftServo.write(90);
rightServo.write(90);
}

Da ich nicht wirklich Lust habe das Kettenlaufwerk nun noch groß zu überarbeiten versuche ich es mit dem sog. Miniskybot 2 , um endlich mal mit dem Arduino spielen zu können – der Drucker ist schon mit der Fahrgestell-Herstellung beschäftigt…

Soweit aus der Bastelkammer…

Horrido und stay tuned.