#!/usr/bin/python

import os
import sys
import win32pipe
import win32file

FIFO_WRITE = "\\\\.\\pipe\\in.fifo"
FIFO_READ = "\\\\.\\pipe\\out.fifo"

print  "Sending data to arduino..."

def sendCommand(str):
    try:
        fileHandle = win32file.CreateFile(FIFO_WRITE, win32file.GENERIC_WRITE, 0, None, win32file.OPEN_EXISTING, 0, None)    
        win32file.WriteFile(fileHandle, str)
        win32file.CloseHandle(fileHandle)
    except:
        print "Error: Arduino pipe not open"
    else:
        print "Data sent"


if (sys.argv[1] == 'FAN'):
	sendCommand("FAN:%s" % sys.argv[2])
elif (sys.argv[1] == 'GAS'):
    sendCommand("GAS:%s" % sys.argv[2])
elif (sys.argv[1] == 'CAL'):
    sendCommand("CAL:%s" % sys.argv[2])
elif (sys.argv[1] == 'END'):
    sendCommand("END:0")

#!/usr/bin/python

import sys
import serial
import os
import serial.tools.list_ports
import win32pipe
import win32file

ports = serial.tools.list_ports.comports()
arduinoPort = None
for p in ports:
    if 'Arduino' in p[1]:
        arduinoPort = p[0]
        print p[1] + ' found at ' + p[0]
        break

if (arduinoPort is None):
    print "Arduino not connected?"
    sys.exit(-1)

arduino = serial.Serial(arduinoPort, 9600, timeout=2)

FIFO_WRITE = "\\\\.\\pipe\\out.fifo"
FIFO_READ = "\\\\.\\pipe\\in.fifo"

def sendToArduino(str):
    arduino.write(str)

def parseCmd(cmd):
    exit_flag=0
    print cmd
    try:
        cmd, val = cmd.split(':')
    except ValueError:
        print "Bad command!";
        return exit_flag

    if (cmd == 'FAN'):
        sendToArduino("FAN:%s\n" % val)
    elif (cmd == 'GAS'):
        sendToArduino("GAS:%s\n" % val)
    elif (cmd == 'CAL'):
        sendToArduino("CAL:%s\n" % val)
    elif (cmd == 'END'):
        exit_flag=1
    return exit_flag


p = win32pipe.CreateNamedPipe(FIFO_READ, win32pipe.PIPE_ACCESS_INBOUND, win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_WAIT, 1, 65536, 65536,300,None)
print  "Pipe open for data from Artisan..."

while True:
    try:
        win32pipe.ConnectNamedPipe(p, None)
        data = win32file.ReadFile(p, 4096)
        win32pipe.DisconnectNamedPipe(p)
        if data[0] == 0:
            exit_loop = parseCmd(data[1])
            if exit_loop == 1:
                break
        else:
            print 'ERROR', data[0]
    except:
        x=1

win32File.CloseHandle(p)

// Define stepper motor digital pins used on the Arduino for TB6600 driver
#define ENA_PIN 2
#define DIR_PIN 3
#define STEP_PIN 4
// Define PWM fan control digital pin used on Arduino.  I used an Interfan model PM240-24D-1751B-2TP fan
#define FAN_CTRL_PIN 11

// Arduino only supports a 255 range for PWM. (e.g. 0-255, so 254/100=2.54)
#define FAN_PWM_RANGE 2.54

// Physical 360 degree rotations of Huky needle valve from off to max desired gas output (5.5 kPa)
#define MAX_VALVE_360 3.25
// number of stepper motor steps in 360 degrees (set on TB6600 driver board for 1/32 microsteps)
#define STEPS_360 6400
// stepper motor speed in uSec.  increasing value slows down speed
#define STEP_DELAY 37
// direction and lock defines for stepper motor
#define CW 1
#define CCW 0
#define LOCK 0
#define UNLOCK 1

// global variable that holds the current stepper position
int _nCurrStepPos;

// buffers used to receive data from Artisan
#define CMD_SIZE 10
char buff[CMD_SIZE];

struct inCmd {
    char *cmd;
    unsigned int val;
} cmd;

void setup() {
	Serial.begin(9600);

	pinMode(LED_BUILTIN, OUTPUT);
	digitalWrite(LED_BUILTIN, LOW);
	
	// Initialize fan pin and turn it off
	pinMode(FAN_CTRL_PIN, OUTPUT);
	analogWrite(FAN_CTRL_PIN, 0);

	// initialize Arduino pins used by the TB6600 driver
	pinMode(ENA_PIN, OUTPUT);
	digitalWrite(ENA_PIN, UNLOCK);
	pinMode(DIR_PIN, OUTPUT);
	digitalWrite(DIR_PIN, LOW);
	pinMode(STEP_PIN, OUTPUT);
	digitalWrite(STEP_PIN, LOW);

	_nCurrStepPos = 0;
}

unsigned int _i = 0;
void loop() {
    while (Serial.available()) {
        //read a line ending with \n and store in buff
        char ch = Serial.read();
        buff[_i] = ch;
        if (ch == '\n' || _i >= CMD_SIZE) {
            parseCommand();
            runCommand();
            _i = 0;
            break;
        }
        ++_i;
    }
}

void parseCommand() {
    //parse command in format COMMAND:VALUE and store cmd/val in cmd struct
    char *valpos;
    for (int x = 0; x < CMD_SIZE; ++x) {
        if (buff[x] == ':') {
            valpos = &buff[x + 1];
            buff[x] = '\0';
        } else if (buff[x] == '\n') {
            buff[x] = '\0';
            break;
        }
    }
    cmd.cmd = buff;
    cmd.val = atoi(valpos);
}

void runCommand() {
    if (strncmp("FAN", cmd.cmd, CMD_SIZE) == 0) {
        SetFanSpeed(cmd.val);
    } else if (strncmp("GAS", cmd.cmd, CMD_SIZE) == 0) {
        MoveStepper(cmd.val);
    } else if (strncmp("CAL", cmd.cmd, CMD_SIZE) == 0) {
        SetCurrentStepperPos(cmd.val);
    } else {
        //Serial.print("Got unknown command: "); Serial.println(cmd.cmd);
    }
}

void SetFanSpeed(int nPercent) {
  //convert fan percentage to an Arduino supported PWM range and send to fan
  int x = int(nPercent * FAN_PWM_RANGE);
  analogWrite(FAN_CTRL_PIN, x);
}

void SetCurrentStepperPos(int nPercent)
{
	// during initial testing, the value of nPercent is recorded for each kPa position on the gauge
	// when starting roaster, after manually setting the needle valve to 0 kPa on the gauge call this function
	// where nPercent=0.  All subsequent gas settings are offsets from this starting valve position.
	
	_nCurrStepPos = nPercent * int(int(MAX_VALVE_360 * STEPS_360)/100);
}

void MoveStepper(int nPercent)
{
	// convert percent into absolute step location and move stepper shaft relative to current location
       // Note: whether to run CW or CCW depends on how motor coils of 4 wire stepper are attached to driver board.  May need to swap below.
	int nNewPos = nPercent * int(int(MAX_VALVE_360 * STEPS_360)/100);
	if (nNewPos == _nCurrStepPos) {
		return;
	}
	if (nNewPos > _nCurrStepPos) {
		RunStepper(nNewPos - _nCurrStepPos, CCW);
	} else {
		RunStepper(_nCurrStepPos - nNewPos, CW);
	}
	_nCurrStepPos = nNewPos;
}

void RunStepper(int nSteps, byte dir ) {
	// lock motor shaft, move nSteps in selected direction, and then unlock motor shaft
	digitalWrite(ENA_PIN, LOCK);
	digitalWrite(DIR_PIN, dir);  
	for (int x = 0; x < nSteps; x++) {
		digitalWrite(STEP_PIN, 1);
		delayMicroseconds(STEP_DELAY);
		digitalWrite(STEP_PIN, 0);
		delayMicroseconds(STEP_DELAY);
	}
	digitalWrite(ENA_PIN, UNLOCK);
}