cs_PowerSampling.h

Go to the documentation of this file.

 
#pragma once
 
#include <cfg/cs_Boards.h>
#include <drivers/cs_ADC.h>
#include <events/cs_EventListener.h>
#include <storage/cs_State.h>
#include <structs/buffer/cs_AdcBuffer.h>
#include <structs/buffer/cs_CircularBuffer.h>
#include <third/Median.h>
 
#include <cstdint>
 
typedef void (*ps_zero_crossing_cb_t)();
 
class PowerSampling : EventListener {
public:
    static PowerSampling& getInstance() {
        static PowerSampling instance;
        return instance;
    }
 
    void init(const boards_config_t* boardConfig);
 
    void powerSampleFirstStart();
 
    void startSampling();
 
    void powerSampleAdcDone(adc_buffer_id_t bufIndex);
 
    void sampleCurrentDone(uint8_t type);
 
    void enableZeroCrossingInterrupt(ps_zero_crossing_cb_t callback);
 
    uint32_t getSkippedBufCount();
 
    void handleEvent(event_t& event);
 
    typedef struct {
        adc_sample_value_t* buf;
        uint16_t bufSize;
        uint16_t numChannels;
        uint16_t voltageIndex;
        uint16_t currentIndex;
        uint32_t sampleIntervalUs;
        uint32_t acPeriodUs;
    } power_t;
 
private:
    PowerSampling();
 
    // Number of filtered buffers for processing.
    // Should be at least as large as number of buffers required for recognize switch.
    const static uint8_t numFilteredBuffersForProcessing = 4;
 
    // Currently hard coded at 1.
    const static uint8_t numUnfilteredBuffers            = 1;
 
    // Number of switch states to keep up.
    const static uint8_t switchHistSize                  = 3;
 
    bool _isInitialized                                  = false;
 
    ADC* _adc;
 
    OperationMode _operationMode;
 
    const boards_config_t* _boardConfig = nullptr;
 
    CircularBuffer<adc_buffer_id_t> _bufferQueue;
 
    cs_power_samples_header_t _lastSoftfuse;
    adc_sample_value_t _lastSoftfuseSamples[AdcBuffer::getChannelLength()] = {0};
 
    CircularBuffer<switch_state_t> _switchHist;
    cs_power_samples_header_t _lastSwitchSamplesHeader;
 
    const static uint8_t numSwitchSamplesBuffers = 6;  // 3 voltage and 3 current buffers.
    adc_sample_value_t _lastSwitchSamples[numSwitchSamplesBuffers * AdcBuffer::getChannelLength()] = {0};
 
    TYPIFY(CONFIG_VOLTAGE_MULTIPLIER) _voltageMultiplier;  
    TYPIFY(CONFIG_CURRENT_MULTIPLIER) _currentMultiplier;  
    TYPIFY(CONFIG_VOLTAGE_ADC_ZERO) _voltageZero;          
    TYPIFY(CONFIG_CURRENT_ADC_ZERO) _currentZero;          
    TYPIFY(CONFIG_POWER_ZERO) _powerZero;                  
 
    uint16_t _avgZeroCurrentDiscount;
    uint16_t _avgZeroVoltageDiscount;
    uint16_t _avgPowerDiscount;
 
    // Slow averaging of power
    float _slowAvgPowerDiscount;
    float _slowAvgPowerMilliWatt = 0.0f;
    uint16_t _slowAvgPowerCount;  // Number of values that have been used for slow averaging.
    const uint16_t slowAvgPowerConvergedCount = 1000;
    float _powerDiffThresholdPart;  // When difference is 10% larger or smaller, consider it a significant change.
    float _powerDiffThresholdMinMilliWatt;   // But the difference must also be at least so many Watts.
    float _negativePowerThresholdMilliWatt;  // Only if power is below threshold, it may be negative.
 
    int32_t _boardPowerZero;       
    int32_t _avgZeroVoltage;       
    int32_t _avgZeroCurrent;       
    bool _recalibrateZeroVoltage;  
    bool _recalibrateZeroCurrent;  
 
    uint16_t _zeroVoltageCount;  
    uint16_t _zeroCurrentCount;  
 
    int32_t _avgPowerMilliWatt;       
    int32_t _avgCurrentRmsMilliAmp;   
    int32_t _avgVoltageRmsMilliVolt;  
 
    PowerVector* _inputSamples;   
    PowerVector* _outputSamples;  
    MedianFilter* _filterParams;  
 
    CircularBuffer<int32_t>* _powerMilliWattHist;        
    CircularBuffer<int32_t>* _currentRmsMilliAmpHist;    
    CircularBuffer<int32_t>* _filteredCurrentRmsHistMA;  
    CircularBuffer<int32_t>* _voltageRmsMilliVoltHist;   
    int32_t _histCopy[POWER_SAMPLING_RMS_WINDOW_SIZE];   
    uint16_t _consecutiveDimmerOvercurrent = 0;
    uint16_t _consecutiveOvercurrent       = 0;
 
    TYPIFY(CONFIG_SOFT_FUSE_CURRENT_THRESHOLD) _currentMilliAmpThreshold;  
    TYPIFY(CONFIG_SOFT_FUSE_CURRENT_THRESHOLD_DIMMER)
    _currentMilliAmpThresholdDimmer;  
 
    int64_t _energyUsedmicroJoule = 0;  
 
    switch_state_t _lastSwitchState;                
    uint32_t _lastSwitchOffTicks;                   
    bool _lastSwitchOffTicksValid         = false;  
    bool _dimmerFailureDetectionStarted   = false;  
    uint32_t _calibratePowerZeroCountDown = 4000 / TICK_INTERVAL_MS;
 
    // Store the adc config, so that the actual adc config can be changed.
    struct __attribute__((packed)) {
        adc_channel_config_t config;
 
        // Iterate over the different pins for this channel.
        uint8_t pinIndex = 0;
 
        // Number of pins we can iterate over.
        uint8_t pinCount = 0;
    } _adcConfig[2];
 
    union {
        struct __attribute__((packed)) {
            bool power : 1;
            bool current : 1;
            bool voltage : 1;
            bool filteredCurrent : 1;
        } flags;
        uint32_t asInt;
    } _logsEnabled;
 
    adc_buffer_seq_nr_t _lastBufSeqNr     = 0;
    adc_buffer_id_t _lastBufIndex         = 0;
    adc_buffer_id_t _lastFilteredBufIndex = 0;
 
    cs_adc_restarts_t _adcRestarts;
    cs_adc_channel_swaps_t _adcChannelSwaps;
 
    uint32_t _bufSkipCount = 0;
 
    void initEnergyUsed();
 
    void storeEnergyUsed();
 
    void initAverages();
 
    bool isValidBuf(adc_buffer_id_t bufIndex);
 
    bool isConsecutiveBuf(adc_buffer_seq_nr_t seqNr, adc_buffer_seq_nr_t prevSeqNr);
 
    void removeInvalidBufs();
 
    void calculateVoltageZero(adc_buffer_id_t bufIndex);
 
    void calculateCurrentZero(adc_buffer_id_t bufIndex);
 
    void filter(adc_buffer_id_t bufIndexIn, adc_buffer_id_t bufIndexOut, adc_channel_id_t channel_id);
 
    bool isVoltageAndCurrentSwapped(adc_buffer_id_t bufIndex, adc_buffer_id_t prevBufIndex);
 
    bool calculatePower(adc_buffer_id_t bufIndex);
 
    void calculateSlowAveragePower(float powerMilliWatt, float fastAvgPowerMilliWatt);
 
    void calibratePowerZero(int32_t powerMilliWatt);
 
    void calculateEnergy();
 
    void checkSoftfuse(
            int32_t currentRmsMilliAmp,
            int32_t currentRmsMilliAmpFiltered,
            int32_t voltageRmsMilliVolt,
            adc_buffer_id_t bufIndex);
 
    void handleGetPowerSamples(PowerSamplesType type, uint8_t index, cs_result_t& result);
 
    void selectNextPin(adc_channel_id_t channel);
 
    void enableDifferentialModeCurrent(bool enable);
 
    void enableDifferentialModeVoltage(bool enable);
 
    void changeRange(uint8_t channel, int32_t amount);
 
    void applyAdcConfig(adc_channel_id_t channelIndex);
 
    void enableSwitchcraft(bool enable);
 
    void printBuf(adc_buffer_id_t bufIndex);
};