eFlexPwmTimer.h

/*
   Copyright (c) 2023, epsilonrt
   All rights reserved.
 
   SPDX-License-Identifier: BSD-3-Clause
*/
#pragma once
 
#include "eFlexPwmPin.h"
 
namespace eFlex {
 
  class Timer {
 
    public:
      bool beginSubModules (uint8_t subModulesToBegin, bool doStart = true, bool doSync = true);
 
      inline bool begin (bool doStart = true, bool doSync = true) {
        return beginSubModules (SmMask[m_tmidx], doStart, doSync);
      }
 
      inline uint8_t index() const {
        return m_tmidx;
      }
 
      void enable (bool value = true);
 
      inline void disable () {
        enable (false);
      }
 
      inline bool isEnabled() const {
        return m_isenabled;
      }
 
      inline void start (uint8_t subModulesToStart, bool startit = true) {
        if (startit) {
          PWM_StartTimer (ptr(), subModulesToStart);
        }
        else {
          PWM_StopTimer (ptr(), subModulesToStart);
        }
      }
 
      inline void start (bool startit = true) {
        start (SmMask[m_tmidx], startit);
      }
 
      inline void stop (uint8_t subModulesToStop) {
        start (subModulesToStop, false);
      }
 
      inline void stop () {
        stop (false);
      }
 
      void setupDutyCyclePercent (uint8_t dutyCyclePercent);
 
      void setupLevel (pwm_level_select_t level);
 
      void setupDeadtime (uint16_t deadtimeValue, uint32_t unit = 1);
 
      void setupOutputEnable (bool activate = true);
 
      void setupFaultState (pwm_fault_state_t faultState);
 
 
      bool updateSetting (bool doSync = true);
 
      static inline uint32_t busClockHz()  {
        return F_BUS_ACTUAL;
      }
 
      inline uint32_t srcClockHz() const {
        return busClockHz();
      }
 
      void printRegs (Stream &out = Serial) const;
 
      void printAllRegs (Stream &out = Serial) const;
 
      inline void setPwmLdok (bool value = true) {
        setPwmLdok (SmMask[m_tmidx], value);
      }
 
      //-----------------------------------------------------------------------
      //                            NXP SDK WRAPPER
      //-----------------------------------------------------------------------
 
      inline void setPwmLdok (uint8_t subModulesToUpdate, bool value) {
        PWM_SetPwmLdok (ptr(), subModulesToUpdate, value);
      }
 
      inline void setupFaultInputFilter (const pwm_fault_input_filter_param_t *faultInputFilterParams) {
        PWM_SetupFaultInputFilter (ptr(), faultInputFilterParams);
      }
 
      inline void setupFaults (pwm_fault_input_t faultNum, const pwm_fault_param_t *faultParams) {
        PWM_SetupFaults (ptr(), faultNum, faultParams);
      }
 
      static inline uint32_t prescalerToMinPwmFrequency (unsigned prescaler) {
        return (busClockHz() / (static_cast<uint32_t> (prescaler & 0x7F) * 65535UL) + 1);
      }
 
      static inline uint32_t prescalerToMinPwmFrequency (pwm_clock_prescale_t prescaler) {
        return prescalerToMinPwmFrequency (1U << prescaler);
      }
 
    protected:
      Timer (uint8_t index);
      inline PWM_Type *ptr() {
        return m_ptr;
      }
      inline const PWM_Type *ptr() const {
        return m_ptr;
      }
 
    private:
      uint8_t m_tmidx;
      PWM_Type *m_ptr;
      bool m_isenabled;
  };
  extern Timer *TM[NofTimers];
}