uStepperS.h

Go to the documentation of this file.

/********************************************************************************************
*       File:       uStepperS.h                                                             *
*       Version:    2.0.0                                                                   *
*       Date:       March 30th, 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_H_
#define _USTEPPER_S_H_
 
#ifndef ARDUINO_AVR_USTEPPER_S
    #error !!This library only supports the uStepper S board!!
#endif
 
#ifndef __AVR_ATmega328PB__
    #error !!This library only supports the ATmega328PB MCU!!
#endif
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include <Arduino.h>
#include <EEPROM.h>
#include <inttypes.h>
#include <uStepperServo.h>
 
#define FREEWHEELBRAKE 0    
#define COOLBRAKE 1         
#define HARDBRAKE 2         
#define CW 1    
#define CCW 0   
#define POSITION_REACHED 0x20   
#define VELOCITY_REACHED 0x10   
#define STANDSTILL 0x08 
#define STALLGUARD2 0x04    
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;
 
typedef struct 
{
    float posError = 0.0;           
    float posEst = 0.0;             
    float velIntegrator = 0.0;      
    float velEst = 0.0;             
}posFilter_t;
 
 
class uStepperS;
#include <uStepperEncoder.h>
#include <uStepperDriver.h>
 
#define HARD 0  
#define SOFT 1  
#define DRV_ENN PD4     
#define SD_MODE PD5 
#define SPI_MODE PD6    
#define CS_DRIVER PE2   
#define CS_ENCODER PD7  
#define MOSI1 PE3   
#define MOSI_ENC PC2    
#define MISO1 PC0   
#define SCK1 PC1    
#define NORMAL  0       
#define DROPIN  1       
#define CLOSEDLOOP  2   
#define PID     CLOSEDLOOP  
#define CLOCKFREQ 16000000.0    
#define ENCODERINTFREQ 1000 
#define ENCODERINTPERIOD 1.0/ENCODERINTFREQ      
#define PULSEFILTERKP 120.0 
#define PULSEFILTERKI 1900.0*ENCODERINTPERIOD 
extern "C" void TIMER1_COMPA_vect(void) __attribute__ ((signal,used));
 
void interrupt0(void);
 
void interrupt1(void);
 
 
class uStepperS
{
 
friend class uStepperDriver;
friend class uStepperEncoder;
friend void interrupt0(void);
friend void TIMER1_COMPA_vect(void) __attribute__ ((signal,used));
public:         
 
    uStepperDriver driver;
    
    uStepperEncoder encoder;
 
    uStepperS();
 
    uStepperS(float acceleration, float velocity);
 
    void init( void );
 
    void setup( uint8_t mode = NORMAL,
                uint16_t stepsPerRevolution = 200, 
                float pTerm = 10.0, 
                float iTerm = 0.0, 
                float dTerm = 0.0,
                uint16_t dropinStepSize = 16,
                bool setHome = true,
                uint8_t invert = 0,
                uint8_t runCurrent = 50,
                uint8_t holdCurrent = 30);  
 
    void setRPM( float rpm );
 
    void setMaxAcceleration ( float acceleration );
 
    void setMaxDeceleration ( float deceleration );
 
    void setMaxVelocity ( float velocity );
 
    void setCurrent( double current );
 
    void setHoldCurrent( double current );
 
    void moveSteps( int32_t steps );
 
    void moveAngle( float angle );
 
    void moveToAngle( float angle );
 
    void runContinous( bool dir );
 
    float angleMoved( void );
 
    bool getMotorState(uint8_t statusType = POSITION_REACHED);
 
    void stop( bool mode = HARD );
 
    void enableStallguard( int8_t threshold = 4, bool stopOnStall = false);
 
    void disableStallguard( void );
 
    void clearStall( void );
 
    bool isStalled(void);
 
 
    bool isStalled( int8_t threshold );
 
    void setBrakeMode( uint8_t mode, float brakeCurrent = 25.0 );
 
    void enablePid(void);
 
    void disablePid(void);
 
    void enableClosedLoop(void);
 
    void disableClosedLoop(void);
 
    void setControlThreshold(float threshold);
 
    float moveToEnd(bool dir, float rpm = 40.0, int8_t threshold = 4);
 
    float getPidError(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();
 
    void checkOrientation(float distance = 10);
    
private: 
 
    float maxVelocity;                  
 
    float maxAcceleration;
    float maxDeceleration;
    bool invertPidDropinDirection;
    float rpmToVelocity;
    float angleToStep;
 
    uint16_t microSteps;
    uint16_t fullSteps;
    uint16_t dropinStepSize;
 
    int32_t stepCnt;
 
    float stepsPerSecondToRPM;
    float RPMToStepsPerSecond;
 
    volatile posFilter_t externalStepInputFilter;
 
    float currentPidSpeed;
    volatile uint8_t mode;  
    float pTerm;    
    float iTerm;        
 
    float dTerm;
    bool brake;
    volatile bool pidDisabled;
    volatile float controlThreshold = 10;
    volatile bool stall;
    // SPI functions
 
    volatile int32_t pidPositionStepsIssued = 0;
    volatile float currentPidError;
 
    int8_t stallThreshold = 4;
 
    bool stallStop = false; 
 
    bool stallEnabled = false;
 
    uint8_t SPI( uint8_t data );
 
    void setSPIMode( uint8_t mode );
 
    void chipSelect( uint8_t pin , bool state );
 
    void filterSpeedPos(posFilter_t *filter, int32_t steps);
 
    float pid(float error);
    
    dropinCliSettings_t dropinSettings;
    bool loadDropinSettings(void);
    void saveDropinSettings(void);
    uint8_t dropinSettingsCalcChecksum(dropinCliSettings_t *settings);
};
 
 
 
#endif