EVShield.h

Go to the documentation of this file.

/*
 * EVShield interface library
 * Copyright (C) 2016 mindsensors.com
 * 12/18/2014  Nitin Patil --  modified to work with EVshield 
 * Feb 2017  Seth Tenembaum -- modified to work with PiStorms, added touchscreen defines and methods
 *
 * This file is part of EVShield interface library.
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.

 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef EVShield_H
#define EVShield_H

#include "SHDefines.h"

// Motor control related constants.
#define SH_CONTROL_SPEED      0x01
#define SH_CONTROL_RAMP       0x02
#define SH_CONTROL_RELATIVE   0x04
#define SH_CONTROL_TACHO      0x08
#define SH_CONTROL_BRK        0x10
#define SH_CONTROL_ON         0x20
#define SH_CONTROL_TIME       0x40
#define SH_CONTROL_GO         0x80

#define SH_STATUS_SPEED       0x01
#define SH_STATUS_RAMP        0x02
#define SH_STATUS_MOVING      0x04
#define SH_STATUS_TACHO       0x08
#define SH_STATUS_BREAK       0x10
#define SH_STATUS_OVERLOAD    0x20
#define SH_STATUS_TIME        0x40
#define SH_STATUS_STALL       0x80

#define SH_COMMAND     0x41
#define SH_VOLTAGE     0x6E

#define SH_SETPT_M1     0x42
#define SH_SPEED_M1     0x46
#define SH_TIME_M1      0x47
#define SH_CMD_B_M1     0x48
#define SH_CMD_A_M1     0x49

#define SH_SETPT_M2     0x4A
#define SH_SPEED_M2     0x4E
#define SH_TIME_M2      0x4F
#define SH_CMD_B_M2     0x50
#define SH_CMD_A_M2     0x51

/*
 * Read registers.
 */
#define SH_POSITION_M1  0x52
#define SH_POSITION_M2  0x56
#define SH_STATUS_M1    0x5A
#define SH_STATUS_M2    0x5B
#define SH_TASKS_M1     0x5C
#define SH_TASKS_M2     0x5D

#define SH_ENCODER_PID  0x5E
#define SH_SPEED_PID  0x64
#define SH_PASS_COUNT  0x6A
#define SH_TOLERANCE  0x6B

#define SH_S1_MODE  0x6F
#define SH_S1_EV3_MODE  0x6F
#define SH_S1_ANALOG   0x70

#define SH_S2_MODE  0xA3
#define SH_S2_EV3_MODE  0x6F
#define SH_S2_ANALOG   0xA4

#define SH_BTN_PRESS     0xDA
#define SH_RGB_LED     0xD7
#define SH_CENTER_RGB_LED     0xDE

#define SH_PS_TS_X  0xE3
#define SH_PS_TS_Y  0xE5
#define SH_PS_TS_RAWX  0xE7
#define SH_PS_TS_RAWY  0xE9
#define SH_PS_TS_CALIBRATION_DATA_READY 0x70
#define SH_PS_TS_CALIBRATION_DATA 0x71
#define SH_PS_TS_SAVE 0x77
#define SH_PS_TS_LOAD 0x6C
#define SH_PS_TS_UNLOCK 0x45

/* constants to be used by user programs */
typedef enum {
  SH_Motor_1     = 0x01,   
  SH_Motor_2     = 0x02,   
  SH_Motor_Both  = 0x03    
} SH_Motor;

/*
 * \enum SH_Next_Action Next action related constants
 */
typedef enum {
  SH_Next_Action_Float  = 0x00, 
  SH_Next_Action_Brake = 0x01, 
  SH_Next_Action_BrakeHold = 0x02 
} SH_Next_Action;

typedef enum {
  SH_Direction_Reverse = 0x00,   
  SH_Direction_Forward = 0x01   
} SH_Direction;

/*
 * \enum SH_Move Tachometer movement related constants
 */
typedef enum {
  SH_Move_Absolute = 0x00,   
  SH_Move_Relative = 0x01   
} SH_Move;

/*
 * \enum SH_Completion_Wait Whether to wait for motor to finish it's current task or not
 */
typedef enum {
  SH_Completion_Dont_Wait    = 0x00,  
  SH_Completion_Wait_For     = 0x01  
} SH_Completion_Wait;

/*
 * Speed constants, these are just convenience constants,
 * You can use any value between 0 and 100.
 */
#define SH_Speed_Full 90
#define SH_Speed_Medium 60
#define SH_Speed_Slow 25

/*
 * EVShield has two banks, and each of them has different I2C address.
 * each bank has 2 motors and 2 sensors.
 *
 */
#define SH_Bank_A 0x34

#define SH_Bank_B 0x36


/*
 *  Sensor type primitives
 *
 */

#define SH_Type_NONE   0x00

#define SH_Type_SWITCH    0x01
 
#define SH_Type_ANALOG   0x02


#define SH_Type_LIGHT_REFLECTED      0x03

#define SH_Type_LIGHT_AMBIENT      0x04

#define SH_Type_I2C                 0x09

#define SH_Type_COLORFULL            13

#define SH_Type_COLORRED             14

#define SH_Type_COLORGREEN           15

#define SH_Type_COLORBLUE            16

#define SH_Type_COLORNONE            17

#define SH_Type_EV3_SWITCH           18

#define SH_Type_EV3                  19



/*
 * Sensor defines.
 */
#define SH_S1   1

#define SH_S2   2

#include "EVShieldI2C.h"
#if defined(__AVR__)
  #include <avr/io.h>
  #include <avr/interrupt.h>
#endif

class EVShieldBank : public EVShieldI2C
{
public:
  EVShieldBank(uint8_t i2c_address = SH_Bank_A);
  
  int  evshieldGetBatteryVoltage();

  int  nxshieldGetBatteryVoltage();

  uint8_t  EVShieldIssueCommand(char command);

  //
  //  Motor Operation APIs.
  //
  bool     motorSetEncoderTarget(SH_Motor which_motor, long target);
  
  long     motorGetEncoderTarget(SH_Motor which_motor);
  
  bool     motorSetSpeed(SH_Motor which_motor, int speed);
  
  int8_t   motorGetSpeed(SH_Motor which_motor);
  
  bool     motorSetTimeToRun(SH_Motor which_motor, int seconds);
  
  uint8_t  motorGetTimeToRun(SH_Motor which_motor);
  
  bool     motorSetCommandRegB(SH_Motor which_motor, uint8_t value);
  uint8_t  motorGetCommandRegB(SH_Motor which_motor);
  bool     motorSetCommandRegA(SH_Motor which_motor, uint8_t value);
  uint8_t  motorGetCommandRegA(SH_Motor which_motor);
  
  int32_t  motorGetEncoderPosition(SH_Motor which_motor);
  
  uint8_t  motorGetStatusByte(SH_Motor which_motor);
  
  uint8_t  motorGetTasksRunningByte(SH_Motor which_motor);
  
  bool     motorSetEncoderPID(uint16_t Kp, uint16_t Ki, uint16_t Kd);
  
  bool     motorSetSpeedPID(uint16_t Kp, uint16_t Ki, uint16_t Kd);
  
  bool centerLedSetRGB(uint8_t R, uint8_t G, uint8_t B);

  // Set the RGBLED that shows RGB color

  bool    ledSetRGB(uint8_t R, uint8_t G, uint8_t B);
  
  bool     motorSetPassCount(uint8_t pass_count);
  
  bool     motorSetTolerance(uint8_t tolerance);
  
  bool     motorReset();
  
  bool     motorStartBothInSync();
  
  bool     motorResetEncoder(SH_Motor which_motor);
  
  bool     motorSetSpeedTimeAndControl(SH_Motor which_motors, int speed,
                                      uint8_t duration, uint8_t control);

  bool     motorSetEncoderSpeedTimeAndControl(SH_Motor which_motors,
                                      long encoder, int speed,
                                      uint8_t duration, uint8_t control);
  
  uint8_t     motorIsTimeDone(SH_Motor which_motors);
  
  uint8_t     motorWaitUntilTimeDone(SH_Motor which_motors);
  
  uint8_t     motorIsTachoDone(SH_Motor which_motors);
  
  uint8_t     motorWaitUntilTachoDone(SH_Motor which_motors);
  
  void     motorRunUnlimited(SH_Motor which_motors, SH_Direction direction,
                                      int speed);
                                      
  uint8_t     motorRunSeconds(SH_Motor which_motors, SH_Direction direction,
                                      int speed, uint8_t duration,
                                      SH_Completion_Wait wait_for_completion,
                                      SH_Next_Action next_action);
                                      
  uint8_t     motorRunTachometer(SH_Motor which_motors, SH_Direction direction,
                                      int speed, long tachometer,
                                      SH_Move relative,
                                      SH_Completion_Wait wait_for_completion,
                                      SH_Next_Action next_action);
                                      
  uint8_t     motorRunDegrees(SH_Motor which_motors, SH_Direction direction,
                                      int  speed, long degrees,
                                      SH_Completion_Wait wait_for_completion,
                                      SH_Next_Action next_action);
                                      
  uint8_t     motorRunRotations(SH_Motor which_motors, SH_Direction direction,
                                      int speed, long rotations,
                                      SH_Completion_Wait wait_for_completion,
                                      SH_Next_Action next_action);
                                      
  bool     motorStop(SH_Motor which_motors, SH_Next_Action next_action);


  //
  // EVShield sensor functions.
  //
public:
  bool     sensorSetType(uint8_t which_sensor, uint8_t sensor_type);
  
  int      sensorReadRaw(uint8_t which_sensor);

};

class EVShieldBankB : public EVShieldBank
{
private:

public:
  EVShieldBankB(uint8_t i2c_address_b = SH_Bank_B);
  int      sensorReadRaw(uint8_t which_sensor);

  bool     sensorSetType(uint8_t which_sensor, uint8_t sensor_type);
};


class EVShield
{
public:
  uint8_t m_protocol;
  EVShieldBank   bank_a;
  EVShieldBankB  bank_b;

  EVShield(uint8_t i2c_address_a = SH_Bank_A,
           uint8_t i2c_address_b = SH_Bank_B);
  
  void init(SH_Protocols protocol=SH_HardwareI2C);

        void initLEDTimers();

        void I2CTimer();
    
        void initProtocols(SH_Protocols protocol=SH_HardwareI2C);

  
  bool getButtonState(uint8_t btn);
  
  void waitForButtonPress(uint8_t btn, uint8_t led_pattern=1);
  

  void ledSetRGB(uint8_t red = 0, uint8_t green = 0, uint8_t blue = 0);

  void ledBreathingPattern();

  void ledHeartBeatPattern();
  
  void getTouchscreenValues(uint16_t *x, uint16_t *y);
  
  uint16_t TS_X();
  
  uint16_t TS_Y();
  
  bool isTouched();
  
  bool checkButton(uint16_t x, uint16_t y, uint16_t width, uint16_t height);
  
  uint8_t getFunctionButton();

private:
  uint16_t x1, y1, x2, y2, x3, y3, x4, y4;
  
  uint16_t RAW_X();
  
  uint16_t RAW_Y();
  
  bool useOldTouchscreen = false;
  
  void getReading(uint16_t *x, uint16_t *y);
};

extern bool format_bin(uint8_t i, char *s);

#endif