DaveSauce fucked around with this message at 19:52 on Jan 29, 2015

DaveSauce fucked around with this message at 04:37 on Jan 30, 2015

typedef struct
{
  unsigned long timeDelayUS;
  unsigned long lastExecuted;
} periodicFunction;

/*
  stepperControl
  
  This code is a basic bipolar stepper control.
 */

#include "stepperMotorStructs.h"

// Define motor output pins
int wire[4] = {2, 4, 7, 8};

// Define analog input pins
int speedPotInput = 0;

// Motor output states, configured for 4 wire control
int stepperFirstStep = 0;               // First step
int stepperLastStep = 3;                // Last step
int currentStep = 0;                    // Initial step (1 through 4)
bool stepState[4] = {1,0,1,0};          // defaults to state 1 on initial run

bool motorDirection = 1;                // Set motor direction, 0 = REV, 1 = FWD

unsigned long stepsPerRev = 400;                  // Number of steps per rotation
unsigned long gearRatio = 1;                      // Gear ratio, output shaft to motor
unsigned long maxSpeed = 100;                      // Max speed of motor, RPM

unsigned long speedCommand = 0;                   // Reference speed command
unsigned long speedCommandMin = 0;                // Minimum speed command (for scaling)
unsigned long speedCommandMax = 1023;             // Maximum speed command (for scaling)

unsigned long stepDelay = 500000;                  // Delay between step state changes (in us)

// assign time slices to periodic code sections
periodicFunction analogReadFunction = {1000, 0};          // Set the analog read update rate
periodicFunction stepChangeFunction = {1000000, 0};       // Set the step change rate
periodicFunction diagnosticFunction = {1000000, 0};        // Set the diagnostic reporting rate

// diagnostic variables
unsigned int currentScanStart = 0;        // Start time of current scan
unsigned int lastScanTime = 0;            // Scan since start of last loop()
unsigned int maxScanTime = 0;             // Max scan time since last power cycle
unsigned int currentDiagScanStart = 0;    // Start time of current diagnostic routine
unsigned int lastDiagScanTime = 0;        // Scan time of the last diagnostic loop

// the setup routine runs once when you press reset:
void setup() 
{
  // start serial debugging
  Serial.begin(115200);
  
  // initialize motor wire pins as outputs
  for (int i = 0; i < 4; i++)
  {
    pinMode(wire[i], OUTPUT);
  }
  
}

// the loop routine runs over and over again forever:
void loop() 
{
  // Calculate loop scan time
  currentScanStart = micros();
  if(lastScanTime > maxScanTime)
  {
    maxScanTime = lastScanTime;
  }
  
  // Calculate the delay between loops
  //  Use the speed pot to translate analog signal to steps per
  //  second, which is then translated to delay between steps.
  
  if (runtimeCheck(&analogReadFunction))
  {
    // Read analog signal from pin
    speedCommand = analogRead(speedPotInput);
    
    // calculate delay time between steps
    stepDelay = (60000000)/(((speedCommand-speedCommandMin)*(stepsPerRev * maxSpeed))/(speedCommandMax-speedCommandMin));
    stepChangeFunction.timeDelayUS = stepDelay;
  }

  if (runtimeCheck(&stepChangeFunction))
  {
      // increment the step
    if (motorDirection)
    {
      // motor is moving forward, add 1 to step
      currentStep++;
      if (currentStep > stepperLastStep)
      {
        // motor has reached last step; reset to first step
        currentStep = stepperFirstStep;
      }
    }
    else
    {
      // motor is moving reverse, subtract 1 from step
      currentStep--;
      if (currentStep < stepperFirstStep)
      {
        // motor has reached first step; reset to last step
        currentStep = stepperLastStep;
      }      
    }
  }
 
  int stepResult = step(currentStep, stepState);
  
  if (stepResult >= 0)
  {
    for(int i = 0; i < 4; i++)
    {
      if (stepState[i] == 1)
      {
        digitalWrite(wire[i], HIGH);
      }
      else
      {
        digitalWrite(wire[i], LOW);
      }
    }
  }  
  // Step funciton has failed for some reason.  Write all outputs to zero.
  // -- should add some extra error handling/signalling
  else
  {
    for (int i = 0; i < 4; i++)
    {
      stepState[i] = 0;
    }  
  }
  
  if(runtimeCheck(&diagnosticFunction))
  {
    currentDiagScanStart = micros();
    Serial.print("\n\n\n---------- Diagnostics at ");
    Serial.print(currentDiagScanStart);
    Serial.print("\nMaximum scan time: ");
    Serial.print(maxScanTime);
    Serial.print("\nLast scan time: ");
    Serial.print(lastScanTime);
    Serial.print("\nLast diagnostic scan time: ");
    Serial.print(lastDiagScanTime);
    lastDiagScanTime = micros() - currentDiagScanStart;
  }
  lastScanTime = micros() - currentScanStart;
}

/*
  Runtime check
    Checks how long it's been since a routine was last run and compares it against
      its expected delay.
    Returns 1 if routine should be run
    Returns 0 if routine should not be run
*/
boolean runtimeCheck(periodicFunction *function)
{
  unsigned long currentTime = micros();
  unsigned long timeSinceExec = 0;
  // Check if millis() has overflowed since last function exectution
  if (currentTime < function->lastExecuted)
  {
    // millis() has overflowed.  Time since last execution will be the max value
    //  of millis() minus the last execution time plus current value of millis()
    //  plus 1 (to account for overflow).
    timeSinceExec = (4294967295 - function->lastExecuted) + micros() + 1;
  }
  else
  {
    timeSinceExec = (micros() - function->lastExecuted);
  }
  // Check if function should be executed
  if (timeSinceExec >= function->timeDelayUS)
  {
    // set lastExecuted to the current time
    function->lastExecuted = micros();
    return 1;
  }
  
  return 0;  
}

/* Stepper output control - 4 steps
 Use the following 4-step gray code for the stepper motor:
 State  1  2  3  4
 0      1  0  1  0
 1      0  1  1  0
 2      0  1  0  1
 3      1  0  0  1
*/
int step(int sequence, bool state[4]) 
{
  if (sequence < 0 || sequence > 3)
  {
    return -1;
  } 
  else
  {
    switch(sequence)
    {
    case 0:
      state[0] = 1;
      state[1] = 0;
      state[2] = 1;
      state[3] = 0;      
      break;
    case 1:
      state[0] = 0;
      state[1] = 1;
      state[2] = 1;
      state[3] = 0; 
      break;
    case 2:
      state[0] = 0;
      state[1] = 1;
      state[2] = 0;
      state[3] = 1; 
      break;
    case 3:
      state[0] = 1;
      state[1] = 0;
      state[2] = 0;
      state[3] = 1; 
      break;
    }
  }
  
  return 0;
}

DaveSauce fucked around with this message at 18:46 on Jan 30, 2015

for (int i = YMIN; i < YMAX; i += 50){
    // Move servo
    yPos.writeMicroseconds(i); 
  
    // Ping
    digitalWrite(2, HIGH);
    digitalWrite(3, LOW);
    delayMicroseconds(2);
    digitalWrite(3, HIGH);
    delayMicroseconds(5);
    digitalWrite(3, LOW);
    // Return ping
    duration = pulseIn(4, HIGH);

    // Convert time to distance
    cm = microsecondsToCentimeters(duration);
 
    // Print output
    Serial.print(i);
    Serial.print(" :: ");  
    Serial.print(cm);
    Serial.print("cm");
    Serial.println();
    
    // Add to array
    yDefault[i] = cm;
    
    delay(100); // Pause before moving the servo
  
  }  // For loop
}

PRADA SLUT fucked around with this message at 08:46 on Jan 31, 2015

for (int i = 0, j = YMIN; j < YMAX; j += ++i*50)

TheLastManStanding fucked around with this message at 09:37 on Jan 31, 2015

const int YMIN = 1000;		// Lower boundary on servo movement
const int YMAX = 2000;		// Upper boundary on servo movement
const int INCREMENT = 50;	// Increments in which the servo moves
int yrange = YMAX - YMIN;	// Total unquantized range of motion
yDefault[???] = {0};          	// Array which stores sensor data

for(int i = 0; i < YMAX/INCREMENT; i++) {

servo.writeMicroseconds(i*INCREMENT+YMIN); // Move servo

(take measurements)

yDefault[i] = measurement;	// Put measured data into the array

delay(100);
}

PRADA SLUT fucked around with this message at 10:01 on Jan 31, 2015

#define YMIN 1000
#define YMAX 2000
#define INCREMENT 50

#define TOTAL_NUM_STATES ((YMAX-YMIN)/INCREMENT)
int yrange = YMAX - YMIN;	// Total unquantized range of motion
int yDefault[TOTAL_NUM_STATES];          	// Array which stores sensor data
memset(yDefault,0,sizeof(int)*TOTAL_NUM_STATES);
for(int i = 0; i < TOTAL_NUM_STATES; i++) {

servo.writeMicroseconds(i*INCREMENT+YMIN); // Move servo

(take measurements)

yDefault[i] = measurement;	// Put measured data into the array

delay(100);
}

babyeatingpsychopath fucked around with this message at 14:31 on Jan 31, 2015

Globofglob fucked around with this message at 21:37 on Jan 31, 2015

for(int i = 0; i < (YMAX-YMIN)/INCREMENT; i++){servo.writeMicroseconds(i*INCREMENT+YMIN); // Move servo

TheLastManStanding fucked around with this message at 01:26 on Feb 2, 2015