Jedi Light Switch

// Responsible for handling temperature and humidity measurements.

 #include "application.h"
 #include "EnvironmentSensors.h"
 
///////////////////////////////////////////////////////////////////////////////////
// Base class
///////////////////////////////////////////////////////////////////////////////////

// Ctor.
EnvironmentSensors::EnvironmentSensors(LedHandler* leds) {
     _leds = leds;
}

bool EnvironmentSensors::init() {
    // Setup I2C as master
    if ( !Wire.isEnabled() ) {
        Wire.setSpeed(CLOCK_SPEED_400KHZ);
        Wire.begin();
    }
    
        // Initialize Temperature and humidity
    if (!_humiditySensor.begin()) {
        Particle.publish("Setup", "Temperature/Humidity sensor setup failed.");
        delay(250);
        RGB.color(255, 0, 00);
        return false;
    }
    
    return true;
}

void EnvironmentSensors::readTemperatureAndHumidity(bool publish) {
    float h = _humiditySensor.readHumidity();
    if (h < 100) {
        _humidity = h;
    } else {
        // Invalid / error.
        RGB.color(255, 0, 0);
    }
    
    float t = _humiditySensor.readTemperature();
    if (t < 100) {
        _temperature = t;
    } else {
        // Invalid / error.
        RGB.color(255, 0, 0);
    }
    
    if (publish) {
        Particle.publish("senml", "{e:[{'n':'Temp','v':'" + String(_temperature) + "'},{'n':'RH','v':'" + String(_humidity) + "'}]}");
    }
}

void EnvironmentSensors::readAnalogLightLevel(bool publish) {
    // No action for V1 hardware.
}

void EnvironmentSensors::appendSenML(SenMLBuilder* builder) {
   // "{e:[{'n':'Temperature','v':'" + String(_temperature) + "'},{'n':'Humidity','v':'" + String(_humidity) + "'}]}"
   builder->add("T", _temperature);
   builder->add("RH", _humidity);
}

uint16_t EnvironmentSensors::getTemperature() {
    return _temperature;    
}

uint16_t EnvironmentSensors::getHumidity() {
    return _humidity;
}

int EnvironmentSensors::getAnalogLightLevel() {
    return _analogLightLevel;
}

///////////////////////////////////////////////////////////////////////////////////
// V1
///////////////////////////////////////////////////////////////////////////////////
// ctor
EnvironmentSensorsV1::EnvironmentSensorsV1(LedHandler* leds) : EnvironmentSensors(leds) {
}


///////////////////////////////////////////////////////////////////////////////////
// V2
///////////////////////////////////////////////////////////////////////////////////
// ctor
EnvironmentSensorsV2::EnvironmentSensorsV2(LedHandler* leds) : EnvironmentSensors(leds) {
}

bool EnvironmentSensorsV2::init() {
    // initialise the base class
    EnvironmentSensors::init();
    pinMode(_analogLightLevelPin, INPUT);
    return true;
}

// Override to read actual analog light level as it's supported on 
// V2 hardware.
void EnvironmentSensorsV2::readAnalogLightLevel(bool publish) {
    _analogLightLevel = analogRead(_analogLightLevelPin);
}

void EnvironmentSensorsV2::appendSenML(SenMLBuilder* builder) {
    EnvironmentSensors::appendSenML(builder);
    builder->add("LightAnalog", _analogLightLevel);
}

// Responsible for handling temperature and humidity measurements.

#ifndef EnvironmentSensors_H
#define EnvironmentSensors_H

#include "HTU21D/HTU21D.h"
#include "LedHandler.h"
#include "SenMLBuilder.h"


///////////////////////////////////////////////////////////////////////////////////
// Base
///////////////////////////////////////////////////////////////////////////////////
class EnvironmentSensors {
public:
    EnvironmentSensors(LedHandler* leds);
    virtual bool init();
    virtual void readTemperatureAndHumidity(bool publish);
    virtual void readAnalogLightLevel(bool publish);
    
    // Append sensor measurements to SenML Builder
    // for publication.
    virtual void appendSenML(SenMLBuilder* builder);
    
    uint16_t getTemperature();
    uint16_t getHumidity();
    int getAnalogLightLevel();
    
protected:
    int _analogLightLevel = 0;

private:
    HTU21D _humiditySensor;
    LedHandler* _leds;
    uint16_t _humidity = 0;
    uint16_t _temperature = 0;
};

///////////////////////////////////////////////////////////////////////////////////
// V1
///////////////////////////////////////////////////////////////////////////////////
class EnvironmentSensorsV1 : public EnvironmentSensors {
public:
    EnvironmentSensorsV1(LedHandler* leds);
};

///////////////////////////////////////////////////////////////////////////////////
// V2
///////////////////////////////////////////////////////////////////////////////////
class EnvironmentSensorsV2 : public EnvironmentSensors {
public:
    EnvironmentSensorsV2(LedHandler* leds);
    bool init() override;
    void readAnalogLightLevel(bool publish) override;
    void appendSenML(SenMLBuilder* builder) override;
private:
    int _analogLightLevelPin = A1;
};

#endif

 #include "application.h"
 #include "GestureSensor.h"

///////////////////////////////////////////////////////////////////////////////////
// Base
///////////////////////////////////////////////////////////////////////////////////
// Ctor.
GestureSensor::GestureSensor(int gestureInterruptPin, LedHandler* leds) {
    _gestureInterruptPin = gestureInterruptPin;
    _leds = leds;
}

/**
 * @brief Destructor
 */
GestureSensor::~GestureSensor() {
}

bool GestureSensor::init() {
    
    // Already has 10k pull-up.
    pinMode(_gestureInterruptPin, INPUT); 
    
    if ( !Wire.isEnabled() ) {
        Wire.setSpeed(CLOCK_SPEED_400KHZ);
        Wire.begin();
    }

    if (!setupLightAndGesture()) {
        Particle.publish("Setup", "Setup Light and Gesture failed. APDS-9960 Error code: " + String(_errorCode));
        return false;
    }
    
     // Now everything is set-up attach the intterupts
    auto interruptHandler = std::bind(&GestureSensor::gestureInterrupt, this);
    attachInterrupt(_gestureInterruptPin, interruptHandler, FALLING);
    
    return true;
}

// Initialise Gesture/Light/Proximity Sensor
bool GestureSensor::setupLightAndGesture() {
    
    // Initialize APDS-9960 (configure I2C and initial values)
    int errorCode = _apds.init();
    if ( _errorCode < 0) {
        Particle.publish("Setup", "Error during APDS-9960 init. APDS-9960 Error code: " + String(errorCode));
        _errorCode = 1;
        RGB.color(255, 0, 00);
        return false;
    }
    
    // Enable light sensing
    if ( !_apds.enableLightSensor(false) ) {
        RGB.color(255, 0, 00);
        _errorCode = 3;
        Particle.publish("Setup", "Error enabling light sensor");
        return false;
    }
    
    // Interrup when light below the low  threshold to say it's dark
    //_apds.setLightIntLowThreshold(_ambientLightLowThreshold);
    // Interrup when light above the high threshold to say it's now light
    //_apds.setLightIntHighThreshold(_ambientLightHighThreshold);
    
    ///
    // Set-up proximity
    // ---
    // Adjust the Proximity sensor gain
    if ( !_apds.setProximityGain(PGAIN_4X) ) { 
        RGB.color(255, 0, 00);
        _errorCode = 4;
        Particle.publish("Setup", "Error  trying to set PGAIN");
        return false;
    } 

    // Start running the APDS-9960 gesture sensor engine
    if (!_apds.enableGestureSensor(true) ) {
        RGB.color(255, 0, 00);
        _errorCode = 8;
        Particle.publish("Setup", "Enable Gesture setup failed.");
        return false;
    }
    
    _apds.clearAmbientLightInt();
    _apds.clearProximityInt();
    
    
    Particle.publish("Setup", "Gesture set-up complete");
    
    return true;
}

void GestureSensor::checkForGesture() {
        // If gesture/proximity/light interrupt flag.
    if (_gestureIsrFlag) {
        //_leds->debugLedOn();
        handleGesture();
    } else if (_apds.isGestureAvailable()) {
        //_leds->debugLedOn();
    }
    
        _apds.clearAmbientLightInt();
    _apds.clearProximityInt();
    
    //processGesture();
    //delay(150);
    //_leds->debugLedOff();
}

void GestureSensor::handleGesture() {
    
    detachInterrupt(_gestureInterruptPin);
    
    // Check the light level as that will cause an interrupt.
    // leave it up to the main loop to determine if light/dard.
    readLightLevel(false);

    // now check for a gesture...
    //readProximity();
    //checkProximity();
    processGesture();
    
    _apds.clearAmbientLightInt();
    _apds.clearProximityInt();
    
    // Pause to allow user to see LEDs
    delay(500);
    _gestureIsrFlag = 0;
    _leds->ledsOff();
    
    auto interruptHandler = std::bind(&GestureSensor::gestureInterrupt, this);
    attachInterrupt(_gestureInterruptPin, interruptHandler, FALLING);
}

void GestureSensor::readLightLevel(bool publish) {
    
    // Read light levels
    readAmbientLight();
    
    // Publish details
    if (publish) {
        publishLightLevel();
    }
}

void GestureSensor::publishLightLevel() {
    Particle.publish("senml", "{e:[{'n':'LightLevel','v':'" + String(_ambientLight) + "'}]}");
}

void GestureSensor::readLightColors(bool publish) {
    
    readRedLight();
    
    readGreenLight();
    
    readBlueLight();

    // Publish details
    if (publish) {
        publishColorLevels();
    }
}

void GestureSensor::publishColorLevels() {
    Particle.publish("senml", "{e:[{'n':'LightLevel','v':'" + String(_ambientLight) + "'},{'n':'Red','v':'" + String(_redLevel) + "'},{'n':'Green','v':'" + String(_greenLevel) + "'},{'n':'Blue','v':'" + String(_blueLevel) + "'},{'n':'Proximity','v':'" + String(_proximity) + "'}]}");    
}

void GestureSensor::readAmbientLight() {
    
    uint16_t value = 0;
    if (_apds.readAmbientLight(value)) {
        _ambientLight = value;
    } else {
        _errorCode = 100;
        RGB.color(255, 0, 0);
        // Particle.publish("Status", "Error reading ambient light");
    }
}

void GestureSensor::readRedLight() {
    uint16_t value = 0;
    if (_apds.readRedLight(value)) {
        _redLevel = value;
    } else {
        _errorCode = 101;
        RGB.color(255, 0, 0);
    }
}

void GestureSensor::readGreenLight() {
    uint16_t value = 0;
    if (_apds.readGreenLight(value)) {
        _greenLevel = value;
    } else {
        _errorCode = 102;
        RGB.color(255, 0, 0);
    }
}

void GestureSensor::readBlueLight() {
    uint16_t value = 0;
    if (_apds.readBlueLight(value)) {
        _blueLevel = value;
    } else {
        _errorCode = 103;
        RGB.color(255, 0, 0);
    }
}

void GestureSensor::readProximity() {
    if ( !_apds.clearProximityInt() ) {
        RGB.color(255, 0, 0);
    }
    
    // Check proximity.
    uint8_t value = 0;
    if ( _apds.readProximity(value) ) {
        _proximity = value;
    } 
}

void GestureSensor::processGesture() {
    if (_apds.isGestureAvailable()) {
        _leds->ledsOff();
        
        int gestureValue = _apds.readGesture();
        //Particle.publish("Status", String(gestureValue));

        switch (gestureValue) {
            case DIR_NONE: // 0
                //Particle.publish("Status", "Swipe None");
                // Skip the delay.
                return;
            case DIR_LEFT: // 1
                _leds->leftLedsOn();
                Particle.publish("Status", "Swipe Left");
                break;
            case DIR_RIGHT: // 2
                _leds->rightLedsOn();
                Particle.publish("Status", "Swipe Right");
                break;
            case DIR_UP: // 3
                _leds->topLedsOn();
                Particle.publish("Status", "Swipe Up");
                break;
            case DIR_DOWN: // 4
                _leds->bottomLedsOn();
                Particle.publish("Status", "Swipe Down");
                break;
            case DIR_NEAR: // 5
                _leds->allLedsOn();
                Particle.publish("Status", "Swipe Near");
                break;
            case DIR_FAR: // 6
                _leds->allLedsOn();
                Particle.publish("Status", "Swipe Far");
                break;
            case DIR_ALL: // 7
                Particle.publish("Status", "Swipe ALL!");
                break;
         // default:
            //Serial.println("NONE");
        }
    } 
}

// Interrupt from gesture sensor.
void GestureSensor::gestureInterrupt() {
    _gestureIsrFlag = true;
}

int GestureSensor::getAmbientLightLevel() {
    return _ambientLight;
}

bool GestureSensor::isDark() {
    // Unknown. Not measured
    if (_ambientLight < 0) {
        return false;
    }
    
    return _ambientLight < _ambientLightLowThreshold;
}

bool GestureSensor::isLight() {
    // Unknown. Not measured
    if (_ambientLight < 0) {
        return false;
    }
    
    return _ambientLight > _ambientLightHighThreshold;
}

void  GestureSensor::appendSenML(SenMLBuilder* builder) {
    // "{e:[{'n':'LightLevel','v':'" + String(_ambientLight) + "'}]}"
    builder->add("Light", _ambientLight);
}

///////////////////////////////////////////////////////////////////////////////////
// V1
///////////////////////////////////////////////////////////////////////////////////
// Constructor for V1 handler which sets up the base class
// with the known IO pins or the V1.1 board.
GestureSensorV1::GestureSensorV1(LedHandler* leds) : GestureSensor(D2, leds) {
}

///////////////////////////////////////////////////////////////////////////////////
// V2
///////////////////////////////////////////////////////////////////////////////////
// Constructor for V2  handler which sets up the base class
// with the known IO pins or the V1.2 board.
GestureSensorV2::GestureSensorV2(LedHandler* leds) : GestureSensor(D2, leds) {
}

// Responsible for handling gasture and gesture sensor light levels.

#ifndef GestureSensor_H
#define GestureSensor_H

#include "LedHandler.h"
#include "SparkFun_APDS9960.h"
#include "SenMLBuilder.h"

///////////////////////////////////////////////////////////////////////////////////
// Base
///////////////////////////////////////////////////////////////////////////////////
class GestureSensor {
public:
    GestureSensor(int gestureInterruptPin, LedHandler* leds);
    ~GestureSensor();
    virtual bool init();
    void checkForGesture();
    void readLightLevel(bool publish);
    int getAmbientLightLevel();
    bool isDark();
    bool isLight();
    
    // Append sensor measurements to SenML Builder
    // for publication.
    virtual void appendSenML(SenMLBuilder* builder);
private:
    bool setupLightAndGesture();
    void handleGesture();
    
    void publishLightLevel();
    void readLightColors(bool publish);
    void publishColorLevels();
    void readAmbientLight();
    void readRedLight();
    void readGreenLight();
    void readBlueLight();
    void readProximity();
    
    void processGesture();
    
    // Light level thresholds
    int _ambientLightLowThreshold = 10;
    int _ambientLightHighThreshold = 15;

    // APDS-9960 variables for light/proximity and gesture sensing.
    SparkFun_APDS9960 _apds = SparkFun_APDS9960();
    
    LedHandler* _leds;
    
    int _errorCode = 0;
    // Set to -1 to indicate the level has not been measured.
    int _ambientLight = -1;
    int _redLevel = -1;
    int _greenLevel = -1;
    int _blueLevel = -1;
    int _proximity = -1;
    
    // Interupt
    void gestureInterrupt();
    int _gestureInterruptPin;
    volatile bool _gestureIsrFlag = false;
};

///////////////////////////////////////////////////////////////////////////////////
// V1
///////////////////////////////////////////////////////////////////////////////////
class GestureSensorV1 : public GestureSensor {
public:
    GestureSensorV1(LedHandler* leds);
};

///////////////////////////////////////////////////////////////////////////////////
// V2
///////////////////////////////////////////////////////////////////////////////////
class GestureSensorV2 : public GestureSensor {
public:
    GestureSensorV2(LedHandler* leds);
};

#endif

#include "application.h"
#include "IrBlaster.h"

///////////////////////////////////////////////////////////////////////////////////
// Base
///////////////////////////////////////////////////////////////////////////////////
// Ctor.
IrBlaster::IrBlaster() {
}


/**
 * @brief Destructor
 */
IrBlaster::~IrBlaster() {
}

/**
 * @brief Base initialiser.
 *
 * @return True if initialized successfully. False otherwise.
 */
bool IrBlaster::init() {
    return true;
}

void IrBlaster::send() {
    // No action by default. Not common to all versions of hardware.
}

///////////////////////////////////////////////////////////////////////////////////
// V1
///////////////////////////////////////////////////////////////////////////////////
// Constructor for V1. No IR LEDs on V1.1 board
// with the known IO pins or the V1.1 board.
IrBlasterV1::IrBlasterV1() : IrBlaster() {
    
}

///////////////////////////////////////////////////////////////////////////////////
// V2
///////////////////////////////////////////////////////////////////////////////////
// Constructor for V2. Two IR LEDs on V2 board
IrBlasterV2::IrBlasterV2() : IrBlaster() {
}

bool IrBlasterV2::init() {
    pinMode(_irLedPin, OUTPUT);
    return true;
}

void IrBlasterV2::send() {
    // No action by default. Not common to all versions of hardware.
    // TODO: Waggle IR LED pin...
}

#ifndef IrBlaster_H
#define IrBlaster_H

///////////////////////////////////////////////////////////////////////////////////
// Base
///////////////////////////////////////////////////////////////////////////////////
// Send IR Pulses (hopefully becoming a remote control....)
class IrBlaster {
public:
    IrBlaster();
    ~IrBlaster();
    
    virtual bool init();
    
    // TODO: Figure out what to do!
    virtual void send();
};

///////////////////////////////////////////////////////////////////////////////////
// V1
///////////////////////////////////////////////////////////////////////////////////
class IrBlasterV1 : public IrBlaster {
public:
    IrBlasterV1();
};

///////////////////////////////////////////////////////////////////////////////////
// V2
///////////////////////////////////////////////////////////////////////////////////
class IrBlasterV2 : public IrBlaster {
public:
    IrBlasterV2();
    bool init() override;
    void send() override;
private:
    int _irLedPin = A0;
};

#endif

// Responsible for handling the interface with the 4 UI LEDs in the corners of the board.

#include "application.h"
#include "LedHandler.h"

///////////////////////////////////////////////////////////////////////////////////
// Base
///////////////////////////////////////////////////////////////////////////////////
// Ctor.
LedHandler::LedHandler(int topLeftLed, int topRightLed, int bottomLeftLed, int bottomRightLed, int debugLed) {
     _topLeftLed = topLeftLed;
     _topRightLed =  topRightLed;
     _bottomLeftLed = bottomLeftLed;
     _bottomRightLed = bottomRightLed;
     _debugLed = debugLed;  
}


/**
 * @brief Destructor
 */
LedHandler::~LedHandler() {
}

/**
 * @brief Configures I2C communications and initializes registers to defaults
 *
 * @return True if initialized successfully. False otherwise.
 */
bool LedHandler::init() {
        // Take control of the Photons LED.
    RGB.control(true);
    RGB.brightness(100);
    RGB.color(0, 0, 0);
    
        // Set output mode for D7 LED.
    pinMode(_debugLed, OUTPUT);
    
    // User facing LEDs
    pinMode(_topLeftLed, OUTPUT);
    pinMode(_topRightLed, OUTPUT);
    pinMode(_bottomLeftLed, OUTPUT);
    pinMode(_bottomRightLed, OUTPUT);
    
    // Set default logic levels for the IO pins.
    // Switch all the user facing LEDs on during setup
    digitalWrite(_topLeftLed, HIGH);
    digitalWrite(_topRightLed, HIGH);
    digitalWrite(_bottomLeftLed, HIGH);
    digitalWrite(_bottomRightLed, HIGH);
    
    return true;
}

void LedHandler::debugLedOn() {
    // NB: This clashes with bottom right
    digitalWrite(_debugLed, HIGH);
}

void LedHandler::debugLedOff() {
    // NB: This clashes with bottom right
    digitalWrite(_debugLed, LOW);
}

void LedHandler::ledOn(int led) {
    switch (led) {
        case 1:
            digitalWrite(_topLeftLed, HIGH);
            break;
        case 2:
            digitalWrite(_topRightLed, HIGH);
            break;
        case 3:
            digitalWrite(_bottomRightLed, HIGH);
            break;
        case 4:
            digitalWrite(_bottomLeftLed, HIGH);
            break;
    }
}

void LedHandler::ledOff(int led) {
    switch (led) {
        case 1:
            digitalWrite(_topLeftLed, LOW);
            break;
        case 2:
            digitalWrite(_topRightLed, LOW);
            break;
        case 3:
            digitalWrite(_bottomRightLed, LOW);
            break;
        case 4:
            digitalWrite(_bottomLeftLed, LOW);
            break;
    }
}

void LedHandler::allLedsOn() {
    digitalWrite(_topLeftLed, HIGH);
    digitalWrite(_topRightLed, HIGH);
    digitalWrite(_bottomLeftLed, HIGH);
    digitalWrite(_bottomRightLed, HIGH);
}

void LedHandler::topLedsOn() {
    digitalWrite(_topLeftLed, HIGH);
    digitalWrite(_topRightLed, HIGH);
}

void LedHandler::bottomLedsOn() {
    digitalWrite(_bottomLeftLed, HIGH);
    digitalWrite(_bottomRightLed, HIGH);
}

void LedHandler::leftLedsOn() {
    digitalWrite(_topLeftLed, HIGH);
    digitalWrite(_bottomLeftLed, HIGH);
}

void LedHandler::rightLedsOn() {
    digitalWrite(_topRightLed, HIGH);
    digitalWrite(_bottomRightLed, HIGH);
}

void LedHandler::ledsOff() {
    digitalWrite(_topLeftLed, LOW);
    digitalWrite(_topRightLed, LOW);
    digitalWrite(_bottomLeftLed, LOW);
    digitalWrite(_bottomRightLed, LOW);
    digitalWrite(_debugLed, LOW);
}

void LedHandler::glow() {
        RGB.brightness(100);
        // Glow colour (Green).
        RGB.color(0, 255, 0);
}

void LedHandler::noglow() {
        RGB.brightness(100);
        RGB.color(0, 0, 0);
}

void LedHandler::rainbowGlow() {
        RGB.brightness(100);
        // TODO: Rainbow the RGB LED...
        RGB.color(0, 255, 255);
}

///////////////////////////////////////////////////////////////////////////////////
// V1
///////////////////////////////////////////////////////////////////////////////////
// Constructor for V1 LED handler which sets up the base class
// with the known IO pins or the V1.1 board.
LedHandlerV1::LedHandlerV1() : LedHandler(A0, D3, A5, D7, D7) {
}

///////////////////////////////////////////////////////////////////////////////////
// V2
///////////////////////////////////////////////////////////////////////////////////
// Constructor for V2 LED handler which sets up the base class
// with the known IO pins or the V1.2 board.
// NB: V2 hardware supports Neopixels
LedHandlerV2::LedHandlerV2() : LedHandler(A2, D3, A5, D7, D7) {
}

bool LedHandlerV2::init() {
    LedHandler::init();
    
    _strip.begin();
     // Initialize all pixels to 'off'
    _strip.show();
    
    return true;
}

 void LedHandlerV2::glow() {
    // V2 hardware, don't use the tri-color lED on the photon as we have NeoPixels!
    // Set to use a dimish green
    uint32_t color = this->_strip.Color(0, 0, 90);
    for(uint16_t i=0; i<_strip.numPixels(); i++) {
      this->_strip.setPixelColor(i, color);
    }
    this->_strip.show();
}

void LedHandlerV2::noglow() {
    uint32_t color = this->_strip.Color(0, 0, 0);
    for(uint16_t i=0; i<_strip.numPixels(); i++) {
      this->_strip.setPixelColor(i, color);
    }
    this->_strip.show();
}

void LedHandlerV2::rainbowGlow() {
    LedHandlerV2::rainbow(20);
}

void LedHandlerV2::rainbow(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256; j++) {
    for(i=0; i<_strip.numPixels(); i++) {
      this->_strip.setPixelColor(i, Wheel((i+j) & 255));
    }
    this->_strip.show();
    delay(wait);
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t LedHandlerV2::Wheel(byte WheelPos) {
  if(WheelPos < 85) {
   return this->_strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  } else if(WheelPos < 170) {
   WheelPos -= 85;
   return this->_strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  } else {
   WheelPos -= 170;
   return this->_strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
}

// Responsible for handling the interface with the 4 UI LEDs in the corners of the board.

 
#ifndef LedHandler_H
#define LedHandler_H

#include "neopixel/neopixel.h"

///////////////////////////////////////////////////////////////////////////////////
// Base
///////////////////////////////////////////////////////////////////////////////////
class LedHandler {
public:
    LedHandler();
    ~LedHandler();
    
    virtual bool init();
    void debugLedOn();
    void debugLedOff();
    void ledOn(int led);
    void ledOff(int led);
    void allLedsOn();
    void topLedsOn();
    void bottomLedsOn();
    void leftLedsOn();
    void rightLedsOn();
    void ledsOff();
    
    virtual void glow();
    virtual void rainbowGlow();
    virtual void noglow();
    
protected:
    LedHandler(int topLeftLed, int topRightLed, int bottomLeftLed, int bottomRightLed, int debugLed);
    

private:
    int _topLeftLed;
    int _topRightLed;
    int _bottomLeftLed;
    int _bottomRightLed;
    int _debugLed;     
};

///////////////////////////////////////////////////////////////////////////////////
// V1
///////////////////////////////////////////////////////////////////////////////////
class LedHandlerV1 : public LedHandler {
public:
    LedHandlerV1();
};

///////////////////////////////////////////////////////////////////////////////////
// V2
///////////////////////////////////////////////////////////////////////////////////
class LedHandlerV2 : public LedHandler {
public:
    LedHandlerV2();
    bool init() override;
    void glow() override;
    void noglow() override;
    void rainbowGlow() override;
private:
    // V2 hardware supports NeoPixels on the back of the PCB
    void rainbow(uint8_t wait);
    uint32_t Wheel(byte WheelPos);
    Adafruit_NeoPixel _strip = Adafruit_NeoPixel(4, A7, WS2812B);
};

#endif

#include "application.h"
#include "PowerManagement.h"

///////////////////////////////////////////////////////////////////////////////////
// Base
///////////////////////////////////////////////////////////////////////////////////
// Ctor.
PowerManagement::PowerManagement() {
}

/**
 * @brief Destructor
 */
PowerManagement::~PowerManagement() {
}

/**
 * @brief Initializes power management
 *
 * @return True if initialized successfully. False otherwise.
 */
bool PowerManagement::init() {
}

void PowerManagement::appendSenML(SenMLBuilder* builder) {
    // No action for base & V1 classes.
}

///////////////////////////////////////////////////////////////////////////////////
// V1
///////////////////////////////////////////////////////////////////////////////////
PowerManagementV1::PowerManagementV1() {
}

void PowerManagementV1::readPowerState(bool publish) {
    // Nothing to implement.
}

///////////////////////////////////////////////////////////////////////////////////
// V2
///////////////////////////////////////////////////////////////////////////////////
PowerManagementV2::PowerManagementV2() {
}

bool PowerManagementV2::init() {
    pinMode(_batteryMonitorAnalogPin, INPUT);
    pinMode(_chargeStatusPin, INPUT);
    
    _batteryMonitor.reset();
    _batteryMonitor.quickStart();
        
    return true;
}

void PowerManagementV2::readPowerState(bool publish) {
    _cellVoltage = _batteryMonitor.getVCell();
    _stateOfCharge = _batteryMonitor.getSoC();
    
    // Battery charger status
    _chargeState = digitalRead(_chargeStatusPin);
    
    // Battery ADC value
    _batteryAdc = analogRead(_batteryMonitorAnalogPin);
    
    // Convert ADC value (0.8mv per ADC, 1/2 voltage divider, millivolrs -> volts)
    _batteryVoltageAnalog = ( (_batteryAdc * 0.8F) * 2.0F / 1000);
    
    if (publish) {
        Particle.publish("senml", "{e:[{'n':'ps-voltage','v':'" + String(_cellVoltage) + "'},{'n':'ps-soc','v':'" + String(_stateOfCharge) + "'},{'n':'charge-status','v':'" + String(_chargeState) + "'},{'n':'battery-adc','v':'" + String(_batteryAdc) + "'} ]}", 60, PRIVATE);
    }
}


void PowerManagementV2::appendSenML(SenMLBuilder* builder) {
    //Particle.publish("senml", "{e:[{'n':'ps-voltage','v':'" + String(_cellVoltage) + "'},{'n':'ps-soc','v':'" + String(_stateOfCharge) + "'},{'n':'charge-status','v':'" + String(_chargeState) + "'},{'n':'battery-adc','v':'" + String(_batteryAdc) + "'} ]}", 60, PRIVATE);
    
    builder->add("ps-volts", _cellVoltage);
    builder->add("ps-soc", _stateOfCharge);
    builder->add("charging", _chargeState);
    builder->add("batt-adc", _batteryAdc);
    builder->add("batt-volts", _batteryVoltageAnalog);
}

#ifndef PowerManagement_H
#define PowerManagement_H

#include "PowerShield/PowerShield.h"
#include "SenMLBuilder.h"

///////////////////////////////////////////////////////////////////////////////////
// Base
///////////////////////////////////////////////////////////////////////////////////
// Responsible for reading the LiPol battery voltage and charge.
class PowerManagement {
public:
    PowerManagement();
    ~PowerManagement();
    
    virtual bool init();
    // Pure virtual - must be overridden
    virtual void readPowerState(bool publish) = 0;
    
    // Append sensor measurements to SenML Builder
    // for publication.
    virtual void appendSenML(SenMLBuilder* builder);

protected:

private:
    
};

///////////////////////////////////////////////////////////////////////////////////
// V1
///////////////////////////////////////////////////////////////////////////////////
// V1.1 board does not support power management
class PowerManagementV1 : public PowerManagement {
public:
    PowerManagementV1();
    void readPowerState(bool publish) override;
};

///////////////////////////////////////////////////////////////////////////////////
// V2
///////////////////////////////////////////////////////////////////////////////////
// V1.2 board has battery/charger and monitor.
class PowerManagementV2 : public PowerManagement {
public:
    PowerManagementV2();
    bool init() override;
    void readPowerState(bool publish) override;
    void appendSenML(SenMLBuilder* builder) override;
private:
    PowerShield _batteryMonitor;
    // Battery is connected to ADC via potential divider on pin...
    int _batteryMonitorAnalogPin = A4;
    int _chargeStatusPin = A3;
    float _cellVoltage;
    float _stateOfCharge;
    int _chargeState;
    // Battery voltage as measured via ADC
    int _batteryAdc;
    float _batteryVoltageAnalog;
};

#endif

#include "application.h"
#include "SenMLBuilder.h"

// Ctor.
SenMLBuilder::SenMLBuilder() {
    // Maximum size of a published message is 255 characters.
    _senml.reserve(255);
}

/**
 * @brief Destructor
 */
SenMLBuilder::~SenMLBuilder() {
}

/**
 * @brief Start a new SenML document.
 *
 */
void SenMLBuilder::begin() {
    // Clear out the old string buffer
    _senml = "{e:[";
    _first = true;
    _terminated = false;
}

void SenMLBuilder::prependComma() {
    // Prepend a comma to anything but the first measurement
    // to seperate the json objects in the senml.e array.
    if (!_first) {
        _senml += ",";
    }
    _first = false;
}

void SenMLBuilder::add(String fieldName, String value) {
    // {'n':'Temperature','v':'22'}
    prependComma();
    _senml += "{'n':'" + fieldName + "','v':'" + value + "'},";
    
}

void SenMLBuilder::add(String fieldName, int value) {
    // {'n':'Temperature','v':'22'}
    prependComma();
    _senml += "{'n':'" + fieldName + "','v':'" + String(value) + "'}";
}

void SenMLBuilder::add(String fieldName, float value) {
    prependComma();
    _senml += "{'n':'" + fieldName + "','v':'" + String(value) + "'}";
}

void SenMLBuilder::add(String fieldName, uint16_t value) {
    prependComma();
    _senml += "{'n':'" + fieldName + "','v':'" + String(value) + "'}";
}

// Complete the document and convert it to a string
// This method may be called repeatedly.
String SenMLBuilder::toString() {
    // Add each or the recorded sensor measurements
    // {'n':'Temperature','v':'" + String(environmentSensors->getTemperature()) + "'}
    //
    if (!_terminated) {
        _senml += "]}";
        _terminated = true;
    }
    
    return _senml;
}

// Publish the senml document
// private. 60s ttl, name="senml"
// This method may be called repeatedly in case of failure.
bool SenMLBuilder::publish() {
    return Particle.publish("senml", toString(), 60, PRIVATE);
}