stepper.h

Go to the documentation of this file.

#ifndef DRV_STEPPER_H
#define DRV_STEPPER_H

#include <cfg/compiler.h>

#include <algo/ramp.h>

// Forward declaration
struct Stepper;

#define STEPS_INFINITE_POSITIVE        ((int16_t)0xFFFF)
#define STEPS_INFINITE_NEGATIVE        ((int16_t)0x8FFF)

#define MAX_STEPS                      0x7FFF

#define MOTOR_NO_LEVEL_SENSOR          0xFFFF

#define MOTOR_NO_HOME_SENSOR           0xFFFF

#define DEAFSTEPS_DEFAULT              MAX_STEPS

//\{
#define SPEED_STOPPED                  0xFFFF    
#define SPEED_HOMING                   0xFFFE    
//\}

// default values for steps inside and outside home sensor
#define MOTOR_INSIDE_HOME_STEPS        10
#define MOTOR_OUTSIDE_HOME_STEPS       40

// default value for home sensor tolerance
#define MOTOR_TOLERANCE_HOME_STEPS      2

// default value for consecutive error
#define MOTOR_CONSECUTIVE_ERROR_STEPS   3

// values for the home control enabling
enum MotorHomeSensorCheck
{
    MOTOR_HOMESENSOR_NOCHECK = 0,
    MOTOR_HOMESENSOR_INCHECK,
    MOTOR_HOMESENSOR_OUTCHECK
};

// default value in ms for home procedure timeout
#define MOTOR_TIMEOUT_HOME              20000

enum MotorDirection
{
    DIR_POSITIVE = 1,       
    DIR_NONE = 0,           
    DIR_NEGATIVE = -1       
};

#define STEPPER_MAX_STATES    32


enum StepperState
{
    MSTS_UNINIT,        
    MSTS_RUN,           
    MSTS_IDLE,          
    MSTS_PREIDLE,       
    MSTS_PRERUN,        

// Home procedure
    MSTS_PREINIT,       
    MSTS_INIT,          
    MSTS_ENTERING,      
    MSTS_LEAVING,       
    MSTS_OUTHOME,       

    MSTS_ERROR,         

    MSTS_DUMMY_ALIGN = STEPPER_MAX_STATES - 1
};

typedef enum StepperState (*fsm_state)(struct Stepper* );

typedef void (*stepper_isr_t)(struct Stepper* );

typedef uint16_t stepper_time_t;

struct StepperConfig
{
    struct Ramp ramp;             
    uint16_t pulse;               

    fsm_state states[STEPPER_MAX_STATES];  

    int16_t stepsInHome;          
    int16_t stepsOutHome;         
    uint16_t clocksHome;          

    int16_t stepsTollOutHome;     
    int16_t stepsTollInHome;      

    int16_t timeoutHome;          

    uint8_t powerRun;             
    uint8_t powerIdle;            

    uint16_t homeSensorIndex;     
    uint16_t levelSensorIndex;    

    struct
    {
        bool homeInverted : 1;    
        bool halfStep : 1;        
        bool axisInverted : 1;    
        bool levelInverted : 1;   
        bool controlBit : 1;      
        bool controlMoveBit : 1;  
        bool highcurrentBit : 1;  
    } flags;
};


struct Stepper
{
    const struct StepperConfig *cfg; 
    fsm_state state;                 

    struct TimerCounter *timer;   
    uint16_t index;               

    volatile int16_t step;        
    volatile int16_t rampStep;    
#if RAMP_USE_FLOATING_POINT
    float rampValue;              
    float rampClock;              
#else
    uint16_t rampValue;
    uint32_t rampClock;
#endif

    enum MotorDirection dir;      
    uint8_t power;                

    uint16_t speed;               
    int16_t stepToReach;          

    int16_t skipIrqs;            
    int16_t changeCurrentIrqs;   

    int8_t  enableCheckHome;      
    int8_t  stepsErrorHome;       
    int16_t stepsTollMax;         
    int16_t stepsTollMin;         

    int16_t stepsDeaf;            
    int16_t stepsLevel;           

    int16_t stepCircular;         
};


void stepper_init(void);
void stepper_end(void);
struct Stepper *stepper_setup(int index, struct StepperConfig *cfg);
void stepper_disable(void);
void stepper_reset(struct Stepper *motor);
void stepper_home(struct Stepper *motor);
void stepper_setStep(struct Stepper *motor, int16_t step);
int16_t stepper_getStep(struct Stepper *motor);
int16_t stepper_move(struct Stepper *motor, int16_t step, uint16_t speed, int16_t deafstep);
void stepper_stop(struct Stepper *motor);
void stepper_break(struct Stepper *motor, enum StepperState state);
bool stepper_idle(struct Stepper *motor);
bool stepper_readHome(struct Stepper *motor);
bool stepper_readLevel(struct Stepper *motor);
void stepper_updateHalfStep(struct Stepper *motor);
void stepper_updateControlBit(struct Stepper *motor);
void stepper_updateControlMoveBit(struct Stepper *motor);
bool stepper_error(struct Stepper *motor);
bool stepper_inhome(struct Stepper *motor);
int16_t stepper_getLevelStep(struct Stepper *motor);
void stepper_set_stepCircular(struct Stepper *motor, int16_t steps);
int16_t stepper_get_stepCircular(struct Stepper *motor);
int16_t stepper_scaleSteps(struct Stepper *motor, int16_t dir);

#endif /* DRV_STEPPER_H */