uStepperSLite.h

/********************************************************************************************
*       File:       uStepperSLite.h                                                         *
*       Version:    1.1.0                                                                   *
*       Date:       June 14, 2020                                                           *
*       Author:     Thomas Hørring Olsen                                                    *
*                                                                                           *   
*********************************************************************************************
*   (C) 2020                                                                                *
*                                                                                           *
*   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_S_LITE_H_
#define _USTEPPER_S_LITE_H_
 
#ifndef __AVR_ATmega328PB__
#error !!This library only supports the ATmega328pb MCU!!
#endif
 
#include <EEPROM.h>
 
typedef union
{
    float f;            
    uint8_t bytes[4];   
}floatBytes_t;
 
typedef struct 
{
    floatBytes_t P;             
    floatBytes_t I;             
    floatBytes_t D;             
    uint8_t invert;             
    uint8_t holdCurrent;        
    uint8_t runCurrent;         
    uint8_t checksum;           
}dropinCliSettings_t;
 
#define SDA SDA0
#define SCL SCL0
#define TWSTO TWSTO0
#define TWDR TWDR0
#define TWSTA TWSTA0
#define TWINT TWINT0
#define TWEA TWEA0
#define TWEN TWEN0
#define TWCR TWCR0
#define TWIE TWIE0
#define TWSR TWSR0
#define TWPS0 TWPS00
#define TWPS1 TWPS01
#define TWBR TWBR0
 
#include <inttypes.h>
#include <avr/io.h>
#include <util/delay.h>
#include <Arduino.h>
#include <uStepperServo.h>
#include "TMC2208.h"
#include "i2cMaster.h"
 
#define STEPGENERATORFREQUENCY 100000.0
 
#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 CW 0                        
 
#define CCW 1                       
 
#define HARD 1                          
 
#define SOFT 0                          
 
#define DELTAANGLETORPM ENCODERINTFREQ*(60.0/4095.0)
 
#define DELTAANGLETOSTEPSPERSECOND ENCODERINTFREQ*(3200.0/4095.0)
 
#define BRAKEON 1
 
#define BRAKEOFF 0
 
#define ENCODERINTFREQ 500.0    
 
#define ENCODERINTSAMPLETIME 1.0/ENCODERINTFREQ 
 
#define ENCODERADDR 0x36                
 
#define ANGLE 0x0E                      
 
#define STATUS 0x0B                     
 
#define AGC 0x1A                        
 
#define MAGNITUDE 0x1B  
 
#define PULSEFILTERKP 60.0
 
#define PULSEFILTERKI 500.0*ENCODERINTSAMPLETIME
 
#define SPS 0
 
#define RPM 1
 
extern "C" void TIMER1_COMPA_vect(void) __attribute__ ((signal,used));
 
extern "C" void TIMER3_COMPA_vect(void) __attribute__ ((signal,used,naked));
 
extern "C" void INT0_vect(void) __attribute__ ((signal,used));
 
extern "C" void INT1_vect(void) __attribute__ ((signal,used));
 
class uStepperEncoder
{
public:
    volatile int32_t angleMoved;    
    
    uint16_t encoderOffset;             
 
    volatile uint16_t oldAngle;         
 
    volatile uint16_t angle;            
 
    volatile float curSpeed;                
    uStepperEncoder(void);
    
    float getAngle(void);
    
    float getSpeed(bool unit = SPS);
    
    uint16_t getStrength(void);
    
    uint8_t getAgc(void);
    
    uint8_t detectMagnet(void);
    
    float getAngleMoved(void);
    
    void setup(void);
    
    void setHome(void);
 
private:
 
    friend void TIMER1_COMPA_vect(void) __attribute__ ((signal,used));
};
 
class uStepperSLite
{
public:
    
    volatile int32_t stepsSinceReset;       //offset 0
    volatile uint32_t cntSinceLastStep;     //offset 4
    volatile uint32_t stepDelay;            //offset 8
    volatile uint8_t stepGeneratorDirection;//offset 12
    volatile int32_t decelToStopThreshold;  //offset 13
 
    bool continous;                         //offset 17
 
    volatile uint8_t pidError = 0;          //offset 18
 
    volatile uint8_t state; 
 
    uint8_t mode;
 
    volatile int32_t stepCnt;   
 
    volatile uint8_t direction;     
 
    float velocity;                 
 
    float acceleration;             
    
    volatile float stepConversion;  
    
    float pTerm;    
 
    float stepsPerSecondToRPM;
 
    float RPMToStepsPerSecond;
 
    float iTerm;    
 
    float dTerm;                                
 
    float stallSensitivity = 0.992;
 
    float angleToStep;  
 
    float stepToAngle;
 
    volatile bool stall;
    
    volatile float RPMToStepDelay;
    
    volatile int32_t decelToAccelThreshold;
    
    volatile int32_t accelToCruiseThreshold;
 
    volatile int32_t cruiseToDecelThreshold;
 
    volatile float currentPidSpeed;
 
    volatile float currentPidAcceleration;
 
    volatile float pidStepsSinceReset;
 
    volatile int32_t targetPosition;
    
    volatile bool pidDisabled;
 
    bool brake;
 
    friend void TIMER1_COMPA_vect(void) __attribute__ ((signal,used));
    friend void TIMER3_COMPA_vect(void) __attribute__ ((signal,used,naked));
    friend void INT0_vect(void) __attribute__ ((signal,used));
    friend void uStepperEncoder::setHome(void); 
 
 
    void enableMotor(void);
    
 
    void disableMotor(void);
 
    void pid(float error);
 
    void pidDropin(float error);
 
    void checkConnectorOrientation(uint8_t mode);
 
    float getPidError(void);
 
    volatile float currentPidError;
 
    volatile float pidTargetPosition;
 
    uStepperEncoder encoder;        
 
    Tmc2208 driver;
 
    bool invertPidDropinDirection;
 
    uStepperSLite(float accel = 1000.0, float vel = 1000.0);
    
 
    void setMaxAcceleration(float accel);
 
    void setMaxVelocity(float vel);
 
    void runContinous(bool dir);
    
 
    void moveSteps(int32_t steps, bool dir, bool holdMode = BRAKEON);
    
 
    void hardStop(bool holdMode = BRAKEON);
    
 
    void softStop(bool holdMode = BRAKEON);
    
 
    void stop(bool brake = BRAKEON);
 
    void setup( uint8_t mode = NORMAL, 
                float stepsPerRevolution = 3200.0, 
                float pTerm = 0.75, 
                float iTerm = 3.0, 
                float dTerm = 0.0,
                bool setHome = true,
                uint8_t invert = 0,
                uint8_t runCurrent = 50,
                uint8_t holdCurrent = 30);  
 
    bool getCurrentDirection(void);
    
 
    uint8_t getMotorState(void);
    
 
    int32_t getStepsSinceReset(void);
 
    void setCurrent(uint8_t runCurrent, uint8_t holdCurrent = 25);
 
    void setHoldCurrent(uint8_t holdCurrent);
 
    void setRunCurrent(uint8_t runCurrent);
    
    float moveToEnd(bool dir, float stallSensitivity = 0.992);
 
    void moveToAngle(float angle, bool holdMode = BRAKEON);
 
    void moveAngle(float angle, bool holdMode = BRAKEON);
 
    bool isStalled(float stallSensitivity = 0.992);
 
    void disablePid(void);
 
    void enablePid(void);
 
    void setProportional(float P);
 
    void setIntegral(float I);
 
    void setDifferential(float D);
 
    void invertDropinDir(bool invert);
 
    void dropinCli();
 
    void parseCommand(String *cmd);
 
    void dropinPrintHelp();
 
private:
 
    bool detectStall(void);
 
    dropinCliSettings_t dropinSettings;
 
    bool loadDropinSettings(void);
 
    void saveDropinSettings(void);
 
    uint8_t dropinSettingsCalcChecksum(dropinCliSettings_t *settings);
};
 
extern i2cMaster I2C;       
 
#endif