Download Inkscape here.

Make sure you download the 0.48 version.

For Macs, you will need to use XQuartz which you can download here.

Download the add-on for Inkscape here in order to convert the files into gcode.

There are instructions on how to install it into Inkscape below the download button.

Download Processing here.

Download the GCTRL.pde for Processing on this website.

http://www.ardumotive.com/new-cnc-plotter.html

You can also download example code files on that website.

 

 

#define dirPin 2
#define stepPin 3
#define dirPin2 8
#define stepPin2 9
#define MotorPin1 12
#define MotorPin2 11
#define Standby 10
#define PWM 5
#include <Stepper.h>
#define LINE_BUFFER_LENGTH 512
const int penZUp = 80;
const int penZDown = 40;
const int penServoPin = 6;
const int stepsPerRevolution = 20;
struct point {
float x;
float y;
float z;
};
struct point actuatorPos;
float StepInc = 1;
int StepDelay = 0;
int LineDelay = 50;
int penDelay = 50;
float StepsPerMillimeterX = 6.0;
float StepsPerMillimeterY = 6.0;
float Xmin = 0;
float Xmax = 40;
float Ymin = 0;
float Ymax = 40;
float Zmin = 0;
float Zmax = 1;

float Xpos = Xmin;
float Ypos = Ymin;
float Zpos = Zmax;
boolean verbose = false;
void setup() {
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
pinMode(stepPin2, OUTPUT);
pinMode(dirPin2, OUTPUT);
pinMode(MotorPin1, OUTPUT);
pinMode(MotorPin2, OUTPUT);
pinMode(Standby, OUTPUT);
pinMode(PWM, OUTPUT);
// Setup
Serial.begin( 9600 );

delay(200);
Serial.println(“Mini CNC Plotter alive and kicking!”);
Serial.print(“X range is from “);
Serial.print(Xmin);
Serial.print(” to “);
Serial.print(Xmax);
Serial.println(” mm.”);
Serial.print(“Y range is from “);
Serial.print(Ymin);
Serial.print(” to “);
Serial.print(Ymax);
Serial.println(” mm.”);
}
void loop()
{
delay(200);
char line[ LINE_BUFFER_LENGTH ];
char c;
int lineIndex;
bool lineIsComment, lineSemiColon;

lineIndex = 0;
lineSemiColon = false;
lineIsComment = false;

while (1) {
while ( Serial.available()>0 ) {
c = Serial.read();
if (( c == ‘\n’) || (c == ‘\r’) ) {
if ( lineIndex > 0 ) {
line[ lineIndex ] = ‘\0’;
if (verbose) {
Serial.print( “Received : “);
Serial.println( line );
}
processIncomingLine( line, lineIndex );
lineIndex = 0;
}
else {
}
lineIsComment = false;
lineSemiColon = false;
Serial.println(“ok”);
}
else {
if ( (lineIsComment) || (lineSemiColon) ) {
if ( c == ‘)’ ) lineIsComment = false;
}
else {
if ( c <= ‘ ‘ ) {
}
else if ( c == ‘/’ ) {
}
else if ( c == ‘(‘ ) {
lineIsComment = true;
}
else if ( c == ‘;’ ) {
lineSemiColon = true;
}
else if ( lineIndex >= LINE_BUFFER_LENGTH-1 ) {
Serial.println( “ERROR – lineBuffer overflow” );
lineIsComment = false;
lineSemiColon = false;
}
else if ( c >= ‘a’ && c <= ‘z’ ) {
line[ lineIndex++ ] = c-‘a’+’A’;
}
else {
line[ lineIndex++ ] = c;
}
}
}
}
}
}

void processIncomingLine( char* line, int charNB ) {
int currentIndex = 0;
char buffer[ 64 ];
struct point newPos;

newPos.x = 0.0;
newPos.y = 0.0;

while( currentIndex < charNB ) {
switch ( line[ currentIndex++ ] ) {
case ‘U’:
penUp();
break;
case ‘D’:
penDown();
break;
case ‘G’:
buffer[0] = line[ currentIndex++ ];
buffer[1] = ‘\0’;

switch ( atoi( buffer ) ){
case 0:
case 1:
char* indexX = strchr( line+currentIndex, ‘X’ );
char* indexY = strchr( line+currentIndex, ‘Y’ );
if ( indexY <= 0 ) {
newPos.x = atof( indexX + 1);
newPos.y = actuatorPos.y;
}
else if ( indexX <= 0 ) {
newPos.y = atof( indexY + 1);
newPos.x = actuatorPos.x;
}
else {
newPos.y = atof( indexY + 1);
indexY = ‘\0’;
newPos.x = atof( indexX + 1);
}
drawLine(newPos.x, newPos.y );
actuatorPos.x = newPos.x;
actuatorPos.y = newPos.y;
break;
}
break;
case ‘M’:
buffer[0] = line[ currentIndex++ ];
buffer[1] = line[ currentIndex++ ];
buffer[2] = line[ currentIndex++ ];
buffer[3] = ‘\0’;
switch ( atoi( buffer ) ){
case 300:
{
char* indexS = strchr( line+currentIndex, ‘S’ );
float Spos = atof( indexS + 1);
if (Spos == 30) {
penDown();
}
if (Spos == 50) {
penUp();
}
break;
}
case 114:
Serial.print( “Absolute position : X = ” );
Serial.print( actuatorPos.x );
Serial.print( ” – Y = ” );
Serial.println( actuatorPos.y );
break;
default:
Serial.print( “Command not recognized : M”);
Serial.println( buffer );
}
}
}

}

void drawLine(float x1, float y1) {

if (verbose)
{
Serial.print(“fx1, fy1: “);
Serial.print(x1);
Serial.print(“,”);
Serial.print(y1);
Serial.println(“”);
}

if (x1 >= Xmax) {
x1 = Xmax;
}
if (x1 <= Xmin) {
x1 = Xmin;
}
if (y1 >= Ymax) {
y1 = Ymax;
}
if (y1 <= Ymin) {
y1 = Ymin;
}

if (verbose)
{
Serial.print(“Xpos, Ypos: “);
Serial.print(Xpos);
Serial.print(“,”);
Serial.print(Ypos);
Serial.println(“”);
}

if (verbose)
{
Serial.print(“x1, y1: “);
Serial.print(x1);
Serial.print(“,”);
Serial.print(y1);
Serial.println(“”);
}

x1 = (int)(x1*StepsPerMillimeterX);
y1 = (int)(y1*StepsPerMillimeterY);
float x0 = Xpos;
float y0 = Ypos;
long dx = abs(x1-x0);
long dy = abs(y1-y0);
int sx = x0<x1 ? StepInc : -StepInc;
int sy = y0<y1 ? StepInc : -StepInc;

long i;
long over = 0;

if (dx > dy) {
for (i=0; i<dx; ++i) {
Xstep(sx);
over+=dy;
if (over>=dx) {
over-=dx;
Ystep(sy);
}
delay(StepDelay);
}
}
else {
for (i=0; i<dy; ++i) {
Ystep(sy);
over+=dx;
if (over>=dy) {
over-=dy;
Xstep(sx);
}
delay(StepDelay);
}
}

if (verbose)
{
Serial.print(“dx, dy:”);
Serial.print(dx);
Serial.print(“,”);
Serial.print(dy);
Serial.println(“”);
}

if (verbose)
{
Serial.print(“Going to (“);
Serial.print(x0);
Serial.print(“,”);
Serial.print(y0);
Serial.println(“)”);
}
delay(LineDelay);
Xpos = x1;
Ypos = y1;
}
void penUp() {
digitalWrite(Standby, HIGH);
digitalWrite(MotorPin1, HIGH);
digitalWrite(MotorPin2, LOW);
analogWrite(PWM, 100);
delay(1000);
Zpos=Zmax;
if (verbose) {
Serial.println(“Pen up!”);
}
}
void penDown() {
digitalWrite(Standby, HIGH);
digitalWrite(MotorPin1, LOW);
digitalWrite(MotorPin2, HIGH);
analogWrite(PWM, 100);
delay(1000);
Zpos=Zmin;
if (verbose) {
Serial.println(“Pen down.”);
}
}

void Xstep (int numstep) {

if (numstep < 0) {
numstep = abs(numstep);
digitalWrite(dirPin, HIGH);
}
else {
digitalWrite(dirPin, LOW);
}

for (int i = 0; i <= numstep; i++) {
digitalWrite(stepPin, HIGH);
delayMicroseconds(2000);
digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}

}
void Ystep (int numstep) {

if (numstep < 0) {
numstep = abs(numstep);
digitalWrite(dirPin2, HIGH);

}
else {
digitalWrite(dirPin2, LOW);
}

for (int i = 0; i <=numstep; i++) {
digitalWrite(stepPin2, HIGH);
delayMicroseconds(2000);
digitalWrite(stepPin2, LOW);
delayMicroseconds(2000);

}
}

DC Motor and Stepper Motor Test (with or without comments)

Stepper Test Code (with or without comments)