uStepper.h

Go to the documentation of this file.

/********************************************************************************************
*       File:       uStepper.h                                                              *
*       Version:    1.3.0                                                                   *
*       date:       January 10th, 2018                                                      *
*       Author:     Thomas Hørring Olsen                                                    *
*                                                                                           *   
*********************************************************************************************
*   (C) 2018                                                                                *
*                                                                                           *
*   uStepper ApS                                                                            *
*   www.ustepper.com                                                                        *
*   administration@ustepper.com                                                             *
*                                                                                           *
*   The code contained in this file is released under the following open source license:    *
*                                                                                           *
*           Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International         *
*                                                                                           *
*   The code in this file is provided without warranty of any kind - use at own risk!       *
*   neither uStepper ApS nor the author, can be held responsible for any damage             *
*   caused by the use of the code contained in this file !                                  *
*                                                                                           *
********************************************************************************************/
#ifndef _USTEPPER_H_
#define _USTEPPER_H_

#ifndef __AVR_ATmega328P__
#error !!This library only supports the ATmega328p MCU!!
#endif

#include <inttypes.h>
#include <avr/io.h>
#include <avr/delay.h>
#include <Arduino.h>
#include <uStepperServo.h>

#define FULL 1                          

#define HALF 2                          

#define QUARTER 4                       

#define EIGHT 8                         

#define SIXTEEN 16                      

#define NORMAL  0                       

#define PWM     1                       

#define DROPIN  1                       

#define PID     2                       

#define STOP 1                          

#define ACCEL 2 

#define CRUISE 4                        

#define DECEL 8                         

#define INITDECEL 16                    

#define INTFREQ 28200.0f                

#define INTPERIOD 1000000.0/INTFREQ     

#define INTPIDDELAYCONSTANT 0.028199994 

#define CW 0                        

#define CCW 1                       

#define HARD 1                          

#define SOFT 0                          

#define ENCODERINTFREQ 1000.0           

#define ENCODERSPEEDCONSTANT ENCODERINTFREQ/10.0/4096.0 

#define ENCODERADDR 0x36                

#define ANGLE 0x0E                      

#define STATUS 0x0B                     

#define AGC 0x1A                        

#define MAGNITUDE 0x1B                  

#define R 4700.0                        

#define I2CFREE 0                       

#define READ  1                         

#define WRITE 0                         

#define START  0x08                     

#define REPSTART 0x10                   

#define TXADDRACK  0x18                 

#define TXDATAACK 0x28                  

#define RXADDRACK 0x40              

#define ACK 1                           

#define NACK 0                          
        
#define A 0.001295752996237     

#define B 0.000237488365866             

#define C 0.000000083423218             

extern "C" void interrupt0(void);

extern "C" void interrupt1(void);

extern "C" void TIMER2_COMPA_vect(void) __attribute__ ((signal,naked,used));

extern "C" void TIMER1_COMPA_vect(void) __attribute__ ((signal,used));

class float2
{
    public:
        float2(void);
        float getFloatValue(void);
        uint64_t getRawValue(void);
        void setValue(float val);
        float2 & operator=(const float &value);
        bool operator==(const float2 &value);
        bool operator!=(const float2 &value);
        bool operator>=(const float2 &value);
        bool operator<=(const float2 &value);
        bool operator<=(const float &value);
        bool operator<(const float2 &value);
        bool operator>(const float2 &value);
        float2 & operator*=(const float2 &value);
        float2 & operator-=(const float2 &value);
        float2 & operator+=(const float2 &value);
        float2 & operator+=(const float &value);
        float2 & operator/=(const float2 &value);
        const float2 operator+(const float2 &value);
        const float2 operator-(const float2 &value);
        const float2 operator*(const float2 &value);
        const float2 operator/(const float2 &value);
        uint64_t value;

    private:
        friend void TIMER2_COMPA_vect(void) __attribute__ ((signal,used));
        
};

class uStepperTemp
{
public:
    
    uStepperTemp(void);
    
    float getTemp(void);
private:
};

class uStepperEncoder
{
public:
    volatile int32_t angleMoved;        
    
    uint16_t encoderOffset;             

    volatile uint16_t oldAngle;         

    volatile uint16_t angle;            
    
    volatile int16_t revolutions;       

    volatile float curSpeed;                
    uStepperEncoder(void);
    
    float getAngle(void);
    
    float getSpeed(void);
    
    uint16_t getStrength(void);
    
    uint8_t getAgc(void);
    
    uint8_t detectMagnet(void);
    
    float getAngleMoved(void);
    
    void setup(uint8_t mode);
    
    void setHome(void);

private:

    friend void TIMER1_COMPA_vect(void) __attribute__ ((signal,used));
};

class uStepper
{
private:
    //Address offset: 0 
    uint16_t cruiseDelay;

    //Address offset: 2
    float2 multiplier;                  
    
    //Address offset: 10
    uint8_t state;      

    //Address offset: 11
    uint32_t accelSteps;                        
    
    //Address offset: 15
    uint32_t decelSteps;                
    
    //Address offset: 19
    uint32_t initialDecelSteps;             
    
    //Address offset: 23
    uint32_t cruiseSteps;               
    
    //Address offset: 27
    uint32_t currentStep;            
    
    //Address offset: 31
    uint32_t totalSteps;            
    
    //Address offset: 35
    bool continous;                 

    //Address offset: 36
    bool hold;                      

    //Address offset: 37
    bool direction;                 
    
    //Address offset: 38
    volatile int32_t stepsSinceReset;

    int32_t dummy;      
    
    //Address offset: 46
    float2 exactDelay;                              
    
    //Address offset: 54    
    uint16_t delay;             

    //Address offset: 56
    bool dropIn;                

    //Address offset: 57
    float velocity;                 

    //Address offset: 61
    float acceleration;             

    //address offset: 65
    volatile float tolerance;       
    
    //address offset: 69
    volatile float hysteresis;      
    
    //address offset: 73
    volatile float stepConversion;  

    //address offset: 77
    volatile uint16_t counter;      
    
    //address offset: 79
    volatile int32_t stepCnt;       
    
    //address offset: 83
    volatile int32_t control;       
    
    //address offset: 87
    volatile uint32_t speedValue[2];
    
    //address offset: 95
    float pTerm;                    
    
    //address offset: 99
    float iTerm;                    

    //address offset: 103
    float dTerm;                    
    
    //address offset: 107
    uint8_t mode;                   

    float angleToStep;      

    volatile bool stall;

    volatile bool invertDir;

    friend void TIMER2_COMPA_vect(void) __attribute__ ((signal,naked,used));
    friend void TIMER1_COMPA_vect(void) __attribute__ ((signal,used));
    friend void interrupt1(void);
    friend void uStepperEncoder::setHome(void);

    void startTimer(void);
    

    void stopTimer(void);
    

    void enableMotor(void);
    

    void disableMotor(void);

    void pidDropIn(void);

    void pid(void);

public:
    uStepperTemp temp;              
    uStepperEncoder encoder;        

    uStepper(float accel, float vel);
    

    uStepper(void);
    

    void setMaxAcceleration(float accel);
    

    float getMaxAcceleration(void);
    

    void setMaxVelocity(float vel);
    

    float getMaxVelocity(void);
    

    void runContinous(bool dir);
    

    void moveSteps(int32_t steps, bool dir, bool holdMode);
    

    void hardStop(bool holdMode);
    

    void softStop(bool holdMode);
    

    void setup( uint8_t mode = NORMAL, 
                uint8_t microStepping = SIXTEEN, 
                float faultTolerance = 10.0,
                float faultHysteresis = 5.0, 
                float pTerm = 1.0, 
                float iTerm = 0.02, 
                float dterm = 0.006,
                bool setHome = true);   

    bool getCurrentDirection(void);
    

    bool getMotorState(void);
    

    int32_t getStepsSinceReset(void);

    void pwmD8(double duty);

    void setCurrent(double current);

    void pwmD8(int mode);
    
    void pwmD3(double duty);


    void pwmD3(int mode);

    void updateSetPoint(float setPoint);
    
    float moveToEnd(bool dir);

    void moveToAngle(float angle, bool holdMode);

    void moveAngle(float angle, bool holdMode);

    bool isStalled(void);

    bool detectStall(float diff, bool running);
};

class i2cMaster
{
    private:
        uint8_t status;         


        bool cmd(uint8_t cmd);

    public:

        i2cMaster(void);
        
        bool readByte(bool ack, uint8_t *data);

        bool read(uint8_t slaveAddr, uint8_t regAddr, uint8_t numOfBytes, uint8_t *data);

        bool start(uint8_t addr, bool RW);
        
        bool restart(uint8_t addr, bool RW);
        
        bool writeByte(uint8_t data);
        
        bool write(uint8_t slaveAddr, uint8_t regAddr, uint8_t numOfBytes, uint8_t *data);

        bool stop(void);
        
        uint8_t getStatus(void);
        
        void begin(void);
};
extern i2cMaster I2C;       

#endif