CNC-Fräse: Unterschied zwischen den Versionen

Aus FabLab Rothenburg
Zur Navigation springen Zur Suche springen
Keine Bearbeitungszusammenfassung
 
(5 dazwischenliegende Versionen von 3 Benutzern werden nicht angezeigt)
Zeile 3: Zeile 3:
== Software ==
== Software ==


Die Steuerhardware und Software stammt von Burkhard Lewetz - Ing.Büro für technische Software-Entwicklungen (http://www.lewetz.de/). Original wurde die software WinPC-NC über eine serielle Verbindung genutzt. Die Original-Steuerung wurde inzwischen von der Leistungselektronik getrennt und soll durch eine eigene Ansteuerung basierend auf einem BeagleBone Black ersetzt werden.
Die Steuerhardware und Software stammt von Burkhard Lewetz - Ing.Büro für technische Software-Entwicklungen (http://www.lewetz.de/). Original wurde die Software WinPC-NC genutzt. Hierzu wird ein Windows-PC (oder Linux-PC mit Wine) benötigt; dieser wird per serieller Schnittstelle mit dem Achscontroller-PC in der Fräse verbunden. Dies hat den Vorteil, dass der (Windows) PC selbst nicht echtzeitfähig sein muss, sondern nur die Abläufe zu Beginn an den Achscontroller übermittelt.  Letzterer steuert dann die Stepper-Motoren in Echtzeit


== Hardware ==
== Hardware ==
Zeile 9: Zeile 9:
Die CNC-Fräse ist eine CUT2000 der Firma Haase (http://www.team-haase.de/).
Die CNC-Fräse ist eine CUT2000 der Firma Haase (http://www.team-haase.de/).


=== Leistungselektronik ===
[[Interna der CUT2000]]


Die Ansteuerung der Schrittmotoren basiert auf vier Toshiba TA8435H Treibern.
= Betrieb im Fablab =


[[Datei:Leistungselektronik_Hinten.jpeg|500px|center|thumb|Leistungselektronik hinten]]
Da die Fräse ein neues Innenleben in Form eines RaspberryPis und Arduino (mit grbl) bekommen hat<ref name="Pimp my CNC – Fräse 2.0">[https://fablab-rothenburg.de/pimp-my-cnc-fraese-2-0/ Pimp my CNC – Fräse 2.0]</ref> kann sie nun über verschiedene gängige grbl-controller angesprochen werden.


[[Datei:Leistungselektronik_Vorne.jpeg|500px|center|thumb|Leistungselektronik vorne]]
Auf dem RaspberryPi sind im Moment folgende installiert:
* [https://github.com/vlachoudis/bCNC/ bCNC] - Vollwertiger G-Code-Streamer auf Python Basis, der direkt am RaspberryPi genutzt werden kann
* [http://xyzbots.com/grblweb.html grblweb] - Webbasierter G-Code-Streamer der von jedem Rechner im FabLab über 192.168.111.202:8000 zu erreichen ist 


=== Verbindung CNC 25-Pol DSUB Stecker ===


==== Typen ====
== Freie Tools ==


<code>
* [http://pycam.sourceforge.net/ PyCAM] - konvertiert 3D-Modelle (STL-Format) in G-Code
    Ref[]       - Zuleitung für Referenzschalter 1-1 Verbindung mit RefOut bei gedrücktem Schalter
* [http://easel.inventables.com/ EASEL] - Pseudo-3D-Online Tool
    RefOut      - Ableitung für Referenzschalter
    direction[] - CNC-Input um Richtung einzustellen, [3.5V, 5V],  High vom Motor weg, Low zum Motor hin
    clock[]    - CNC-Input um Motoren anzusteuern, Geschwindigkeit des Flankenwechsels regelt Drehgeschwindigkeit
</code>


==== Breite Reihe ====
== Weitere Infos ==


<code>
* [http://linuxcnc.org/docs/html/gcode.html "G-Code" Quick Reference]
    01 - None
* [http://linuxcnc.org/docs/html/gcode/overview.html umfassende G-Code Referenz]
   
    02 - directionX
    03 - clockX
   
    04 - directionY
    05 - clockY
   
    06 - directionZ
    07 - clockZ
   
    08 - directionT
    09 - clockT
   
    10 - RefX
    11 - RefY
    12 - RefZ
    13 - RefT
</code>


==== Schmale Reihe ====


<code>
== Einzelnachweise ==
    14 - None
    15 - None
    16 - None
    17 - None
    18 - RefOut ( 24 bei 37-Pol Adapter )
    19 - RefOut ( 24 bei 37-Pol Adapter )
    20 - RefOut ( 24 bei 37-Pol Adapter )
    21 - RefOut ( 24 bei 37-Pol Adapter )
    22 - RefOut ( 24 bei 37-Pol Adapter )
    23 - RefOut ( 24 bei 37-Pol Adapter )
    24 - RefOut ( 24 bei 37-Pol Adapter )
    25 - RefOut ( 24 bei 37-Pol Adapter )
</code>


=== Experimentelle Ansteuerung ===
<references />
 
[[Datei:CNC_Arduino.jpg|500px|center|thumb|CNC mit Arduino ansteuern]]
 
Um die Ansteuerung der Leistungselektronik zu testen wurde folgende neben der notwendigen Verkabelung folgender Code verwendet:
 
<code>
    int pin_refX = 11;
    int pin_dirX = 12;    // LOW = Vom Motor weg
    int pin_clkX = 13;
   
    int pin_refY = 08;
    int pin_dirY = 09;    // LOW = Vom Motor weg. Gedreht, eigentlich zum Motor hin.
    int pin_clkY = 10;
   
    int pin_refZ = 05;
    int pin_dirZ = 06;    // LOW = Vom Motor weg
    int pin_clkZ = 07;
   
    int pin_refT = 02;
    int pin_dirT = 03;    // LOW = Vom Motor aus gesehen im Uhrzeigersinn
    int pin_clkT = 04;
   
    int pin_anaX = 00;
    int pin_anaY = 01;
    int pin_anaZ = 02;
    int pin_anaT = 03;
   
    void setup() {
        pinMode(pin_refX, INPUT_PULLUP);
        pinMode(pin_refY, INPUT_PULLUP);
        pinMode(pin_refZ, INPUT_PULLUP);
        pinMode(pin_refT, INPUT_PULLUP);
     
        pinMode(pin_dirX, OUTPUT);
        pinMode(pin_dirY, OUTPUT);
        pinMode(pin_dirZ, OUTPUT);
        pinMode(pin_dirT, OUTPUT);
 
        pinMode(pin_clkX, OUTPUT);
        pinMode(pin_clkY, OUTPUT);
        pinMode(pin_clkZ, OUTPUT);
        pinMode(pin_clkT, OUTPUT);
    }
   
    void driveX(int dir) {
        digitalWrite(pin_dirX, dir);
        digitalWrite(pin_clkX, HIGH);
        delayMicroseconds(1);
        digitalWrite(pin_clkX, LOW);
    }
   
    void driveY(int dir) {
        digitalWrite(pin_dirY, dir);
        digitalWrite(pin_clkY, HIGH);
        delayMicroseconds(1);
        digitalWrite(pin_clkY, LOW);
    }
   
    void driveZ(int dir) {
        digitalWrite(pin_dirZ, !dir); // Achtung, hier Richtung gedreht
        digitalWrite(pin_clkZ, HIGH);
        delayMicroseconds(1);
        digitalWrite(pin_clkZ, LOW);
    }
   
    void driveT(int dir) {
        digitalWrite(pin_dirT, dir);
        digitalWrite(pin_clkT, HIGH);
        delayMicroseconds(1);
        digitalWrite(pin_clkT, LOW);
    }
   
    void loop() {
        analogReference(DEFAULT);
        int anaX = analogRead(pin_anaX);
        int anaY = analogRead(pin_anaY);
        int anaZ = analogRead(pin_anaZ);
        int anaT = analogRead(pin_anaT);
 
        if(anaX < 340) { driveX( LOW); } else if(anaX > 680) { driveX(HIGH); }
        if(anaY < 340) { driveY( LOW); } else if(anaY > 680) { driveY(HIGH); }
        if(anaZ < 340) { driveZ( LOW); } else if(anaZ > 680) { driveZ(HIGH); }
        if(anaT < 340) { driveT(HIGH); } else if(anaT > 680) { driveT( LOW); }
     
        delayMicroseconds(1000); // 1000 als Wert zeigt in sicherer Geschwindigkeit eine bewegung
    }
</code>

Aktuelle Version vom 5. April 2019, 17:04 Uhr

Originalzustand

Software

Die Steuerhardware und Software stammt von Burkhard Lewetz - Ing.Büro für technische Software-Entwicklungen (http://www.lewetz.de/). Original wurde die Software WinPC-NC genutzt. Hierzu wird ein Windows-PC (oder Linux-PC mit Wine) benötigt; dieser wird per serieller Schnittstelle mit dem Achscontroller-PC in der Fräse verbunden. Dies hat den Vorteil, dass der (Windows) PC selbst nicht echtzeitfähig sein muss, sondern nur die Abläufe zu Beginn an den Achscontroller übermittelt. Letzterer steuert dann die Stepper-Motoren in Echtzeit

Hardware

Die CNC-Fräse ist eine CUT2000 der Firma Haase (http://www.team-haase.de/).

Interna der CUT2000

Betrieb im Fablab

Da die Fräse ein neues Innenleben in Form eines RaspberryPis und Arduino (mit grbl) bekommen hat[1] kann sie nun über verschiedene gängige grbl-controller angesprochen werden.

Auf dem RaspberryPi sind im Moment folgende installiert:

  • bCNC - Vollwertiger G-Code-Streamer auf Python Basis, der direkt am RaspberryPi genutzt werden kann
  • grblweb - Webbasierter G-Code-Streamer der von jedem Rechner im FabLab über 192.168.111.202:8000 zu erreichen ist


Freie Tools

  • PyCAM - konvertiert 3D-Modelle (STL-Format) in G-Code
  • EASEL - Pseudo-3D-Online Tool

Weitere Infos


Einzelnachweise