eFlexPwmSubmodule.h

/*
   Copyright (c) 2023, epsilonrt
   All rights reserved.
 
   SPDX-License-Identifier: BSD-3-Clause
*/
#pragma once
 
#include "eFlexPwmPin.h"
#include "eFlexPwmConfig.h"
#include "eFlexPwmTimer.h"
 
namespace eFlex {
 
  class SubModule {
    public:
      SubModule (int pinChanA, int pinChanB = -1);
 
      bool isValid() const;
 
      bool configure (const Config &config);
 
      inline const Config &config() const {
        return m_config;
      }
 
      bool begin (bool doStart = true, bool doSync = true);
 
      void enable (bool value = true);
 
      inline void disable () {
        enable (false);
      }
 
      bool isEnabled() const;
 
      inline void start (bool value = true) {
        timer().start (1 << index(), value);
      }
 
 
      inline void stop () {
        start (false);
      }
 
      inline void setPwmLdok (bool value = true) {
 
        timer().setPwmLdok (1 << index(), value);
      }
 
      inline Timer &timer() {
        return *TM[m_tmidx];
      }
 
      inline uint8_t index() const {
        return m_smidx;
      }
 
      bool setPwmFrequency (uint32_t freq, bool doSync = true, bool adjustPrescaler = false);
 
      inline uint32_t pwmFrequency() const {
        return config().pwmFreqHz();
      }
 
      // TODO: Test setPwmMode()
      inline bool setPwmMode (pwm_mode_t  mode, bool doSync = true) {
        m_config.setMode (mode);
        return updateSetting (doSync);
      }
 
      inline pwm_mode_t pwmMode() const {
        return config().mode();
      }
 
      inline void setupOutputEnable (Channel channel, bool activate = true) {
 
        m_signal[channel].pwmchannelenable = activate;
      }
 
      inline void setupOutputEnable (bool activate = true) {
        for (uint8_t i = ChanA; i <= ChanB ; i++) {
          setupOutputEnable (static_cast<Channel> (i), activate);
        }
      }
 
      bool outputEnableSetting (Channel channel) {
 
        return m_signal[channel].pwmchannelenable;
      }
 
      inline void setupDutyCyclePercent (Channel channel, uint8_t dutyCyclePercent) {
        m_signal[channel].dutyCyclePercent = dutyCyclePercent;
      }
 
      inline void setupDutyCyclePercent (uint8_t dutyCyclePercent) {
        for (uint8_t i = ChanA; i <= ChanB ; i++) {
          setupDutyCyclePercent (static_cast<Channel> (i), dutyCyclePercent);
        }
      }
 
      uint8_t dutyCyclePercentSetting (Channel channel) {
        return m_signal[channel].dutyCyclePercent;
      }
 
      inline void setupLevel (Channel channel, pwm_level_select_t level) {
        m_signal[channel].level = level;
      }
 
      inline void setupLevel (pwm_level_select_t level) {
        for (uint8_t i = ChanA; i <= ChanB ; i++) {
          setupLevel (static_cast<Channel> (i), level);
        }
      }
 
      pwm_level_select_t levelSetting (Channel channel) {
        return m_signal[channel].level;
      }
 
      inline void setupDeadtime (Channel channel, uint16_t deadtimeValue, uint32_t unit = 1) {
        if (unit == 1) {
          m_signal[channel].deadtimeValue = deadtimeValue;
        }
        else {
          m_signal[channel].deadtimeValue = ( (uint64_t) timer().srcClockHz() * deadtimeValue) / unit;
        }
      }
 
      inline void setupDeadtime (uint16_t deadtimeValue, uint32_t unit = 1) {
        for (uint8_t i = ChanA; i <= ChanB ; i++) {
          setupDeadtime (static_cast<Channel> (i), deadtimeValue, unit);
        }
      }
 
      uint16_t deadtimeSetting (Channel channel) {
        return m_signal[channel].deadtimeValue;
      }
 
      inline void setupFaultState (Channel channel, pwm_fault_state_t faultState) {
        m_signal[channel].faultState = faultState;
      }
 
      inline void setupFaultState (pwm_fault_state_t faultState) {
        for (uint8_t i = ChanA; i <= ChanB ; i++) {
          setupFaultState (static_cast<Channel> (i), faultState);
        }
      }
 
      inline pwm_fault_state_t faultStateSetting (Channel channel) {
        return m_signal[channel].faultState;
      }
 
      bool updateSetting (bool doSync = true);
 
      inline void setInitValue (uint16_t value) {
        m_ptr->SM[m_smidx].INIT = value;
      }
 
      inline void setVal0Value (uint16_t value) {
        m_ptr->SM[m_smidx].VAL0 = value;
      }
 
      inline void setVal1Value (uint16_t value) {
        m_ptr->SM[m_smidx].VAL1 = value;
      }
 
      inline void setVal2Value (uint16_t value) {
        m_ptr->SM[m_smidx].VAL2 = value;
      }
 
      inline void setVal3Value (uint16_t value) {
        m_ptr->SM[m_smidx].VAL3 = value;
      }
 
      inline void setVal4Value (uint16_t value) {
        m_ptr->SM[m_smidx].VAL4 = value;
      }
 
      inline void setVal5Value (uint16_t value) {
        m_ptr->SM[m_smidx].VAL5 = value;
      }
 
      inline uint16_t initValue () {
        return m_ptr->SM[m_smidx].INIT;
      }
 
      inline uint16_t val0Value () {
        return m_ptr->SM[m_smidx].VAL0;
      }
 
      inline uint16_t val1Value () {
        return m_ptr->SM[m_smidx].VAL1;
      }
 
      inline uint16_t val2Value () {
        return m_ptr->SM[m_smidx].VAL2;
      }
 
      inline uint16_t val3Value () {
        return m_ptr->SM[m_smidx].VAL3;
      }
 
      inline uint16_t val4Value () {
        return m_ptr->SM[m_smidx].VAL4;
      }
 
      inline uint16_t val5Value () {
        return m_ptr->SM[m_smidx].VAL5;
      }
 
      void printRegs (Stream &out = Serial);
 
      //-----------------------------------------------------------------------
      //                            NXP SDK WRAPPER
      //-----------------------------------------------------------------------
 
      inline void updateDutyCyclePercent (uint8_t dutyCyclePercent, Channel channel = ChanA) {
 
        m_duty[static_cast<uint8_t> (channel)] = reloadValue(dutyCyclePercent); // [0, 65535]
        m_signal[static_cast<uint8_t> (channel)].dutyCyclePercent = dutyCyclePercent; // [0, 100]
        PWM_UpdatePwmDutycycleHighAccuracy (ptr(), SM[m_smidx], kPwmChan (channel), m_config.m_mode, m_duty[static_cast<uint8_t> (channel)]);
      }
 
      inline void updateDutyCycle (uint16_t dutyCycle, Channel channel = ChanA) {
 
        m_duty[static_cast<uint8_t> (channel)] = dutyCycle; // [0, 65535]
        PWM_UpdatePwmDutycycleHighAccuracy (ptr(), SM[m_smidx], kPwmChan (channel), m_config.m_mode, dutyCycle);
      }
 
      inline bool setupPwmPhaseShift (Channel channel, uint8_t shiftvalue, bool doSync = true) {
 
        return (PWM_SetupPwmPhaseShift (ptr(), SM[m_smidx], kPwmChan (channel), m_config.pwmFreqHz(), timer().srcClockHz(), shiftvalue, doSync) == kStatus_Success);
      }
 
      inline void setupInputCapture (Channel channel, const pwm_input_capture_param_t *inputCaptureParams) {
        PWM_SetupInputCapture (ptr(), SM[m_smidx], kPwmChan (channel), inputCaptureParams);
      }
 
      inline void setupForceSignal (Channel channel, pwm_force_signal_t mode) {
        PWM_SetupForceSignal (ptr(), SM[m_smidx], kPwmChan (channel), mode);
      }
 
      inline uint32_t statusFlags () {
        return PWM_GetStatusFlags (ptr(), SM[m_smidx]);
      }
 
      inline void clearStatusFlags (uint32_t mask) {
        PWM_ClearStatusFlags (ptr(), SM[m_smidx], mask);
      }
 
      inline void enableInterrupts (uint32_t mask) {
        PWM_EnableInterrupts (ptr(), SM[m_smidx], mask);
      }
 
      inline void disableInterrupts (uint32_t mask) {
        PWM_DisableInterrupts (ptr(), SM[m_smidx], mask);
      }
 
      inline uint32_t enabledInterrupts () {
        return PWM_GetEnabledInterrupts (ptr(), SM[m_smidx]);
      }
 
      inline void setDMAWatermarkControl (pwm_watermark_control_t pwm_watermark_control) {
        PWM_DMAFIFOWatermarkControl (ptr(), SM[m_smidx], pwm_watermark_control);
      }
 
      inline void setDMACaptureSourceSelect (pwm_dma_source_select_t pwm_dma_source_select) {
        PWM_DMACaptureSourceSelect (ptr(), SM[m_smidx], pwm_dma_source_select);
      }
 
      inline void enableDMACapture (uint16_t mask, bool activate = true) {
        PWM_EnableDMACapture (ptr(), SM[m_smidx], mask, activate);
      }
 
      inline void enableDMAWrite (bool activate) {
        PWM_EnableDMAWrite (ptr(), SM[m_smidx], activate);
      }
 
      inline void setVALxValue (pwm_value_register_t valueRegister, uint16_t value) {
        PWM_SetVALxValue (ptr(), SM[m_smidx], valueRegister,  value);
      }
 
      inline uint16_t VALxValue (pwm_value_register_t valueRegister) {
        return PWM_GetVALxValue (ptr(), SM[m_smidx], valueRegister);
      }
 
      inline void enableOutputTrigger (pwm_value_register_t valueRegister, bool activate = true) {
        PWM_OutputTriggerEnable (ptr(), SM[m_smidx], valueRegister, activate);
      }
 
      inline void enableOutputTrigger (uint16_t valueRegisterMask) {
        PWM_ActivateOutputTrigger (ptr(), SM[m_smidx], valueRegisterMask);
      }
 
      inline void disableOutputTrigger (uint16_t valueRegisterMask) {
        PWM_DeactivateOutputTrigger (ptr(), SM[m_smidx], valueRegisterMask);
      }
 
      inline void setupSwCtrlOut (Channel channel, bool value) {
        PWM_SetupSwCtrlOut (ptr(), SM[m_smidx], kPwmChan (channel), value);
      }
 
      inline void setPwmFaultState (Channel channel, pwm_fault_state_t faultState) {
        PWM_SetPwmFaultState (ptr(), SM[m_smidx], kPwmChan (channel),  faultState);
      }
 
      inline void setupFaultDisableMap (Channel channel, pwm_fault_channels_t pwm_fault_channels, uint16_t value) {
        PWM_SetupFaultDisableMap (ptr(), SM[m_smidx], kPwmChan (channel),  pwm_fault_channels,  value);
      }
 
      inline void enableOutput (Channel channel) {
        PWM_OutputEnable (ptr(), kPwmChan (channel), SM[m_smidx]);
      }
 
      inline void disableOutput (Channel channel) {
        PWM_OutputDisable (ptr(), kPwmChan (channel), SM[m_smidx]);
      }
 
      inline uint8_t dutyCyclePercent (Channel channel) {
        return PWM_GetPwmChannelState (ptr(), SM[m_smidx], kPwmChan (channel));
      }
 
      inline bool setOutputToIdle (Channel channel, bool idleStatus) {
        return (PWM_SetOutputToIdle (ptr(), kPwmChan (channel), SM[m_smidx], idleStatus) == kStatus_Success);
      }
 
      inline void setPrescaler (pwm_clock_prescale_t prescaler) {
        m_config.setPrescale (prescaler);
        m_fpmin = Timer::prescalerToMinPwmFrequency (prescaler);
        PWM_SetClockMode (ptr(), SM[m_smidx], prescaler);
      }
 
      inline void setClockMode (pwm_clock_prescale_t prescaler) {
        setPrescaler (prescaler);
      }
 
      inline pwm_clock_prescale_t prescaler() const {
        return config().prescale();
      }
 
      inline void setPwmForceOutputToZero (Channel channel, bool forcetozero) {
        PWM_SetPwmForceOutputToZero (ptr(), SM[m_smidx], kPwmChan (channel), forcetozero);
      }
 
      inline void setChannelOutput (Channel channel, pwm_output_state_t outputstate) {
        PWM_SetChannelOutput (ptr(), SM[m_smidx], kPwmChan (channel),  outputstate);
      }
 
      inline uint32_t minPwmFrequency() const {
        return m_fpmin;
      }
 
      bool adjustPrescaler (uint32_t pwmFreq);
 
    protected:
      inline PWM_Type *ptr() {
        return m_ptr;
      }
 
      inline const PWM_Type *ptr() const {
        return m_ptr;
      }
 
      inline pwm_signal_param_t *kPwmSignals() {
        return m_signal;
      }
 
      inline const pwm_signal_param_t *kPwmSignals() const {
        return m_signal;
      }
 
      static inline void setSignalToDefault (pwm_signal_param_t &signal) {
        signal.pwmchannelenable = true;
        signal.level = kPWM_HighTrue;
        signal.dutyCyclePercent = 50;
        signal.deadtimeValue = 0;
        signal.faultState = kPWM_PwmFaultState0;
      }
 
    private:
      Pin m_pin[NofPins];
      uint8_t m_tmidx;
      uint8_t m_smidx;
      PWM_Type *m_ptr;
      pwm_signal_param_t m_signal[NofPins];
      Config m_config;
      bool m_wasbegin;
      uint32_t m_fpmin;
      uint16_t m_duty[NofPins];
  };
 
  extern SubModule *SmList[NofTimers][NofSubmodules];
}