// Set the PWM period, keeping the duty cycle the same.
void pwmout_period_us(pwmout_t *obj, int us)
{
float seconds = 0;
uint32_t cycles = 0;
int ClkDiv = 0;
int i = 0;
float duty_cycle = 0;
uint32_t clk_freq = 0;
seconds = (float)((us) / 1000000.0f);
obj->period = seconds;
if (obj->period > 0.7) {
clk_freq = (CLOCK_FREQUENCY / 2);
} else {
clk_freq = CLOCK_FREQUENCY;
}
// Select highest timer resolution
for (i = 0; i < 7; ++i) {
cycles = (int)((clk_freq / prescale_tbl[i]) * seconds);
if (cycles <= MAX_COUNTER_16B) {
ClkDiv = i + 1; // range 1:6
break;
} else {
cycles = MAX_COUNTER_16B;
ClkDiv = 7;
}
}
// Stops and clear count operation
TMRB_SetRunState(obj->channel, TMRB_STOP);
// Restore the duty-cycle
duty_cycle = (float)((obj->trailing_timing - obj->leading_timing) / obj->trailing_timing);
obj->trailing_timing = cycles;
obj->leading_timing = ((cycles)- (uint16_t)(cycles * duty_cycle));
// Change the source clock division and period
m_tmrb.Mode = TMRB_INTERVAL_TIMER;
m_tmrb.ClkDiv = ClkDiv;
m_tmrb.UpCntCtrl = TMRB_AUTO_CLEAR;
m_tmrb.TrailingTiming = obj->trailing_timing;
m_tmrb.LeadingTiming = obj->leading_timing;
FFStruct.FlipflopCtrl = TMRB_FLIPFLOP_SET;
FFStruct.FlipflopReverseTrg = (TMRB_FLIPFLOP_MATCH_TRAILING | TMRB_FLIPFLOP_MATCH_LEADING);
// Enable channel
TMRB_Enable(obj->channel);
// Disable double buffering
TMRB_SetDoubleBuf(obj->channel, DISABLE, TMRB_WRITE_REG_SEPARATE);
// Init timer function
TMRB_Init(obj->channel, &m_tmrb);
// Enable double buffering
TMRB_SetDoubleBuf(obj->channel, ENABLE, TMRB_WRITE_REG_SEPARATE);
TMRB_SetFlipFlop(obj->channel, &FFStruct);
// Start timer function
TMRB_SetRunState(obj->channel, TMRB_RUN);
}
/**
* @brief TMRB_PPG demo
* @param None
* @retval None
*/
void Example_TimerPpg(void)
{
uint8_t Rate = 0U;
uint32_t Duty[5] = { 0x8CAU, 0x753U, 0x4E2U, 0x271U, 0xFAU }; /* duty: 10%, 25%, 50%, 75%, 90% */
uint8_t keyvalue;
TMRB_InitTypeDef m_tmrb;
TMRB_FFOutputTypeDef PPGFFInital;
GPIO_SetInput(KEYPORT, GPIO_BIT_0); /* set KEY port to input */
/* Set PF1 as TB7OUT for PPG output */
GPIO_SetOutput(GPIO_PF, GPIO_BIT_1);
GPIO_EnableFuncReg(GPIO_PF, GPIO_FUNC_REG_1, GPIO_BIT_1);
GPIO_SetPullUp(GPIO_PF, GPIO_BIT_1, ENABLE);
m_tmrb.Mode = TMRB_INTERVAL_TIMER;
m_tmrb.ClkDiv = TMRB_CLK_DIV_8;
m_tmrb.UpCntCtrl = TMRB_AUTO_CLEAR;
m_tmrb.Cycle = TMRB7TIME; /* T = 250us */
m_tmrb.Duty = Duty[Rate];
PPGFFInital.FlipflopCtrl = TMRB_FLIPFLOP_CLEAR;
PPGFFInital.FlipflopReverseTrg = TMRB_FLIPFLOP_MATCH_CYCLE | TMRB_FLIPFLOP_MATCH_DUTY;
TMRB_Enable(TSB_TB7);
TMRB_Init(TSB_TB7, &m_tmrb);
TMRB_SetFlipFlop(TSB_TB7, &PPGFFInital);
TMRB_SetDoubleBuf(TSB_TB7, ENABLE, TMRB_WRITE_REG_SEPARATE); /* enable double buffer */
TMRB_SetRunState(TSB_TB7, TMRB_RUN);
do { /* wait if key is pressed */
keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);
} while (GPIO_BIT_VALUE_1 == keyvalue);
delay(0xFFFU); /* noise cancel */
while (1) {
do { /* wait if key is released */
keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);
} while (GPIO_BIT_VALUE_0 == keyvalue);
delay(0xFFFU); /* noise cancel */
Rate++;
if (Rate >= DUTYMAX) { /* change duty rate */
Rate = DUTYINIT;
} else {
/* Do nothing */
}
TMRB_ChangeDuty(TSB_TB7, Duty[Rate]); /* change duty rate */
do { /* wait if key is pressed */
keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);
} while (GPIO_BIT_VALUE_1 == keyvalue);
delay(0xFFFU); /* noise cancel */
}
}
/**
* @brief The main function of TMRB_PPG demo
* @param None
* @retval None
*/
void Example_TMRB_PPG(void)
{
uint32_t Duty[5] = { 0x1194U, 0xEA6U, 0x9C4U, 0x4E2U, 0x1F4U }; /* duty: 10%, 25%, 50%, 75%, 90% */
uint8_t keyvalue;
TMRB_InitTypeDef m_tmrb;
TMRB_FFOutputTypeDef PPGFFInital;
/* LCD & switch initialization */
LCD_Configuration();
SW_Init();
/* Set PA5 as TB6OUT for PPG output */
GPIO_SetOutput(GPIO_PA, GPIO_BIT_5);
GPIO_EnableFuncReg(GPIO_PA, GPIO_FUNC_REG_2, GPIO_BIT_5);
m_tmrb.Mode = TMRB_INTERVAL_TIMER;
m_tmrb.ClkDiv = TMRB_CLK_DIV_8;
m_tmrb.UpCntCtrl = TMRB_AUTO_CLEAR;
m_tmrb.Cycle = TMRB6TIME; /* T = 500us */
m_tmrb.Duty = Duty[Rate];
PPGFFInital.FlipflopCtrl = TMRB_FLIPFLOP_CLEAR;
PPGFFInital.FlipflopReverseTrg = TMRB_FLIPFLOP_MATCH_CYCLE | TMRB_FLIPFLOP_MATCH_DUTY;
TMRB_Enable(TSB_TB6);
TMRB_Init(TSB_TB6, &m_tmrb);
TMRB_SetFlipFlop(TSB_TB6, &PPGFFInital);
TMRB_SetDoubleBuf(TSB_TB6, ENABLE, TMRB_WRITE_REG_SEPARATE); /* enable double buffer */
TMRB_SetRunState(TSB_TB6, TMRB_RUN);
do { /* Handle the condition that start with the SW0 is high*/
keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);
duty_display();
} while (GPIO_BIT_VALUE_1 == keyvalue);
delay(0xFFFFU); /* noise cancel */
while (1) {
do {
keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0); /* display when switch is low */
duty_display();
} while (GPIO_BIT_VALUE_0 == keyvalue);
delay(0xFFFFU); /* noise cancel */
Rate++;
if (Rate >= DUTYMAX) { /* change duty rate */
Rate = DUTYINIT;
} else {
/* Do nothing */
}
TMRB_ChangeDuty(TSB_TB6, Duty[Rate]);
do {
keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0); /* display when switch is high */
duty_display();
} while (GPIO_BIT_VALUE_1 == keyvalue);
delay(0xFFFFU); /* noise cancel */
}
}
/*int main(void)*/
void TMRB_PPG(void)
{
uint8_t Rate = 0U;
uint32_t Duty[5] = { 0x384U, 0x2EEU, 0x1F4U, 0xFAU, 0x64U }; /* duty: 10%, 25%, 50%, 75%, 90% */
TMRB_InitTypeDef m_tmrb;
TMRB_FFOutputTypeDef PPGFFInital;
/* Set PG0 as TB0OUT for PPG output */
TSB_PG->CR |= 0x01;
TSB_PG->FR1 |= 0x01;
m_tmrb.Mode = TMRB_INTERVAL_TIMER;
m_tmrb.ClkDiv = TMRB_CLK_DIV_8;
m_tmrb.UpCntCtrl = TMRB_AUTO_CLEAR;
m_tmrb.Cycle = TMRB0TIME; /* T = 1ms */
m_tmrb.Duty = Duty[Rate];
PPGFFInital.FlipflopCtrl = TMRB_FLIPFLOP_CLEAR;
PPGFFInital.FlipflopReverseTrg = TMRB_FLIPFLOP_MATCH_CYCLE | TMRB_FLIPFLOP_MATCH_DUTY;
TMRB_Enable(TSB_TB0);
TMRB_Init(TSB_TB0, &m_tmrb);
TMRB_SetFlipFlop(TSB_TB0, &PPGFFInital);
TMRB_SetDoubleBuf(TSB_TB0, ENABLE); /* enable double buffer */
TMRB_SetRunState(TSB_TB0, TMRB_RUN);
while (1)
{
/* change duty rate */
delay();
if (Rate++ >= DUTYMAX)
{
Rate = DUTYINIT;
}
TMRB_ChangeDuty(TSB_TB0, Duty[Rate]);
}
}
void pwmout_init(pwmout_t *obj, PinName pin)
{
uint16_t counter = 0;
TMRB_FFOutputTypeDef FFStruct;
TMRB_InitTypeDef m_tmrb;
// Determine the pwm channel
PWMName pwm = (PWMName)pinmap_peripheral(pin, PinMap_PWM);
//Assert input is valid
MBED_ASSERT(pwm != (PWMName)NC);
// Enable clock supply to TB0
CG_SetFcPeriphA(CG_FC_PERIPH_TMRB0_3, ENABLE);
CG_SetFcPeriphA(CG_FC_PERIPH_TMRB4_6, ENABLE);
switch (pwm) {
case PWM_0:
obj->channel = TSB_TB0;
break;
case PWM_1:
obj->channel = TSB_TB1;
break;
case PWM_2:
obj->channel = TSB_TB2;
break;
case PWM_3:
obj->channel = TSB_TB3;
break;
case PWM_4:
obj->channel = TSB_TB4;
break;
case PWM_5:
obj->channel = TSB_TB5;
CG_SetFcPeriphA(CG_FC_PERIPH_PORTJ, ENABLE);
break;
case PWM_6:
obj->channel = TSB_TB6;
CG_SetFcPeriphA(CG_FC_PERIPH_PORTJ, ENABLE);
break;
default:
obj->channel = NULL;
return;
}
// Set pin function as PWM
pinmap_pinout(pin, PinMap_PWM);
obj->pin = pin;
obj->period = DEFAULT_PERIOD;
// Enable channel
TMRB_Enable(obj->channel);
// Stops and clear count operation
TMRB_SetRunState(obj->channel, TMRB_STOP);
// Disables double buffering
TMRB_SetDoubleBuf(obj->channel, DISABLE);
// Set default period = 20ms, duty cycle = 0
obj->divisor = DEFAULT_CLOCK_DIVISION;
counter = (uint16_t)((DEFAULT_PERIOD * CLOCK_FREQUENCY) / obj->divisor);
// Init timer variable for using PPG mode
m_tmrb.Mode = TMRB_INTERVAL_TIMER;
m_tmrb.ClkDiv = TMRB_CLK_DIV_32;
m_tmrb.UpCntCtrl = TMRB_AUTO_CLEAR; // clear UC when matching value
m_tmrb.TrailingTiming = counter; // period = 20ms
m_tmrb.LeadingTiming = counter; // duty cycle = 0%
// Init timer function
TMRB_Init(obj->channel, &m_tmrb);
obj->trailing_timing = counter;
obj->leading_timing = counter;
// Enable double buffering
TMRB_SetDoubleBuf(obj->channel, ENABLE);
// Setting to TBxFF0 reverse trigger
FFStruct.FlipflopCtrl = TMRB_FLIPFLOP_CLEAR;
FFStruct.FlipflopReverseTrg = TMRB_FLIPFLOP_MATCH_TRAILINGTIMING | TMRB_FLIPFLOP_MATCH_LEADINGTIMING;
TMRB_SetFlipFlop(obj->channel, &FFStruct);
// Start count operation
TMRB_SetRunState(obj->channel, TMRB_RUN);
}
