LEDController.h

Go to the documentation of this file.

/*
   Copyright 2019 Leon Kiefer
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
       http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/
#pragma once
 
#include <FastLED.h>
 
#include "Arduino.h"
#include "CLPUtils.h"
#include "ILEDController.h"
 
#define CHANNEL_NUM 2
#define GROUPS_NUM 6
 
enum class ChannelMode : byte {
    Disabled = 0x00,
    HardwarePlayback = 0x01,
    SoftwarePlayback = 0x02
};
 
bool inline isValidChannelMode(const ChannelMode channelMode) {
    return channelMode == ChannelMode::Disabled || channelMode == ChannelMode::HardwarePlayback ||
           channelMode == ChannelMode::SoftwarePlayback;
}
 
enum class PortType : byte {
    WS2812B = 0x01,
    UCS1903 = 0x02
};
 
bool inline isValidPortType(const PortType portType) {
    return portType == PortType::WS2812B || portType == PortType::UCS1903;
}
 
// LED group mode
#define GROUP_MODE_Rainbow_Wave 0x00
#define GROUP_MODE_Color_Shift 0x01
#define GROUP_MODE_Color_Pulse 0x02
#define GROUP_MODE_Color_Wave 0x03
#define GROUP_MODE_Static 0x04
#define GROUP_MODE_Temperature 0x05
#define GROUP_MODE_Visor 0x06
#define GROUP_MODE_Marquee 0x07
#define GROUP_MODE_Blink 0x08
#define GROUP_MODE_Sequential 0x09
#define GROUP_MODE_Rainbow 0x0A
 
enum class GroupSpeed : byte { High = 0x00, Medium = 0x01, Low = 0x02 };
 
bool inline isValidGroupSpeed(const GroupSpeed groupSpeed) {
    return groupSpeed == GroupSpeed::High || groupSpeed == GroupSpeed::Medium || groupSpeed == GroupSpeed::Low;
}
 
enum class GroupDirection : byte { Backward = 0x00, Forward = 0x01 };
 
bool inline isValidGroupDirection(const GroupDirection groupDirection) {
    return groupDirection == GroupDirection::Backward || groupDirection == GroupDirection::Forward;
}
 
enum class GroupExtra : byte { Alternating = 0x00, Random = 0x01 };
 
bool inline isValidGroupExtra(const GroupExtra groupExtra) {
    return groupExtra == GroupExtra::Alternating || groupExtra == GroupExtra::Random;
}
 
#define GROUP_TEMP_GROUP_EXTERNAL 255
 
struct LEDGroup {
    uint8_t ledIndex = 0;
    uint8_t ledCount = 0;
    byte mode = GROUP_MODE_Rainbow_Wave;
    GroupSpeed speed = GroupSpeed::High;
    GroupDirection direction = GroupDirection::Forward;
    GroupExtra extra = GroupExtra::Alternating;
    byte tempGroup = GROUP_TEMP_GROUP_EXTERNAL;
 
    CRGB color1;
    CRGB color2;
    CRGB color3;
 
    uint16_t temp1;
    uint16_t temp2;
    uint16_t temp3;
};
 
struct LEDChannel {
    uint8_t brightness = 255;
    ChannelMode mode = ChannelMode::HardwarePlayback;
    uint8_t ledCount = 0;
    PortType ledPortType = PortType::WS2812B;
 
    LEDGroup groups[GROUPS_NUM];
    uint8_t groupsSet = 0;
};
 
class LEDController : public ILEDController {
public:
    virtual void handleLEDControl(const Command& command, const CorsairLightingProtocolResponse* response) override;
    virtual bool isValidLEDChannel(const LEDChannel& ledChannel);
    virtual bool isValidLEDGroup(const LEDGroup& ledGroup);
    const LEDChannel& getChannel(uint8_t channelIndex);
    virtual void reset();
 
protected:
    LEDChannel channels[CHANNEL_NUM];
    bool triggerSave = false;
    unsigned long lastCommand = 0;
 
    virtual void triggerLEDUpdate() = 0;
    virtual uint8_t getLEDStripMask(uint8_t channel, uint8_t group);
    virtual void setLEDExternalTemperature(uint8_t channel, uint16_t temp) = 0;
    virtual bool setLEDGroup(uint8_t channel, uint8_t groupIndex, LEDGroup& group);
    virtual void setLEDColorValues(uint8_t channel, uint8_t color, uint8_t offset, const uint8_t* values,
                                   size_t len) = 0;
    virtual bool setLEDMode(uint8_t channel, ChannelMode mode);
    virtual bool setLEDBrightness(uint8_t channel, uint8_t brightness);
    virtual bool setLEDPortType(uint8_t channel, PortType ledPortType);
    virtual void clearLEDColorValues(uint8_t channel) = 0;
    virtual bool clearLEDGroups(uint8_t channel);
    virtual void startLEDAutodetection(uint8_t channel);
    virtual uint8_t getLEDAutodetectionResult(uint8_t channel) = 0;
    virtual bool save() = 0;
    virtual bool load() = 0;
    bool saveIfNeeded();
};