File content as of revision 0:a1abeb6aa42c:

/* L6482 Driver code communicated via SPI
 * file name: StepperDriver.cpp
 * 07/15/2014 edited by Grace (Yi-Wen Liao)
 */
#include "StepperDriver.h"
#include "mbed.h"
 
StepperDriver::StepperDriver(PinName CSPin, PinName mosi, PinName miso, PinName sck) : _CSPin(CSPin), SPIPin(mosi,miso,sck)
{
    // When CSPin is high the device is unselected
    _CSPin = 1;
    SPIPin.format(8,3); // 8 bit data, Mode 3 
    SPIPin.frequency(5000000); // 8MHz clock rate
}

// StepperDrive Command Management (datasheet p.61)
void StepperDriver::setParam(char param, unsigned long value)
{
    param |= SET_PARAM;
    SPIWrite((char)param);
    paramHandler(param, value);
}

unsigned long StepperDriver::getParam(char param)
{
    SPIWrite(param|GET_PARAM);
    return paramHandler(param,0);
}

int StepperDriver::getStatus()
{
  int temp = 1;
  char* bytePointer = (char*)&temp;
  SPIWrite(GET_STATUS);
  bytePointer[1] = SPIWrite(0);
  bytePointer[0] = SPIWrite(0);
  return temp;
}    
    
void StepperDriver::run(char dir, float stepsPerSec)
{
    SPIWrite(RUN|dir);
    unsigned long integerSpeed = spdCalc(stepsPerSec);
    if (integerSpeed > 0xFFFFF) integerSpeed = 0xFFFFF;
    
    char *bytepointer = (char *)&integerSpeed;
    for (int i=2; i>=0; i--)  // most significant bytr first (datasheet p.61)
    {
        SPIWrite(bytepointer[i]);
    }
} 

void StepperDriver::move(char dir, unsigned long numSteps)
{ 
  SPIWrite(MOVE|dir);
  if (numSteps > 0x3FFFFF) numSteps = 0x3FFFFF;
  char* bytePointer = (char*)&numSteps;
  
  for (int i = 2; i >= 0; i--)
  {
    SPIWrite(bytePointer[i]);
  }
}

// StepperDriver Programming Manual (Datasheet p.43)
void StepperDriver::setAcc(float stepsPerSecondPerSecond)
{
  unsigned long integerAcc = accCalc(stepsPerSecondPerSecond);
  setParam(ACC, integerAcc);
}

void StepperDriver::setDec(float stepsPerSecondPerSecond)
{
  unsigned long integerDec = decCalc(stepsPerSecondPerSecond);
  setParam(DEC, integerDec);
}

void StepperDriver::setMaxSpeed(float stepsPerSecond)
{
  unsigned long integerSpeed = maxSpdCalc(stepsPerSecond);
  setParam(MAX_SPEED, integerSpeed);
}

void StepperDriver::setFullSpeed(float stepsPerSecond)
{
  unsigned long integerSpeed = FSCalc(stepsPerSecond);
  setParam(FS_SPD, integerSpeed);
}

void StepperDriver::setAccTVAL(char tvalInput)
{
    setParam(TVAL_ACC, (unsigned long)tvalInput);
}

void StepperDriver::setDecTVAL(char tvalInput)
{
    setParam(TVAL_DEC, (unsigned long)tvalInput);
}

void StepperDriver::setRunTVAL(char tvalInput)
{
    setParam(TVAL_RUN, (unsigned long)tvalInput);
}

void StepperDriver::setHoldTVAL(char tvalInput)
{
    setParam(TVAL_HOLD, (unsigned long)tvalInput);
}

unsigned long StepperDriver::accCalc(float stepsPerSecSec)
{
    float temp = stepsPerSecSec*0.06871947674;
    if( (unsigned long) long(temp) > 0x00000FFF) return 0x00000FFF;
    else return (unsigned long) long(temp);
}

unsigned long StepperDriver::decCalc(float stepsPerSecSec)
{
    float temp = stepsPerSecSec*0.06871947674;
    if( (unsigned long) long(temp) > 0x00000FFF) return 0x00000FFF;
    else return (unsigned long) long(temp);
}

unsigned long StepperDriver::spdCalc(float stepsPerSec)
{
    float temp = stepsPerSec*67.106;
    if( (unsigned long) long(temp) > 0x000FFFFF) return 0x000FFFFF;
    else return (unsigned long) temp;
}

unsigned long StepperDriver::maxSpdCalc(float stepsPerSec)
{
  unsigned long temp = ceil(stepsPerSec * 0.065536);
  if(temp > 0x000003FF) return 0x000003FF;
  else return temp;
}

unsigned long StepperDriver::minSpdCalc(float stepsPerSec)
{
  float temp = stepsPerSec * 4.194304;
  if( (unsigned long) long(temp) > 0x00000FFF) return 0x00000FFF;
  else return (unsigned long) long(temp);
}

unsigned long StepperDriver::FSCalc(float stepsPerSec)
{
  float temp = (stepsPerSec * 0.065536)-0.5;
  if( (unsigned long) long(temp) > 0x000003FF) return 0x000003FF;
  else return (unsigned long) long(temp);
}

void StepperDriver::resetDev()
{
  SPIWrite(RESET_DEVICE);
}

void StepperDriver::hardHiZ()
{
  SPIWrite(HARD_HIZ);
}

void StepperDriver::softHiZ()
{
  SPIWrite(SOFT_HIZ);
}

unsigned long StepperDriver::writeParam(unsigned long value, char bitLength)
{
    char byteLength = bitLength/8;
    if (bitLength%8 > 0) byteLength++;
    unsigned long mask = 0xFFFFFFFF >> (32-bitLength);
    if (value > mask) value = mask;
    char *bytePointer = (char*)&value;

    for(int i=byteLength-1; i>=0; i--)
    {
        bytePointer[i] = SPIWrite(bytePointer[i]);
    }

    return value;
}

char StepperDriver::SPIWrite(char data)
{
    char rxData;
    _CSPin = 0;
    rxData = SPIPin.write(data);
    _CSPin = 1;
    return rxData;
}

unsigned long StepperDriver::paramHandler(char param, unsigned long value)
{
    unsigned long returnValue = 0;
    switch (param)
    {
        case ABS_POS:
        returnValue = writeParam(value, 22);
        break;
    
        case EL_POS:
        returnValue = writeParam(value, 9);
        break;
   
        case MARK:
        returnValue = writeParam(value, 22);
        break;
        
        case SPEED:
        returnValue = writeParam(0, 20);
        break;
        
        case MAX_SPEED:
        returnValue = writeParam(value, 10);
        break;
      
        case ACC:
        returnValue = writeParam(value, 12);
        break;
        
        case DEC:
        returnValue = writeParam(value, 12);
        break;
        
        case MIN_SPEED: 
        returnValue = writeParam(value, 12);
        break;
 
        case FS_SPD:
        returnValue = writeParam(value, 10);
        break;
        
        case TVAL_HOLD:
        value &= 0x7F;
        returnValue = SPIWrite((char)value);
        break;
        
        case TVAL_RUN:
        value &= 0x7F;
        returnValue = SPIWrite((char)value);
        break;
        
        case TVAL_ACC:
        value &= 0x7F;
        returnValue = SPIWrite((char)value);
        break;
        
        case TVAL_DEC:
        value &= 0x7F;
        returnValue = SPIWrite((char)value);
        break;
            
        case OCD_TH: 
        value &= 0x1F;
        returnValue = SPIWrite((char)value);
        break;
      
        case STEP_MODE:
        returnValue = SPIWrite((char)value);
        break;
        
        case CONFIG: 
        returnValue = writeParam(value, 16);      
        break;
        
        case STATUS:
        returnValue = writeParam(0, 16);
        break;
        
        case ALARM_EN: 
        returnValue = SPIWrite((char)value);
        break;
        
        case GATECFG1:
        returnValue = writeParam(value, 11);
        break;
        
        case GATECFG2:
        returnValue = writeParam(value, 11);
        break;
        
        case T_FAST:
        returnValue = SPIWrite((char)value);
        break;
        
        case TON_MIN:
        returnValue = SPIWrite((char)value);
        break;
        
        case TOFF_MIN:
        returnValue = SPIWrite((char)value);
        break;

        case ADC_OUT:
        returnValue = SPIWrite((char)value);
        break;        
    }
    return returnValue;
}