4-axis Arduino based CNC hot wire foam cutter

Hi Dan,

So now I have found a solution. Well it seems so.

I have modified the file a little. Took away what I did not need, and added a few things.

Added STEPS_PER_MM as a constant

and put it here in your code:

void line(float newx,float newy,float newz,float newe) {

a[0].delta = (newx-px)*STEPS_PER_MM;

a[1].delta = (newy-py)*STEPS_PER_MM;

a[2].delta = (newz-pz)*STEPS_PER_MM;

a[3].delta = (newe-pe)*STEPS_PER_MM;

And this very simple solution makes my steppers turn exactly the way I want.

So now I send a Gcode:
G01 X10.0000 Y25.0000 Z5.0000 E25.0000

And every stepper moves the corresponding mm, which in my setup means 5120 steps/mm equals to e.g. my X-axis goes 10 mm Y-axix moves 25mm etc.

Really nice. I am very satisfied.

Below you have the entire modified file. I am not used to this, so I just put my name in the top. You should maybe change something. I have no intention to violate the GNU license.

//

// 4 Axis CNC Hot Wire Foam Cutter  - supports MEGA 2560 Arduino RAMPS 1.4

// [email protected] 2013-10-28

// Modified by [email protected] 2015-06-19

//

// Copyright at end of file.

// please see http://www.github.com/MarginallyClever/GcodeCNCDemo for more information.





//

// CONSTANTS

//

//#define VERBOSE              (1)  // add to get a lot more serial output.



#define VERSION              (2)  // firmware version

#define BAUD                 (57600)  // How fast is the Arduino talking?

#define MAX_BUF              (64)  // What is the longest message Arduino can store?

#define STEPS_PER_TURN       (400)  // depends on your stepper motor.  most are 200.

#define STEPS_PER_MM         (STEPS_PER_TURN*16/1.25)  // (400*16)/1.25 with a M8 spindle

#define MAX_FEEDRATE         (1000000)

#define MIN_FEEDRATE         (1)

#define NUM_AXIES            (4)





//

// STRUCTS

//

// for line()

typedef struct {

long delta;  // number of steps to move

long absdelta;

long over;  // for dx/dy bresenham calculations

} Axis;





typedef struct {

int step_pin;

int dir_pin;

int enable_pin;

int limit_switch_pin;

} Motor;





//

// GLOBALS

//

Axis a[NUM_AXIES];  // for line()

Axis atemp;  // for line()

Motor motors[NUM_AXIES];



char buffer[MAX_BUF];  // where we store the message until we get a ';'

int sofar;  // how much is in the buffer



// speeds

float fr=0;  // human version

long step_delay;  // machine version



float px,py,pz,pe;  // position



// settings

char mode_abs=1;  // absolute mode?



long line_number=0;





//

// METHODS

//





/**

* delay for the appropriate number of microseconds

* @input ms how many milliseconds to wait

*/

void pause(long ms) {

delay(ms/1000);

delayMicroseconds(ms%1000);  // delayMicroseconds doesn't work for values > ~16k.

}





/**

* Set the feedrate (speed motors will move)

* @input nfr the new speed in steps/second

*/

void feedrate(float nfr) {

if(fr==nfr) return;  // same as last time?  quit now.



if(nfr>MAX_FEEDRATE || nfr<MIN_FEEDRATE) {  // don't allow crazy feed rates

Serial.print(F("New feedrate must be greater than "));

Serial.print(MIN_FEEDRATE);

Serial.print(F("steps/s and less than "));

Serial.print(MAX_FEEDRATE);

Serial.println(F("steps/s."));

return;

}

step_delay = MAX_FEEDRATE/nfr;

fr=nfr;

}





/**

* Set the logical position

* @input npx new position x

* @input npy new position y

*/

void position(float npx,float npy,float npz,float npe) {

// here is a good place to add sanity tests

px=npx;

py=npy;

pz=npz;

pe=npe;

}





/**

* Supports movement with both styles of Motor Shield

* @input newx the destination x position

* @input newy the destination y position

**/

void onestep(int motor) {

#ifdef VERBOSE

char *letter="XYZE";

Serial.print(letter[]);

#endif



digitalWrite(motors[motor].step_pin,HIGH);

digitalWrite(motors[motor].step_pin,LOW);

}





/**

* Uses bresenham's line algorithm to move both motors

* @input newx the destination x position

* @input newy the destination y position

**/

void line(float newx,float newy,float newz,float newe) {

a[0].delta = (newx-px)*STEPS_PER_MM;

a[1].delta = (newy-py)*STEPS_PER_MM;

a[2].delta = (newz-pz)*STEPS_PER_MM;

a[3].delta = (newe-pe)*STEPS_PER_MM;



long i,j,maxsteps=0;



for(i=0;i<NUM_AXIES;++i) {

a.absdelta = abs(a.delta);

a.over=0;

if( maxsteps < a.absdelta ) maxsteps = a.absdelta;

// set the direction once per movement

digitalWrite(motors.dir_pin,a.delta>0?HIGH:LOW);

}



long dt = MAX_FEEDRATE/5000;

long accel = 1;

long steps_to_accel = dt - step_delay;

if(steps_to_accel > maxsteps/2 )

steps_to_accel = maxsteps/2;



long steps_to_decel = maxsteps - steps_to_accel;



Serial.print("START ");

Serial.println(dt);

Serial.print("TOP ");

Serial.println(step_delay);



Serial.print("accel until ");

Serial.println(steps_to_accel);

Serial.print("decel after ");

Serial.println(steps_to_decel);

Serial.print("total ");

Serial.println(maxsteps);

#ifdef VERBOSE

Serial.println(F("Start >"));

#endif



for( i=0; i<maxsteps; ++i ) {

for(j=0;j<NUM_AXIES;++j) {

a[j].over += a[j].absdelta;

if(a[j].over >= maxsteps) {

a[j].over -= maxsteps;



digitalWrite(motors[j].step_pin,HIGH);

digitalWrite(motors[j].step_pin,LOW);

}

}



if(i<steps_to_accel) {

dt -= accel;

}

if(i>=steps_to_decel) {

dt += accel;

}

delayMicroseconds(dt);

}



#ifdef VERBOSE

Serial.println(F("< Done."));

#endif



position(newx,newy,newz,newe);



where();

}





// returns angle of dy/dx as a value from 0...2PI

static float atan3(float dy,float dx) {

float a=atan2(dy,dx);

if(a<0) a=(PI*2.0)+a;

return a;

}







/**

* Look for character /code/ in the buffer and read the float that immediately follows it.

* @return the value found.  If nothing is found, /val/ is returned.

* @input code the character to look for.

* @input val the return value if /code/ is not found.

**/

float parsenumber(char code,float val) {

char *ptr=buffer;

while(ptr && *ptr && ptr<buffer+sofar) {

if(*ptr==code) {

return atof(ptr+1);

}

ptr=strchr(ptr,' ')+1;

}

return val;

}





/**

* write a string followed by a float to the serial line.  Convenient for debugging.

* @input code the string.

* @input val the float.

*/

void output(char *code,float val) {

Serial.print(code);

Serial.println(val);

}





/**

* print the current position, feedrate, and absolute mode.

*/

void where() {

output("X",px);

output("Y",py);

output("Z",pz);

output("E",pe);

output("F",fr);

Serial.println(mode_abs?"ABS":"REL");

}





/**

* display helpful information

*/

void help() {

Serial.print(F("GcodeCNCDemo6AxisV2 "));

Serial.println(VERSION);

Serial.println(F("Commands:"));

Serial.println(F("G00/G01 [X/Y/Z/E(steps)] [F(feedrate)]; - linear move"));

Serial.println(F("G04 P[seconds]; - delay"));

Serial.println(F("G90; - absolute mode"));

Serial.println(F("G91; - relative mode"));

Serial.println(F("G92 [X/Y/Z/E(steps)]; - change logical position"));

Serial.println(F("M18; - disable motors"));

Serial.println(F("M100; - this help message"));

Serial.println(F("M114; - report position and feedrate"));

Serial.println(F("All commands must end with a newline."));

}





/**

* Read the input buffer and find any recognized commands.  One G or M command per line.

*/

void processCommand() {

int cmd = parsenumber('G',-1);

switch(cmd) {

case  0:

case  1: { // line

feedrate(parsenumber('F',fr));

line( parsenumber('X',(mode_abs?px:0)) + (mode_abs?0:px),

parsenumber('Y',(mode_abs?py:0)) + (mode_abs?0:py),

parsenumber('Z',(mode_abs?pz:0)) + (mode_abs?0:pz),

parsenumber('E',(mode_abs?pe:0)) + (mode_abs?0:pe) );

break;

}

case  2:

case  4:  pause(parsenumber('P',0)*1000);  break;  // dwell

case 90:  mode_abs=1;  break;  // absolute mode

case 91:  mode_abs=0;  break;  // relative mode

case 92:  // set logical position

position( parsenumber('X',0),

parsenumber('Y',0),

parsenumber('Z',0),

parsenumber('E',0) );

break;

default:  break;

}



cmd = parsenumber('M',-1);

switch(cmd) {

case  17:  motor_enable();  break;

case  18:  motor_disable();  break;

case 100:  help();  break;

case 114:  where();  break;

default:  break;

}

}





/**

* prepares the input buffer to receive a new message and tells the serial connected device it is ready for more.

*/

void ready() {

sofar=0;  // clear input buffer

Serial.print(F(">"));  // signal ready to receive input

}





/**

* set up the pins for each motor

*/

void motor_setup() {

motors[0].step_pin=54;

motors[0].dir_pin=55;

motors[0].enable_pin=38;

motors[0].limit_switch_pin=3;



motors[1].step_pin=60;

motors[1].dir_pin=61;

motors[1].enable_pin=56;

motors[1].limit_switch_pin=14;



motors[2].step_pin=46;

motors[2].dir_pin=48;

motors[2].enable_pin=62;

motors[2].limit_switch_pin=18;



motors[3].step_pin=26;

motors[3].dir_pin=28;

motors[3].enable_pin=24;

motors[3].limit_switch_pin=34;



int i;

for(i=0;i<NUM_AXIES;++i) {

// set the motor pin & scale

pinMode(motors.step_pin,OUTPUT);

pinMode(motors.dir_pin,OUTPUT);

pinMode(motors.enable_pin,OUTPUT);

}

}





void motor_enable() {

int i;

for(i=0;i<NUM_AXIES;++i) {

digitalWrite(motors.enable_pin,LOW);

}

}





void motor_disable() {

int i;

for(i=0;i<NUM_AXIES;++i) {

digitalWrite(motors.enable_pin,HIGH);

}

}





/**

* First thing this machine does on startup.  Runs only once.

*/

void setup() {

Serial.begin(BAUD);  // open coms



motor_setup();

motor_enable();





where();  // for debugging purposes

help();  // say hello

position(0,0,0,0);  // set starting position

feedrate(1000);  // set default speed

ready();

}





/**

* After setup() this machine will repeat loop() forever.

*/

void loop() {

// listen for serial commands

while(Serial.available() > 0) {  // if something is available

char c=Serial.read();  // get it

Serial.print(c);  // repeat it back so I know you got the message

if(sofar<MAX_BUF-1) buffer[sofar++]=c;  // store it

if(c=='n') {

// entire message received

// we got a message and it ends with a semicolon

buffer[sofar]=0;  // end the buffer so string functions work right

Serial.print(F("rn"));  // echo a return character for humans

processCommand();  // do something with the command

ready();

}

}

}





/**

* This file is part of GcodeCNCDemo.

*

* GcodeCNCDemo is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* GcodeCNCDemo is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with Foobar. If not, see .

*/

Ok – Pull Request made after a lot of reading 😉

Hope you survive in Russia and get home to your base again fit for fight.

When will you come up with some news from Russia?