CNC-Fräse

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 ü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.

Hardware

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

Leistungselektronik

Die Ansteuerung der Schrittmotoren basiert auf vier Toshiba TA8435H Treibern.

Leistungselektronik hinten

Leistungselektronik vorne

Verbindung CNC 25-Pol DSUB Stecker

Typen

   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 

Breite Reihe

   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

Schmale Reihe

   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 ) 

Experimentelle Ansteuerung

CNC mit Arduino ansteuern

Um die Ansteuerung der Leistungselektronik zu testen wurde folgende neben der notwendigen Verkabelung folgender Code verwendet:

   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
   }