pwm.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef  _PWM_H_INC
#define  _PWM_H_INC
 
#include <predef.h>
#include <stdio.h>
#include <nbrtos.h>
#include <sim.h>
 
#ifndef __cplusplus
#error PWM driver is a C++ only library
#endif
 
#define DEFAULT_PWM_MODULE 0   
#define PWM_MODULE_COUNT   2   
#define PWM_CHANNEL_COUNT  4
 
#define PWM_CLOCK_DIV_MAX  256
#define PWM_CLOCK_PRE_MAX  11
 
#define __DEBUG_PWM
 
extern volatile uint32_t PERIPH_CLOCK;
 
// 49.5.3 PWM interrupt
 
enum pwmChannelNumber {
    PWM_CHANNEL_0        = 0,    
    PWM_CHANNEL_1        = 1,    
    PWM_CHANNEL_2        = 2,    
    PWM_CHANNEL_3        = 3,    
};
 
enum pwmAlignment {
    PWM_ALIGN_LEFT       = 0,   
    PWM_ALIGN_CENTER     = 1,   
};
 
enum pwmPolarity {
    PWM_LOW_LEVEL        = 0,   
    PWM_HIGH_LEVEL       = 1,   
};
 
typedef struct
{
    uint32_t m_reg_PWM_CMR;
    uint32_t m_frequency;
    uint32_t m_dutyCycle;
    uint32_t m_period;
    uint8_t  m_alignment;
    uint8_t  m_polarity;
    uint32_t m_clockSource; // clock A, clock B, or master clock/peripheral clock
    // counter event
    // deadtime
} pwmChannelStruct;
 
 
class PWMModule
{
public:
 
protected:
    static  PWMModule *lastCtxs[PWM_MODULE_COUNT];
    // static  spiDriverStruct driverCtx[PWM_MODULE_COUNT];
 
    // PWM Module specific
    uint8_t  m_moduleNum;
    uint32_t m_reg_PWM_CLK;       
    // polarity
 
    // Channel Specific
    // static pwmChannelStruct pwmChannels[PWM_CHANNEL_COUNT];
    static pwmChannelStruct pwmChannels[PWM_MODULE_COUNT][PWM_CHANNEL_COUNT];
    // deadtime
 
    /* Additional members pwm_channel_t (Microchip source): */
    // pwm_counter_event_t counter_event;  /** Channel counter event */
    // bool b_deadtime_generator;          /** Boolean of channel dead-time generator */
    // bool b_pwmh_output_inverted;        /** Boolean of channel dead-time PWMH output inverted */
    // bool b_pwml_output_inverted;        /** Boolean of channel dead-time PWML output inverted */
    // uint16_t us_deadtime_pwmh;          /** Dead-time Value for PWMH Output */
    // uint16_t us_deadtime_pwml;          /** Dead-time Value for PWML Output */
    // pwm_output_t output_selection;      /** Channel output */
    // bool b_sync_ch;                     /** Boolean of Synchronous Channel */
    // pwm_fault_id_t fault_id;            /** Fault ID of the channel */
    // pwm_level_t ul_fault_output_pwmh;   /** Channel PWMH output level in fault protection */
    // pwm_level_t ul_fault_output_pwml;   /** Channel PWML output level in fault protection */
 
    // uint32_t ul_spread;                                     /** Spread Spectrum Value */
    // pwm_spread_spectrum_mode_t spread_spectrum_mode;        /** Spread Spectrum Mode */
    // uint32_t ul_leading_edge_delay;                         /** Leading Edge Value */
    // pwm_leading_edge_blanking_mode_t leading_edge_blanking_mode;    /** Leading Edge Mode */
    // uint32_t ul_ppm_mode;                                   /** PPM Mode in Channel mode */
    /* End Additional members pwm_channel_t (Microchip source): */
 
 
 
    // uint32_t    m_regMR;
    // uint32_t    m_regCSR;
    // OS_SEM      *m_finishedSem;
    // uint32_t    m_busSpeed;
    // uint8_t     m_CSNum;
    // volatile bool m_inProgress;
 
    // void ReadyHW();
    // spiDriverStruct *getCtx() { return driverCtx + m_moduleNum; }
    inline Pwm   * pwm() { return PWM0 + m_moduleNum; }
    inline pwmChannelStruct * getChannelStruct(uint8_t channelNum) { return &(pwmChannels[m_moduleNum][channelNum]); }
 
public:
 
#ifdef __DEBUG_PWM
    void dumpRegs();
    void dumpChannelStruct(uint8_t channelNum);
#endif
 
     PWMModule( uint8_t pwmModule = DEFAULT_PWM_MODULE);
 
     uint8_t Init();
     uint32_t ConfigureChannel(uint8_t channelNum, uint32_t frequency,
        uint8_t alignment = PWM_ALIGN_LEFT, uint8_t polarity = PWM_LOW_LEVEL,
        uint32_t period = 100, uint32_t dutyCycle = 50);
     uint8_t EnableChannel(uint8_t channelNum);
     uint8_t DisableChannel(uint8_t channelNum);
     uint32_t SetFrequency(uint8_t channelNum, uint32_t frequency);
     uint32_t GetActualFrequency(uint8_t channelNum);
     bool ChannelIsActive(uint8_t channelNum);
 
// EnableDeadtime(uint8_t channelNum)
// DisableDeadtime(uint8_t channelNum)
// uint8_t GetAvailableChannel() ?
 };
 
 
 #endif   /* ----- #ifndef _PWM_H_INC  ----- */