#include <Arduino.

h>

#include <gcode.h>

#include <AccelStepper.h>

#include <LiquidCrystal.h>

#include <SimpleMenu.h>

#include <EEPROM.h>

#include <Plex.h>

#define EEPROM_SIZE 20

#define XMultiplier 48.2093663912 // number per 1mm

#define RMultiplier 400 // number per revilution

#define Speed 1000 //200

#define Acceleration 50000000.0

// inputs

#define UpPin 0

#define DownPin 1

#define BackPin 2

#define SelectPin 3

#define xLimitPin 4

// outputs
#define StepPinX 12

#define StepPinR 13

#define DirPin A5

#define XSelect 0

#define RSelect 3

#define enablePin A4

const float pi = 3.14159265359;

int XSpeed = 1000;

int DipSpeed = 1000;

AccelStepper stepperx(1,StepPinX,DirPin);

Plex PLEX;

AccelStepper stepperr(1,StepPinR,DirPin);
/****************************** CONTROL NOT USED YET ******************************/

void HomeMachine();

commandscallback commands[1] = {{"G28",HomeMachine}};

gcode Commands(1,commands);

/****************************** MENUS ******************************/

void About();

void RunProgram();

void SaveSettings();

int numberOfTurns = 100;

int width = 100;

int wireSpacing = 20;

SimpleMenu Menu[6] = {

SimpleMenu("# of Turns",&numberOfTurns,0,1000),

SimpleMenu("Width",&width,0,200),

SimpleMenu("Wire Spacing",&wireSpacing),

SimpleMenu("Run",RunProgram),

SimpleMenu("Save",SaveSettings),

SimpleMenu("About",About)

};

SimpleMenu TopMenu(6,Menu);

void display(SimpleMenu *_menu)

PLEX.lcd.clear();

PLEX.lcd.print(">");

PLEX.lcd.print(_menu->name);

SimpleMenu *next = TopMenu.next();

if(next != NULL)

PLEX.lcd.setCursor(1,1);

PLEX.lcd.print(next->name);
 }

void displayValue(SimpleMenu *_menu)

PLEX.lcd.clear();

PLEX.lcd.print(_menu->name);

PLEX.lcd.setCursor(0,1);

if(_menu == &Menu[1])

PLEX.lcd.print(_menu->getValue());

PLEX.lcd.print(" mm");

else if(_menu == &Menu[2])

int decimalValue = _menu->getValue()%1000;

int uppervalue = _menu->getValue()/1000;

PLEX.lcd.print(uppervalue);

PLEX.lcd.print(".");

if(decimalValue<10)

PLEX.lcd.print("0");

if(decimalValue<100)

PLEX.lcd.print("0");

if(decimalValue<1)
 PLEX.lcd.print("0");

PLEX.lcd.print(decimalValue);

PLEX.lcd.print(" mm");

else

PLEX.lcd.print(_menu->getValue());

/****************************** MAIN ******************************/

void setup()

{
 Commands.begin();

#ifndef __AVR__

EEPROM.begin(EEPROM_SIZE);

#endif

/*

pinMode(xLimitPin, INPUT);

pinMode(UpPin, INPUT);

pinMode(DownPin, INPUT);

pinMode(BackPin, INPUT);

pinMode(SelectPin, INPUT);*/

pinMode(enablePin, OUTPUT);

digitalWrite(enablePin,HIGH);

PLEX.lcd.begin(16,2);

stepperx.setMaxSpeed(Speed/10);

stepperx.setSpeed(Speed/10);

stepperx.setCurrentPosition(0);

stepperx.setAcceleration(Acceleration);

//stepperx.setPinsInverted(1,0,0);

stepperr.setMaxSpeed(Speed);

stepperr.setSpeed(Speed);

stepperr.setCurrentPosition(0);
 stepperr.setAcceleration(Acceleration);

LoadData();

About();

Enabled();

HomeMachine();

TopMenu.begin(display,displayValue);

void loop()

if(digitalPressedDelay(UpPin))

TopMenu.up();

if(digitalPressedDelay(DownPin))

TopMenu.down();

if(digitalPressed(SelectPin))

TopMenu.select();

if(digitalPressed(BackPin))

{
 TopMenu.back();

if(numberOfTurns<0)numberOfTurns=0;

if(width<0)width=0;

if(wireSpacing<0)wireSpacing=0;

/****************************** GUI ******************************/

void About()

PLEX.lcd.clear();

PLEX.lcd.print("Winding Machine");
 PLEX.lcd.setCursor(0, 1);

PLEX.lcd.print("Tinkers Projects");

while(true)

delay(1);

if(digitalPressed(SelectPin))

break;

void SaveSettings()

SaveData();

PLEX.lcd.clear();

PLEX.lcd.print(" Saved! ");

while(true)

delay(1);

if(digitalPressed(SelectPin))

break;

}
void RunProgram()

HomeMachine();

PLEX.lcd.clear();

PLEX.lcd.print("Winding ");

/*

PLEX.lcd.setCursor(0, 1);

PLEX.lcd.print("#: ");

/*

int totalTurns = 0;

double RealwireSpacing = wireSpacing/100;

double turnsPreWidth = width/RealwireSpacing;

double NumberOfLayers = numberOfTurns/turnsPreWidth;

*/

long x = width*XMultiplier;

long r = numberOfTurns*RMultiplier;

stepperx.moveTo(x);

stepperr.moveTo(r);

double WidthSpeed = XMultiplier/RMultiplier*(((double)wireSpacing)/1000)*Speed;

stepperx.setMaxSpeed(WidthSpeed);

stepperx.setSpeed(WidthSpeed);

/* PLEX.lcd.setCursor(3, 1);

PLEX.lcd.print(WidthSpeed);*/

while(stepperr.distanceToGo() != 0)

/*if(digitalPressed(SelectPin))

break;*/

if(stepperx.distanceToGo() == 0)

if(stepperx.currentPosition() == 0)

stepperx.moveTo(x);

else

stepperx.moveTo(0);

//PLEX.selectD(RSelect);

stepperr.run();

//PLEX.selectD(XSelect);
 stepperx.run();

/*

int totalTurns = 10;//stepperr.currentPosition()/(RMultiplier);

PLEX.lcd.setCursor(3, 1);

PLEX.lcd.print(totalTurns);*/

/*

PLEX.lcd.print(stepperx.currentPosition());

PLEX.lcd.print(" ");

PLEX.lcd.print(stepperx.distanceToGo());

PLEX.lcd.print(" ");

int PercentDone = totalTurns/numberOfTurns;

PLEX.lcd.setCursor(9, 0);

PLEX.lcd.print(PercentDone);

PLEX.lcd.print("%");

*/

PLEX.lcd.clear();

PLEX.lcd.print("Finished");

PLEX.lcd.setCursor(0, 1);
 PLEX.lcd.print("Cut/Remove Coil");

while(true)

delay(1);

if(digitalPressed(SelectPin))

break;

HomeMachine();

}
/****************************** MACHINE CONTROL ******************************/

void Enabled()

digitalWrite(enablePin,LOW);

void Disabled()

digitalWrite(enablePin,HIGH);

void HomeMachine()

PLEX.lcd.clear();

PLEX.lcd.print("Homing");

stepperx.setMaxSpeed(Speed/3);

stepperx.setSpeed(Speed/3);

PLEX.selectD(XSelect);

while(PLEX.digitalReadC(xLimitPin) == LOW)

stepperx.move(-10);

stepperx.run();
 }

stepperx.setCurrentPosition(0);

stepperr.setCurrentPosition(0);

/****************************** OTHER ******************************/

int pinStillPressed = -1;

int Currentdelay = 500;

bool digitalPressed(byte pin)

bool ispressed = LOW;

while(PLEX.digitalReadC(pin) == HIGH)
 {

pinStillPressed = -1;

Currentdelay = 500;

ispressed = HIGH;

delay(3);

return ispressed;

bool digitalPressedDelay(byte pin)

bool ispressed = LOW;

unsigned long timeStarted = millis();

while(PLEX.digitalReadC(pin) == HIGH)

ispressed = HIGH;

if(timeStarted+Currentdelay<millis())

pinStillPressed = pin;

Currentdelay -= 50;

break;

if(pinStillPressed == pin && PLEX.digitalReadC(pinStillPressed) == LOW)

 {

pinStillPressed = -1;

Currentdelay = 500;

if(Currentdelay<5)

Currentdelay = 5;

return ispressed;

bool digitalPressed(byte pin, bool PreedValue)

bool ispressed = LOW;

while(PLEX.digitalReadC(pin) == PreedValue)

pinStillPressed = -1;

Currentdelay = 500;

ispressed = HIGH;

delay(3);

return ispressed;

}
void SaveData()

EEPROM.write(0,100);

EEPROM.put(1, numberOfTurns);

EEPROM.put(5, width);

EEPROM.put(10, wireSpacing);

#ifndef __AVR__

EEPROM.commit();

#endif

void LoadData()

if(EEPROM.read(0) == 100)

EEPROM.get(1, numberOfTurns);

EEPROM.get(5, width);

EEPROM.get(10, wireSpacing);

}
}