egoShieldTimeLapse.h

Go to the documentation of this file.

/********************************************************************************************
*       File:       egoShieldTimeLapse.h                                                    *
*       Version:    1.1.0                                                                   *
*       Date:       March 17th, 2018                                                        *
*       Author:     Mogens Groth Nicolaisen                                                 *
*                                                                                           *   
*********************************************************************************************
* (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 egoShield_h
#define egoShield_h

#include "uStepper.h"
#include "U8g2lib.h"
#include "SPI.h"
#include "Arduino.h"
#include "SoftwareSerial.h"

#define FWBT A3

#define PLBT A1

#define RECBT A2

#define BWBT A0

#define CNT 50

#define OPTO 3

#define FULL 1                          

#define HALF 2                          

#define QUARTER 4                       

#define EIGHT 8                         

#define SIXTEEN 16          

#define en_width 11
#define en_height 9
static unsigned char fw_bits[] = {
   0x41, 0x00, 0xc3, 0x00, 0xc7, 0x01, 0xcf, 0x03, 0xdf, 0x07, 0xcf, 0x03,
   0xc7, 0x01, 0xc3, 0x00, 0x41, 0x00 };
static unsigned char bw_bits[] = {
   0x10, 0x04, 0x18, 0x06, 0x1c, 0x07, 0x9e, 0x07, 0xdf, 0x07, 0x9e, 0x07,
   0x1c, 0x07, 0x18, 0x06, 0x10, 0x04 };
#define tt_width 10
#define tt_height 10
static unsigned char rec_bits[] = {
   0xfc, 0x00, 0xfe, 0x01, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03,
   0xff, 0x03, 0xff, 0x03, 0xfe, 0x01, 0xfc, 0x00 };
static unsigned char stop_bits[] = {
   0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03,
   0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03 };
static unsigned char pse_bits[] = {
   0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00,
   0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00 };
#define play_width 6
#define play_height 11
static unsigned char play_bits[] = {
   0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01 };
#define loop_width 11
#define loop_height 10
static unsigned char loop_bits[] = {
   0x04, 0x00, 0x08, 0x00, 0x9e, 0x03, 0x09, 0x04, 0x05, 0x04, 0x01, 0x05,
   0x81, 0x04, 0xce, 0x03, 0x80, 0x00, 0x00, 0x01 };
#define logo_width 90
#define logo_height 16
static unsigned char logo_bits[] = {
   0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x80, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0xc0, 0xff, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0xc0, 0xc7, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x3e, 0xcf, 0x07, 0xfc, 0xe3, 0xc3, 0x7b, 0x78, 0x0f, 0x3e, 0x9c, 0x01,
   0xdf, 0xcf, 0x3f, 0xfe, 0xf3, 0xf7, 0xff, 0xfe, 0x1f, 0x7f, 0xff, 0x03,
   0x3e, 0xcf, 0xff, 0x78, 0x38, 0xc7, 0xf3, 0x78, 0x9e, 0x73, 0xfe, 0x03,
   0x3c, 0x8f, 0xff, 0x79, 0xfc, 0xcf, 0xf3, 0x79, 0xde, 0xff, 0xbc, 0x01,
   0x1c, 0x47, 0xfe, 0x78, 0xfc, 0xcf, 0xf3, 0x78, 0xbe, 0x7f, 0x1e, 0x00,
   0x3c, 0xef, 0xf0, 0x79, 0x38, 0xc0, 0xf3, 0x79, 0xde, 0x03, 0x1e, 0x00,
   0xbe, 0xcf, 0xff, 0x78, 0x78, 0xc4, 0xf3, 0x78, 0x9e, 0x47, 0x3e, 0x00,
   0xfc, 0xdf, 0x7f, 0xf8, 0xf3, 0xc7, 0x7f, 0xf8, 0x0f, 0x7f, 0x7e, 0x00,
   0x38, 0x07, 0x3f, 0xf0, 0xe1, 0xc3, 0x3f, 0xf8, 0x07, 0x3e, 0x7f, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x03, 0x7c, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x07, 0xfc, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x07, 0xf8, 0x00, 0x00, 0x00, 0x00 };

typedef struct {
    uint8_t debounce,           
    state,                      
    holdCnt,                    
    btn;                        
    uint16_t time;              
} buttons;

#define DEPRESSED 0             
#define PRESSED 1               
#define HOLD 2                  
#define HOLDTIME 75             
#define HOLDTICK 5              
#define RESETWDT asm volatile("WDR \n\t")

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

class egoShield
{
public:
    egoShield(void);
    void egoShield::setup(uint16_t acc = 1500, 
                          uint16_t vel = 1000, 
                          uint8_t uStep = SIXTEEN, 
                          uint16_t fTol = 10,
                          uint16_t fHys = 5, 
                          float P = 1.0, 
                          float I = 0.02, 
                          float D = 0.006,
                          float res = 1,
                          uint16_t shutterDelay = 250);
    void loop(void);
    uStepper stepper;
private:
    SoftwareSerial *BTSerial;
    U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI *u8g2;
    uint8_t place;
    uint8_t endmove;
    float pos[CNT];
    bool pidFlag;
    bool record;
    bool loopMode;
    bool longPushFlag[4];
    char state;
    uint8_t rec;
    uint8_t play;
    uint8_t fw;
    uint8_t bw;
    float setPoint;
    uint16_t acceleration;
    uint16_t velocity;
    uint8_t microStepping; 
    uint16_t faultTolerance;
    uint16_t faultHysteresis; 
    float pTerm; 
    float iTerm; 
    float dTerm;
    float stepSize;
    uint16_t interval;
    float resolution;
    bool brakeFlag;
    /* Declaration of structs for each button*/
    volatile buttons    forwardBtn    = {0x1F, DEPRESSED, 0, 0, 0},
                        playBtn       = {0x1F, DEPRESSED, 0, 0, 0},
                        recordBtn     = {0x1F, DEPRESSED, 0, 0, 0},
                        backwardsBtn  = {0x1F, DEPRESSED, 0, 0, 0};
    uint16_t shutterDelay;

    void resetButton(buttons *btn);
    void resetAllButton();
    void inputs(void);
    uint8_t buttonState(uint8_t button, uint8_t nmbr);
    void idleMode(void);
    void playMode(void);
    void pauseMode(void);
    void timeMode(void);
    void manForward(void);
    void manBackward(void);
    void startPage(void);
    void idlePage(bool pidMode, float pos);
    void recordPage(bool pidMode, bool recorded, uint8_t index, float pos);
    void playPage(bool loopMode, bool pidMode, uint8_t index, bool mode);
    void pausePage(bool loopMode, bool pidMode, uint8_t index);
    void timePage(uint8_t step, bool pidMode);
    void changeVelocity(void);
    void debounce(buttons *btn, uint8_t sample);
    friend void WDT_vect(void) __attribute__ ((signal,used));
};
#endif