HyperCube 3D – Rahmen (Frame) und Druckbettauflage

Beschreibung
Der Rahmen wird aus Aluminiumprofil 20x20mm B-Typ NUT 6 aufgebaut.

Bauraum: 200x200x150mm

Stückliste

Bauteilset Rahmen
Bild Menge Beschreibung
4 Stk. X-Achse
Aluprofil 20x20mm
Länge 340mm
4 Stk. Y-Achse
Aluprofil 20x20mm
Länge 303mm
4 Stk. Z-Achse
Aluprofil 20x20mm
Länge 350mm
2 Stk. Druckbettauflage
Aluprofil 20x20mm
Länge 285mm
1 Stk. Druckbettauflage
Aluprofil 20x20mm
Länge 135mm
48 Stk. Schraube M4x8mm
48 Stk. Gewindeplatte M4
24 Stk. Winkel 20 B-Typ

Aufbau Rahmen
Der Rahmen muss winklig aufgebaut sein !!!


Die Teile die für den Zusammenbau des hinteren Rahmens benötigt werden.


Die linke obere Ecke. Die rechte Ecke wird spiegelbildlich aufgebaut.


Die linke, obere Ecke. Die rechte Ecke wird spiegelbildlich aufgebaut.


Die linke, untere Ecke. Die rechte Ecke wird spiegelbildlich aufgebaut.


Die linke, untere Ecke. Die rechte Ecke wird spiegelbildlich aufgebaut.


Hinterer Rahmen, der vordere wird gleich aufgebaut. Das auf dem Bild gezeigte Teil wird also zwei mal benötigt.

Aufbau Druckbettauflage
Muss winklig sein !!!

3D Drucker – Austausch Umlenkrollen

Am Mendel habe ich die Umlenkrollen, die ich aus Multiplexplatten gefertigt hatte, gegen einen gedruckten Umlenkrollenhalter mit integrierter Spannmöglichkeit ausgetauscht.

Umlenkrollenhalter aus Holz – X-Achse
Umlenkrolle mit Spannmöglichkeit für Riemen

Umlenkrolle Y-Achse

Grundlage für den Umbau habe ich bei www.thingiverse.com gefunden. Den Schlitten für die X-Achse habe ich in OpenSCAD, so dass dieser um 90° gedreht ist, neu gezeichnet.

Mähroboter Landroid

Heute 16.04.2018 habe ich den WORX-Landroid SB450 WR102SI.1 beim Bauhaus in Pforzheim gekauft.

20 V, Li-Ionen, 2 Ah, Max. Flächenempfehlung: 450 m²

  • Mäht bis zu 450 m² Rasenfläche vollautomatisch im Zufallsprinzip
  • W-LAN Funktion für einfache Programmierung per Smartphone
  • Multi-Zonenfunktion für unterschiedlich beschaffene Gartenbereiche
  • Schafft Steigungen bis 35 %
  • Patentierte AIA Technik ermöglicht das mühelose Mähen von engen und verwinkelten Flächen

3D Drucker – Extruderumbau

  1. Der bisherige Extruder, direkt am Hotend soll auf einen Bowedenextruder umgebaut werden.

Gründe für den Umbau:

  • PLA-Filament wird beim Fördern teilweise so warm, das es durch den Extruder nicht mehr in den Kühlkörper des Hotend’s geschoben wird. Durch das trennen von Hotend und Extruder verspreche ich mir einen besseren Materialtransport.
  • Die Mechanik am Extruder wird durch das Hotend nicht mehr erwärmt
  • Die mitfahrende X-Achse wird um einiges leichter. Der Schrittmotor plus Halterung sowie der jetzige Vorschub entfallen auf der X-Achse.

Die erforderlichen Teile habe ich bestellt bez. werden aus Hartholz hergestellt. Später werden die Holzteile mit ABS gedruckt.

HyperCube 3D-Drucker

Nach dem ich den Franzis-Mendel erfolgreich zum laufen gebracht habe, habe ich beschlossen, einen HyperCube 3D Drucker zu bauen. Den HyperCube habe ich bei thingiverse.com gefunden. Der Drucker HyperCube 3D Printer/CNC von thingiverse-Mitglied Tech2C ist lizensiert unter der  Creative Commons – Attribution – Non-Commercial Lizens.

Von Tech2C gibt es bei YouTube einen BuildLog wo Tech2C genau den Aufbau, leider nur auf Englisch, beschreibt. Das BuildLog besteht aus zur Zeit 20 sehr ausführlichen und guten Videos.

Warum will ich den Drucker bauen?
Der Franzis-Mendel funktioniert, vor allem nach den diversen Verbesserungen, gut. Vom HyperCube erwarte ich allerdings einiges mehr an Genauigkeit, und vor allem an Geschwindigkeit.

3D Drucker – Schritte pro mm berechnen

Anzahl der Microschritte
RAMPS unterstützt 1/16 Schritte (Steps)

Berechnung Riemenscheibe:
Berechnung Schritte (Steps)/ mm

Motordaten:
Schrittwinkel = 1,8 Grad/Schritt
Schritte für eine Umdrehung = 360 Grad / 1,8 Grad/Schritt
Schritte für eine Umdrehung = 200 Schritte

Motrotreiber:
Jeder Schritt wird in Microschritte aufgeteilt
Treiber Microschritte = 1/16
Microschritte pro Umdrehung = 200 Motorschritte * 16 Microschrittt = 3200 Schritte

Riemenscheibe:
Zahnteilung = 2mm (GT2 Belt)
Anzahl Zähne = 36 (20)
Scheibenumfang = Zahnteilung * Zähne
Scheibenumfang = 2mm * 36 Zähne
Schiebenumfang = 72mm (40mm)

Schritte pro mm = 3200 Schritte/Umdrehung / 72mm
Schritte pro mm = 44,4444 (80) Schritte
==================================

Berechnung Trapetzspindel:
Berechnung Schritte (Steps)/mm

Motordaten und Treiberdaten bleiben wie bei der Riemenscheibe

Trapetzgewindespindel:
Steigung der Spindel (Pitch) = 2mm/Umdrehung

Schritte pro mm = 3200 Schritte/Umdrehung / 2mm
Schritte pro mm = 1600 Schritte
==================================

Berechnung Extrudervorschub:
Berechnung Schritte (Steps)/mm

Motordaten und Treiberdaten bleiben wie bei der Riemenscheibe

Vorschubrad für 1,75mm und 3mm Filament:
Durchmesser Zahnrad = 11mm
Umfang = 3,14 * Durchmesser = 34,5mm
Schritte pro mm = 3200 Schritte/Umdrehung / 34,5mm
Schritte pro mm = 92,75 Schritte

 

Arduino – Bitmanipulation

&       bitweise AND – Verknüpfung (bitwise and)
<<     (bitshift left)
>>     (bitshift right)
^       bitweise XOR – Verknüpfung (bitwise xor)
|         bitweise OR – Verknüpfung (bitwise or)
~       bitweise NOT – Verknüpfung (bitwise not)

Bit Setzen 

// Setzen von Bit 2 und 7 im Register
// Die Bit's in Register werden mit B10000100 ODER verknüpft

   Register |= B10000100; // Nur Bit 2 und 7 werden auf 1 gesetzt, die restlichen Bits bleiben unverändert
   // entspricht
   Register = Register | B10000100;

// oder
   Register |= (1 << Bit2); //Bit2 wird auf 1 gesetzt
   Register |= (1 << Bit7); //Bit7 wird auf 1 gesetzt

// oder
   Register |= (1 << Bit2) | (1 << Bit7); //Bit2 und Bit7 werden auf 1 gesetzt

Bit löschen

// Löschen von Bit 2 und 7 im Register
   Register &= ~B10000100;
   // entspricht
   Register = Register & ~B10000100;

// oder
   Register &= ~(1 << Bit2); // Bit2 wird auf 0 gesetzt
   Register &= ~(1 << Bit7); // Bit7 wird auf 0 gesetzt

// oder
   Register &= ~(1 << Bit2) | (1 << Bit7); //Bit2 und Bit7 werden auf 0 gesetzt

Bit invertieren (umschalten)

// invertiert Bit 4 im Register 
   Register ^= B00010000;
   // entspricht
   Register = Register ^ B00010000; // Invertiert Bit4

// oder
   Register ^= (1 << Bit4); // Invertiert Bit4

Bit abfragen

// abfragen des  WGM12-Bits im TCCR1B Register
   byte bitStatus = (TCCR1B & (1 << WGM12)) >> WGM12;

// oder mit
// Bedingungsoperator
   bool bitStatus = (TCCR1B & (1 << WGM12)) == (1 << WGM12) ? 1 : 0;

Quellen:
arduino-projekte.webnode.at

Arduino – Ein- / Ausgangsports

  1. Data Direction Register x (DDRx)
    Die einzelnen Bits geben an, ob der jeweilige Pin als Ein- oder Ausgang benutzt wird.
    DDxn = 0 -> Eingang
    DDxn = 1 -> Ausgang
  2. Port x Data Register (PORTx)
    Wenn ein Pin im Data Direction Register x (DDRx) als Ausgang definiert ist:
    PORTxn = 0 -> Ausgabe von logisch „0“
    PORTxn = 1 -> Ausgabe von logisch „1“
    Wenn ein Pin im Data Direction Register X (DDRX) als Eingang definiert ist:
    PORTxn = 0 -> Interner Pullup-Widerstand deaktiviert
    PORTxn = 1 -> Interner Pullup-Widerstand aktiviert
  3. Port x Input Pins Register (PINxn)
    Wenn ein Pin im Data Direction Register X (DDRX) als Eingang definiert ist, stellt PINXn des jeweiligen Zustand des Pins dar.

Tabelle 1:

Bit (n) 7 6 5 4 3 2 1 0
DDRx  DDxn DDxn DDxn DDxn DDxn DDxn DDxn DDxn
PORTBn D13 D12 D11 D10 D9 D8
PORTCn A5 A4 A3 A2 A1 A0
PORTDn D7 D6 D5 D4 D3 D2 D1 D0
PINx PINx7 PINx6 PINx5 PINx4 PINx3 PINx2 PINx1 PINx0
Ein- / Ausgangsports

x = Portnummer, n = Bitnummer

Beispiel:
Setzen der Binär-Pins D2 und D7 als Ausgang:

(D2 und D7 sind die Bits 2 und 7 am Port D)

DDRD |= B10000100; // Nur Bit 2 und 7 werden verändert

// oder

DDRD |= (1 << DDD2); //D2 ist Ausgang
DDRD |= (1 << DDD7); //D7 ist Ausgang

// oder

DDRD |= (1 << DDD2) | (1 << DDD7); //D2 und D7 sind Ausgaenge


Ausgabe von logisch „1“ und logisch „0“ am Beispiel Binär-Pin D10:

(D10 ist das Bit 2 am Port B)

//D10 als Ausgang setzen
DDRB |= (1 << DDB2);

//D10 auf "1" setzen
PORTB |= (1 << PORTB2);

//D10 auf "0" setzen
PORTB &= ~(1 << PORTB2);


Einlesen des Binär-Pins D5 mit internem Pullup-Widerstand:

(D5 ist das Bit 5 am Port D)

//D5 als Eingang setzen
DDRD &= ~(1 << DDD5);

//Pullup-Widerstand aktivieren
PORTD |= (1 << PORTD5);

//Abfrage des Eingangs-Pin D5
byte bitStatus = (PIND & (1 << PIND5)) >> PIND5;