...

XY Table Code


Arduino Test code:

sample program for scanner x axis move: (change loop from 1000 to 250, for testing out the y axis move).

void setup() {                
  pinMode(2, OUTPUT); // blue
  pinMode(3, OUTPUT); // yellow
  pinMode(4, OUTPUT); // green
  pinMode(5, OUTPUT); // orange
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
}

void loop() {
  for (int i = 0; i < 1000; i++) {
    pulse(2);
    pulse(3);
    pulse(4);
    pulse(5);
  }
  for (int i = 0; i < 1000; i++) {
    pulse(5);
    pulse(4);
    pulse(3);
    pulse(2);
  }  
}

void pulse(int pinToPulse) {
  digitalWrite(pinToPulse, HIGH);
  delay(5);
  digitalWrite(pinToPulse, LOW);
  delay(5);
}

Launchpad listing:

Uploaded to the Launchpad using Energia, so this is actually an arduino C listing.


/*
    Listing is for a M430G2533, using Energia as the programmer.
 */
// pins for motor 1
const byte M1_A = P1_4;
const byte M1_B = P1_5;
const byte M1_C = P2_0;
const byte M1_D = P2_1;
// pins for motor 2
const byte M2_A = P2_2;
const byte M2_B = P2_3;
const byte M2_C = P2_4;
const byte M2_D = P2_5; 
// pin sequence for stepping motor1 and motor2
const byte M1PINS[] = {M1_A,M1_B,M1_C,M1_D};
const byte M2PINS[] = {M2_A,M2_B,M2_C,M2_D};
// direction constants
const byte D_LEFT  = 1;
const byte D_RIGHT = 2;
const byte D_UP    = 3;
const byte D_DOWN  = 4;

// each step needs to be a pulse a few ms wide, or motor doesn't step.
byte stepDwell = 10;
// pause a few ms between repeating input triggers
byte iPause = 20;
// track the current pin index in the step sequence
byte m1Pin = 0;
byte m2Pin = 0;
// holds the command code, sent over serial
char commandValue = '\0';
// holds the data, sent over serial
int dataValue = 0;

//
void setup() {
    Serial.begin(9600);
    // setup pins for output
    pinMode(M1_A, OUTPUT);
    pinMode(M1_B, OUTPUT);
    pinMode(M1_C, OUTPUT);
    pinMode(M1_D, OUTPUT);
    pinMode(M2_A, OUTPUT);
    pinMode(M2_B, OUTPUT);
    pinMode(M2_C, OUTPUT);
    pinMode(M2_D, OUTPUT);
}

//
void loop() {
    if (Serial.available()) {
        char incomingChar = Serial.read();
        if ('\n' == incomingChar) { // eol recvd, so process command and value collected so far
            processCommand(commandValue, dataValue);
            Serial.print("(");Serial.print(commandValue);Serial.print(dataValue);
            Serial.println(") ok >");// reply back to calling device
            commandValue = '\0'; // reset
            dataValue = 0; // reset
        } else if (isDigit(incomingChar)) {
            dataValue = (dataValue * 10) + (incomingChar - '0'); // accumulate the data value
        } else { // non-digit, so consider as a command code
            commandValue = incomingChar; // set the current command
        }
    }
}

/* -------------- support routines -------------- */

// returns true if 'digit' represents an ascii digit between 0 and 9
boolean isDigit (char digit) {
    return (digit >= '0' && digit <= '9');
}

//
void processCommand(char commandValue, int dataValue) {
    
    if ('i' == commandValue) {// set iPause
        iPause = dataValue;
        return;
    } else if ('s' == commandValue) {// set stepDwell
        stepDwell = dataValue;
        return;
    }
    // if "move" command, process it
    byte direction = 0;
    if ('L' == commandValue)
        direction = D_LEFT;
    else if ('U' == commandValue)
        direction = D_UP;
    else if ('D' == commandValue)
        direction = D_DOWN;
    else if ('R' == commandValue)   
        direction = D_RIGHT; 
        
    if (0 != direction) {
        // move...
        for (int i = 0; i < dataValue; i++)
            step(direction);
    }
}

//
void step(byte direction) {
    switch (direction) {
        case D_LEFT:
            m1Pin = cShift(-1,m1Pin);
            pulse(M1PINS[m1Pin]);
            break;
        case D_UP:
            m2Pin = cShift(1,m2Pin);
            pulse(M2PINS[m2Pin]);
            break;            
        case D_DOWN:
            m2Pin = cShift(-1,m2Pin);
            pulse(M2PINS[m2Pin]);
            break;
        case D_RIGHT:
            m1Pin = cShift(1,m1Pin);
            pulse(M1PINS[m1Pin]);
            break;
        default:
            // invalid value, ignore
            break;
    }
}

//
void pulse(byte pinToPulse) {
    digitalWrite(pinToPulse,HIGH);
    delay(stepDwell);
    digitalWrite(pinToPulse,LOW);    
    delay(iPause);
}

/*
   performs a circular shift of the index indexToShift, by shiftDirection.
   operation is done on a 4-bit word. returns the index shifted to.
   cShift(1,0) -> 1 (1000 -> 0100), cShift(1,1) -> 2 (0100 -> 0010)
   cShift(1,2) -> 3 (0010 -> 0001), cShift(1,3) -> 0 (0001 -> 1000)
   cShift(-1,0) -> 3 (1000 -> 0001), cShift(-1,1) -> 0 (0100 -> 1000)
   cShift(-1,2) -> 1 (0010 -> 0100), cShift(-1,3) -> 2 (0001 -> 0010)
*/
byte cShift(char shiftDirection, byte indexToShift) {
    char shiftedIndex = shiftDirection + indexToShift;
    if (shiftedIndex > 3)
        shiftedIndex = 0;
    else if (shiftedIndex < 0)
        shiftedIndex = 3;
    return shiftedIndex;
}