CNC-Fräse: Unterschied zwischen den Versionen

Aus FabLab Rothenburg
Zur Navigation springen Zur Suche springen
Keine Bearbeitungszusammenfassung
Keine Bearbeitungszusammenfassung
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]]
Um die CNC-Fräse im Fablab in Betrieb zu nehmen, gibt es letztlich mehrere Ansätze und Herangehensweisen.


[[Datei:Leistungselektronik_Vorne.jpeg|500px|center|thumb|Leistungselektronik vorne]]
* Betrieb der Fräse mit Achscontroller und Original-Software
 
* Ansatz von Felix und Paul: Achscontroller abklemmen und Steuerung komplett selbst übernehmen; Details siehe [[Experimentelle Ansteuerung der CUT2000]]
=== Verbindung CNC 25-Pol DSUB Stecker ===
* Ansatz von stesie: Achscontroller lassen, Windows-Software zu Gunsten einer Python-Eigenentwicklung über Bord werfen: [[PyPC-NC]]
 
==== Typen ====
 
<code>
    Ref[]      - Zuleitung für Referenzschalter 1-1 Verbindung mit RefOut bei gedrücktem Schalter
    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 ====
 
<code>
    01 - None
   
    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>
    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 ===
 
[[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>

Version vom 27. April 2014, 01:22 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

Um die CNC-Fräse im Fablab in Betrieb zu nehmen, gibt es letztlich mehrere Ansätze und Herangehensweisen.

  • Betrieb der Fräse mit Achscontroller und Original-Software
  • Ansatz von Felix und Paul: Achscontroller abklemmen und Steuerung komplett selbst übernehmen; Details siehe Experimentelle Ansteuerung der CUT2000
  • Ansatz von stesie: Achscontroller lassen, Windows-Software zu Gunsten einer Python-Eigenentwicklung über Bord werfen: PyPC-NC
Abgerufen von „https://wiki.fablab-rothenburg.de/index.php?title=CNC-Fräse&oldid=52“