/**
* @details Initiizes timers for timer based interrupts
*/
void Init_Timers(void) {
// ------------------------------------------------
// Timer 32_0 Init
Chip_TIMER_Init(LPC_TIMER32_0);
Chip_TIMER_Reset(LPC_TIMER32_0);
Chip_TIMER_MatchEnableInt(LPC_TIMER32_0, 0);
Chip_TIMER_SetMatch(LPC_TIMER32_0, 0, Hertz2Ticks(10));
Chip_TIMER_ResetOnMatchEnable(LPC_TIMER32_0, 0);
// Chip_TIMER_Enable(LPC_TIMER32_0);
/* Enable timer interrupt */
NVIC_ClearPendingIRQ(TIMER_32_0_IRQn);
NVIC_EnableIRQ(TIMER_32_0_IRQn);
// ------------------------------------------------
// Timer 32_0 Init
Chip_TIMER_Init(LPC_TIMER32_1);
Chip_TIMER_Reset(LPC_TIMER32_1);
Chip_TIMER_MatchEnableInt(LPC_TIMER32_1, 0);
Chip_TIMER_SetMatch(LPC_TIMER32_1, 0, Hertz2Ticks(BCM_POLL_IDLE_FREQ));
Chip_TIMER_ResetOnMatchEnable(LPC_TIMER32_1, 0);
/* Enable timer_32_1 interrupt */
NVIC_ClearPendingIRQ(TIMER_32_1_IRQn);
NVIC_EnableIRQ(TIMER_32_1_IRQn);
Chip_TIMER_Enable(LPC_TIMER32_1);
}
static void initHardware(void)
{
SystemCoreClockUpdate();
SysTick_Config(SystemCoreClock/1000);
Board_Init();
Board_LED_Set(0, false);
/* Timer */
Chip_TIMER_Init(LPC_TIMER1);
Chip_TIMER_PrescaleSet(LPC_TIMER1,
#ifdef lpc1769
Chip_Clock_GetPeripheralClockRate(SYSCTL_PCLK_TIMER1) / 1000000 - 1
#else
Chip_Clock_GetRate(CLK_MX_TIMER1) / 1000000 - 1
#endif
);
/* Match 0 (period) */
Chip_TIMER_MatchEnableInt(LPC_TIMER1, 0);
Chip_TIMER_ResetOnMatchEnable(LPC_TIMER1, 0);
Chip_TIMER_StopOnMatchDisable(LPC_TIMER1, 0);
Chip_TIMER_SetMatch(LPC_TIMER1, 0, 1000);
/* Match 1 (duty) */
Chip_TIMER_MatchEnableInt(LPC_TIMER1, 1);
Chip_TIMER_ResetOnMatchDisable(LPC_TIMER1, 1);
Chip_TIMER_StopOnMatchDisable(LPC_TIMER1, 1);
Chip_TIMER_SetMatch(LPC_TIMER1, 1, 100);
Chip_TIMER_Reset(LPC_TIMER1);
Chip_TIMER_Enable(LPC_TIMER1);
NVIC_EnableIRQ(TIMER1_IRQn);
}
void AVALON_PWM_Init(void)
{
/* System CLK 48MHz */
Chip_TIMER_Init(LPC_TIMER16_0);
Chip_TIMER_Disable(LPC_TIMER16_0);
/* CT16B0_MAT0/CT16B0_MAT1/CT16B0_MAT2 Init */
Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 8, IOCON_FUNC2 | IOCON_MODE_INACT);
Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 9, IOCON_FUNC2 | IOCON_MODE_INACT);
Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 15, IOCON_FUNC2 | IOCON_MODE_INACT);
/* CT16B0_MAT0 duty:50% */
Chip_TIMER_ExtMatchControlSet(LPC_TIMER16_0, 1, TIMER_EXTMATCH_TOGGLE, 0);
Chip_TIMER_SetMatch(LPC_TIMER16_0, 0, DUTY_50);
/* CT16B0_MAT1 duty:25% */
Chip_TIMER_ExtMatchControlSet(LPC_TIMER16_0, 1, TIMER_EXTMATCH_TOGGLE, 1);
Chip_TIMER_SetMatch(LPC_TIMER16_0, 1, DUTY_25);
/* CT16B0_MAT2 duty:10% */
Chip_TIMER_ExtMatchControlSet(LPC_TIMER16_0, 1, TIMER_EXTMATCH_TOGGLE, 2);
Chip_TIMER_SetMatch(LPC_TIMER16_0, 2, DUTY_10);
/* Prescale 0 */
Chip_TIMER_PrescaleSet(LPC_TIMER16_0, 0);
/* PWM Period 800Hz */
Chip_TIMER_SetMatch(LPC_TIMER16_0, 3, DUTY_100);
Chip_TIMER_ResetOnMatchEnable(LPC_TIMER16_0, 3);
/* CT16B0_MAT0/CT16B0_MAT1/CT16B0_MAT2 Enable */
LPC_TIMER16_0->PWMC = 0x7;//pwm
Chip_TIMER_Enable(LPC_TIMER16_0);
}
/**
* @brief main routine for timer example
* @return Function should not exit.
*/
int main(void)
{
uint32_t timerBaseClock;
SystemCoreClockUpdate();
Board_Init();
Board_LED_Set(0, false);
Board_LED_Set(1, false);
/* Initialize Timer 0 and Timer 1 */
Chip_TIMER_Init(LPC_TIMER0);
Chip_TIMER_Init(LPC_TIMER1);
/* Setup prescale value on Timer 0 to PCLK */
Chip_TIMER_PrescaleSet(LPC_TIMER0, 0);
/* Setup prescale value on Timer 1 for lower resolution */
Chip_TIMER_PrescaleSet(LPC_TIMER1, PRESCALE_HZ2);
/* Reset timers */
Chip_TIMER_Reset(LPC_TIMER0);
Chip_TIMER_Reset(LPC_TIMER1);
/* Enable both timers to generate interrupts when time matches */
Chip_TIMER_MatchEnableInt(LPC_TIMER0, 1);
Chip_TIMER_MatchEnableInt(LPC_TIMER1, 1);
/* Get rate of timer base clock */
timerBaseClock = Chip_Clock_GetAsyncSyscon_ClockRate();
/* Setup Timer 0 for a match every 1s */
Chip_TIMER_SetMatch(LPC_TIMER0, 1, (timerBaseClock / TICKRATE_HZ1));
/* Setup Timer 1 for a match twice in a second */
Chip_TIMER_SetMatch(LPC_TIMER1, 1, (timerBaseClock / ((PRESCALE_HZ2 + 1) * TICKRATE_HZ2)) );
/* Setup both timers to restart when match occurs */
Chip_TIMER_ResetOnMatchEnable(LPC_TIMER0, 1);
Chip_TIMER_ResetOnMatchEnable(LPC_TIMER1, 1);
/* Start both timers */
Chip_TIMER_Enable(LPC_TIMER0);
Chip_TIMER_Enable(LPC_TIMER1);
/* Clear both timers of any pending interrupts */
NVIC_ClearPendingIRQ(CT32B0_IRQn);
NVIC_ClearPendingIRQ(CT32B1_IRQn);
/* Enable both timer interrupts */
NVIC_EnableIRQ(CT32B0_IRQn);
NVIC_EnableIRQ(CT32B1_IRQn);
/* Wait for timers to generate interrupts (LEDs toggle in interrupt handlers) */
while (1) {
__WFI();
}
return 0;
}
uint32_t PWMSetPeriod(uint8_t channel, uint32_t period) {
if (channel > CHANNEL_C_TIMER_INDEX) {
return 1;
}
if (eDVSMode != EDVS_MODE_INTERNAL && channel == 0) {
return 1; // channel 0 taken for master/slave mode
}
LPC_TIMER_T * timer = halTimers[channel].timer;
halTimers[channel].period = period;
/**
* If the period equal 0, the timer is disable and its outputs are set as GPIO and driven low.
*/
if (period == 0) {
Chip_TIMER_DeInit(timer); //Stop the timer
Chip_TIMER_SetMatch(timer, 2, 0);
halTimers[channel].enabled[0] = DISABLE;
halTimers[channel].enabled[1] = DISABLE;
Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, halTimers[channel].portGpio[0], halTimers[channel].pinGpio[0]);
Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, halTimers[channel].portGpio[1], halTimers[channel].pinGpio[1]);
Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, halTimers[channel].portGpio[0], halTimers[channel].pinGpio[0]);
Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, halTimers[channel].portGpio[1], halTimers[channel].pinGpio[1]);
Chip_SCU_PinMuxSet(halTimers[channel].port[0], halTimers[channel].pin[0], halTimers[channel].gpioMode[0]);
Chip_SCU_PinMuxSet(halTimers[channel].port[1], halTimers[channel].pin[1], halTimers[channel].gpioMode[1]);
} else {
/**
* The channel match 2 is used as the controller of the base frequency.
* When there is a match on this channel, the timer is reset and the external match bit
* is set to 1.
* The M0 core is looking for this change and it sets the output of the channels to high.
*/
Chip_TIMER_Init(timer);
Chip_TIMER_Disable(timer);
Chip_TIMER_Reset(timer);
/**
* The Main clock is running at 192Mhz so set the Prescaler in order to have
* a 1 Mhz timer. Timer_CLK = Main_CLK/ (PR+1)
*/
Chip_TIMER_PrescaleSet(timer, 191);
Chip_TIMER_ResetOnMatchEnable(timer, 2);
Chip_TIMER_StopOnMatchDisable(timer, 2);
Chip_TIMER_MatchDisableInt(timer, 2);
Chip_TIMER_SetMatch(timer, 2, period);
//Reconfigure match channels!
if (halTimers[channel].enabled[0]) {
PWMSetWidth(channel, 0, halTimers[channel].witdh[0]);
}
if (halTimers[channel].enabled[1]) {
PWMSetWidth(channel, 1, halTimers[channel].witdh[1]);
}
Chip_TIMER_ExtMatchControlSet(timer, 0, TIMER_EXTMATCH_SET, 2);
// Clear interrupt pending
timer->IR = 0xFFFFFFFF;
Chip_TIMER_Enable(timer);
}
return 0;
}
/*
* @Brief Initialize Timer peripheral
* @param timerNumber: Timer number, 0 to 3
* @param ticks: Number of ticks required to finish the cycle.
* @param voidFunctionPointer: function to be executed at the end of the timer cycle
* @return nothing
* @note For the 'ticks' parameter, see function Timer_microsecondsToTicks
*/
void Timer_Init( uint8_t timerNumber, uint32_t ticks,
voidFunctionPointer_t voidFunctionPointer){
/* Source:
http://docs.lpcware.com/lpcopen/v1.03/lpc18xx__43xx_2examples_2periph_2periph__blinky_2blinky_8c_source.html */
/*If timer period = CompareMatch0 Period = 0 => ERROR*/
if (ticks==0){
errorOcurred();
}
/* Enable timer clock and reset it */
Chip_TIMER_Init(timer_sd[timerNumber].name);
Chip_RGU_TriggerReset(timer_sd[timerNumber].RGU);
while (Chip_RGU_InReset(timer_sd[timerNumber].RGU)) {}
Chip_TIMER_Reset(timer_sd[timerNumber].name);
/* Update the defalut function pointer name of the Compare match 0*/
timer_dd[timerNumber].timerCompareMatchFunctionPointer[TIMERCOMPAREMATCH0] = voidFunctionPointer;
/* Initialize compare match with the specified ticks (number of counts needed to clear the match counter) */
Chip_TIMER_MatchEnableInt(timer_sd[timerNumber].name, TIMERCOMPAREMATCH0);
Chip_TIMER_SetMatch(timer_sd[timerNumber].name, TIMERCOMPAREMATCH0, ticks);
/* Makes Timer Match 0 period the timer period*/
Chip_TIMER_ResetOnMatchEnable(timer_sd[timerNumber].name, TIMERCOMPAREMATCH0);
/*Enable timer*/
Chip_TIMER_Enable(timer_sd[timerNumber].name);
/* Enable timer interrupt */
NVIC_SetPriority(timer_sd[timerNumber].IRQn, MAX_SYSCALL_INTERRUPT_PRIORITY+1);
NVIC_EnableIRQ(timer_sd[timerNumber].IRQn);
NVIC_ClearPendingIRQ(timer_sd[timerNumber].IRQn);
}
/**
* @brief Initialization 32-bit Timer 0
* @return Nothing
*/
void Timer32_0_Init(uint32_t tickrate)
{
uint32_t timerFreq;
/* Initialize 32-bit timer 0 clock */
Chip_TIMER_Init(LPC_TIMER32_0);
/* Timer rate is system clock rate */
timerFreq = Chip_Clock_GetSystemClockRate();
/* Timer setup for match and interrupt at TICKRATE_HZ */
Chip_TIMER_Reset(LPC_TIMER32_0);
/* Enable timer to generate interrupts when time matches */
Chip_TIMER_MatchEnableInt(LPC_TIMER32_0, 1);
/* Setup 32-bit timer's duration (32-bit match time) */
Chip_TIMER_SetMatch(LPC_TIMER32_0, 1, (timerFreq / tickrate));
/* Setup timer to restart when match occurs */
Chip_TIMER_ResetOnMatchEnable(LPC_TIMER32_0, 1);
/* Start timer */
Chip_TIMER_Enable(LPC_TIMER32_0);
/* Clear timer of any pending interrupts */
NVIC_ClearPendingIRQ(TIMER_32_0_IRQn);
/* Enable timer interrupt */
NVIC_EnableIRQ(TIMER_32_0_IRQn);
}
/*
* @Brief Enables a compare match in a timer
* @param timerNumber: Timer number, 0 to 3
* @param compareMatchNumber: Compare match number, 1 to 3
* @param ticks: Number of ticks required to reach the compare match.
* @param voidFunctionPointer: function to be executed when the compare match is reached
* @return None
* @note For the 'ticks' parameter, see function Timer_microsecondsToTicks
*/
void Timer_EnableCompareMatch(uint8_t timerNumber, uint8_t compareMatchNumber , uint32_t ticks, voidFunctionPointer_t voidFunctionPointer){
timer_dd[timerNumber].timerCompareMatchFunctionPointer[compareMatchNumber] = voidFunctionPointer;
Chip_TIMER_MatchEnableInt(timer_sd[timerNumber].name, compareMatchNumber);
Chip_TIMER_SetMatch(timer_sd[timerNumber].name, compareMatchNumber, ticks);
}
/**
* @brief main routine for blinky example
* @return Function should not exit.
*/
int main(void)
{
uint32_t timerFreq;
/* Generic Initialization */
SystemCoreClockUpdate();
Board_Init();
/* Enable timer 1 clock */
Chip_TIMER_Init(LPC_TIMER0);
/* Timer rate is system clock rate */
timerFreq = Chip_Clock_GetSystemClockRate();
/* Timer setup for match and interrupt at TICKRATE_HZ */
Chip_TIMER_Reset(LPC_TIMER0);
Chip_TIMER_MatchEnableInt(LPC_TIMER0, 1);
Chip_TIMER_SetMatch(LPC_TIMER0, 1, (timerFreq / TICKRATE_HZ1));
Chip_TIMER_ResetOnMatchEnable(LPC_TIMER0, 1);
Chip_TIMER_Enable(LPC_TIMER0);
/* Enable timer interrupt */
NVIC_ClearPendingIRQ(TIMER0_IRQn);
NVIC_EnableIRQ(TIMER0_IRQn);
/* LEDs toggle in interrupt handlers */
while (1) {
__WFI();
}
return 0;
}
uint32_t PWMSetWidth(uint8_t channel, uint8_t output, uint32_t width) {
if (output >= MAX_OUTPUTS || channel > CHANNEL_C_TIMER_INDEX) {
return 1;
}
if (eDVSMode != EDVS_MODE_INTERNAL && channel == 0) {
return 1; // channel 0 taken for master/slave mode
}
LPC_TIMER_T * timer = halTimers[channel].timer;
halTimers[channel].witdh[output] = width;
halTimers[channel].enabled[output] = ENABLE;
/**
* Since we have to use the Core M0 to overcome hardware limitations
* when the width is 0 or bigger than the period of the wave,
* the output is set as GPIO and driven accordingly.
*/
if (width == 0) { //Set GPIO Low
Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, halTimers[channel].portGpio[output],
halTimers[channel].pinGpio[output]);
Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, halTimers[channel].portGpio[output], halTimers[channel].pinGpio[output]);
Chip_SCU_PinMuxSet(halTimers[channel].port[output], halTimers[channel].pin[output],
halTimers[channel].gpioMode[output]);
} else if (width >= timer->MR[2]) { //Set GPIO High
Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, halTimers[channel].portGpio[output],
halTimers[channel].pinGpio[output]);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, halTimers[channel].portGpio[output], halTimers[channel].pinGpio[output]);
Chip_SCU_PinMuxSet(halTimers[channel].port[output], halTimers[channel].pin[output],
halTimers[channel].gpioMode[output]);
} else {
Chip_TIMER_SetMatch(timer, halTimers[channel].timerChannel[output], width);
Chip_SCU_PinMuxSet(halTimers[channel].port[output], halTimers[channel].pin[output],
halTimers[channel].timerMode[output]);
}
return 0;
}
void InicTimers(void){
uint32_t timerFreq;
//inicializo los timers para la maquina de estado
Chip_TIMER_Init(LPC_TIMER2);
//tomo la frecuencia del clok
timerFreq = Chip_Clock_GetSystemClockRate();
//confinfiguro el timer 2 y el match 1
Chip_TIMER_Reset(LPC_TIMER2);
Chip_TIMER_MatchEnableInt(LPC_TIMER2, 1);
Chip_TIMER_SetMatch(LPC_TIMER2, 1, 250);
Chip_TIMER_ResetOnMatchEnable(LPC_TIMER2, 1);
Chip_TIMER_Enable(LPC_TIMER2);
//habilito interrupciones
NVIC_ClearPendingIRQ(TIMER2_IRQn);
NVIC_EnableIRQ(TIMER2_IRQn);
}
void AVALON_PWM_SetDuty(AVALON_PWM_e pwm, unsigned char duty)
{
if ((pwm >= AVALON_PWM_GREEN) && (pwm < AVALON_PWM_MAX)) {
Chip_TIMER_ClearMatch(LPC_TIMER16_0, pwm);
Chip_TIMER_ExtMatchControlSet(LPC_TIMER16_0, 1, TIMER_EXTMATCH_SET, (int8_t)pwm);
Chip_TIMER_SetMatch(LPC_TIMER16_0, pwm, (uint32_t)duty);
}
}
void initialize_timer() {
Chip_TIMER_Init(LPC_TIMER1);
Chip_TIMER_Reset(LPC_TIMER1);
Chip_TIMER_MatchEnableInt(LPC_TIMER1, 1);
Chip_TIMER_SetMatch(LPC_TIMER1, 1, 240000);//1200000
Chip_TIMER_ResetOnMatchEnable(LPC_TIMER1, 1);
Chip_TIMER_Enable(LPC_TIMER1);
NVIC_ClearPendingIRQ(TIMER1_IRQn);
NVIC_EnableIRQ(TIMER1_IRQn);
}
void AVALON_PWM_Enable(void)
{
/* Prescale 0 */
Chip_TIMER_PrescaleSet(LPC_TIMER16_0, 0);
/* PWM Period 800Hz */
Chip_TIMER_SetMatch(LPC_TIMER16_0, 3, DUTY_100);
Chip_TIMER_ResetOnMatchEnable(LPC_TIMER16_0, 3);
/* CT16B0_MAT0/CT16B0_MAT1/CT16B0_MAT2 Enable */
LPC_TIMER16_0->PWMC = 0x7;
Chip_TIMER_Enable(LPC_TIMER16_0);
}
void
call_transmit_delay (uint32_t seconds)
{
NVIC_DisableIRQ (TIMER_32_0_IRQn);
transmit_call = false;
Chip_TIMER_Reset (LPC_TIMER32_0);
Chip_TIMER_ClearMatch(LPC_TIMER32_0, 0);
Chip_TIMER_SetMatch (LPC_TIMER32_0, 0, seconds);
NVIC_ClearPendingIRQ (TIMER_32_0_IRQn);
NVIC_EnableIRQ (TIMER_32_0_IRQn);
}
void AVALON_PWM_Init(void)
{
/* System CLK 48MHz */
Chip_TIMER_Init(LPC_TIMER16_0);
Chip_TIMER_Disable(LPC_TIMER16_0);
/* CT16B0_MAT0/CT16B0_MAT1/CT16B0_MAT2 Init */
Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 8, IOCON_FUNC2 | IOCON_MODE_INACT);
Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 9, IOCON_FUNC2 | IOCON_MODE_INACT);
Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 15, IOCON_FUNC2 | IOCON_MODE_INACT);
/* CT16B0_MAT0 duty:50% */
Chip_TIMER_ExtMatchControlSet(LPC_TIMER16_0, 1, TIMER_EXTMATCH_SET, 0);
Chip_TIMER_SetMatch(LPC_TIMER16_0, 0, DUTY_0);
/* CT16B0_MAT1 duty:25% */
Chip_TIMER_ExtMatchControlSet(LPC_TIMER16_0, 1, TIMER_EXTMATCH_SET, 1);
Chip_TIMER_SetMatch(LPC_TIMER16_0, 1, DUTY_0);
/* CT16B0_MAT2 duty:10% */
Chip_TIMER_ExtMatchControlSet(LPC_TIMER16_0, 1, TIMER_EXTMATCH_SET, 2);
Chip_TIMER_SetMatch(LPC_TIMER16_0, 2, DUTY_0);
}
void setupTimer(void)
{
Chip_IOCON_PinMux(LPC_IOCON, 1, 28, 2, 3);
Chip_GPIO_SetPinDIROutput(LPC_GPIO, 1, 28);
Chip_TIMER_Init(LPC_TIMER0);
Chip_TIMER_Reset(LPC_TIMER0);
Chip_TIMER_PrescaleSet(LPC_TIMER0, 500);
Chip_TIMER_SetMatch(LPC_TIMER0, 0, 16000);
Chip_TIMER_ResetOnMatchEnable(LPC_TIMER0, 0);
// Chip_TIMER_MatchEnableInt(LPC_TIMER0, 0);
Chip_TIMER_ExtMatchControlSet(LPC_TIMER0, RESET, TIMER_EXTMATCH_TOGGLE, 0);
Chip_TIMER_Enable(LPC_TIMER0);
// NVIC_ClearPendingIRQ(TIMER0_IRQn);
// NVIC_EnableIRQ(TIMER0_IRQn);
}
void vConfigureTimerForRunTimeStats( void )
{
uint32_t timerFreq;
/* Enable timer 1 clock and reset it */
Chip_TIMER_Init(LPC_TIMER1);
Chip_RGU_TriggerReset(RGU_TIMER1_RST);
while (Chip_RGU_InReset(RGU_TIMER1_RST)) {}
/* Get timer 1 peripheral clock rate */
timerFreq = Chip_Clock_GetRate(CLK_MX_TIMER1);
/* Timer setup for match and interrupt at TICKRATE_HZ */
Chip_TIMER_Reset(LPC_TIMER1);
Chip_TIMER_SetMatch(LPC_TIMER1, 1, (timerFreq / TICKRATE_HZ));
Chip_TIMER_ResetOnMatchEnable(LPC_TIMER1, 1);
Chip_TIMER_Enable(LPC_TIMER1);
}
int main(void)
{
int duty = 100;
initHardware();
while(1) {
pausems(1000);
duty += 100;
if(duty == 1000) duty = 100;
Chip_TIMER_SetMatch(LPC_TIMER1, 1, duty);
Chip_TIMER_Reset(LPC_TIMER1);
Chip_TIMER_ClearMatch(LPC_TIMER1, 1);
Chip_TIMER_ClearMatch(LPC_TIMER1, 0);
}
}
void
call_init (void)
{
transmit_call = false;
Chip_TIMER_Init (LPC_TIMER32_0);
Chip_TIMER_Reset (LPC_TIMER32_0);
Chip_TIMER_MatchEnableInt (LPC_TIMER32_0, 0);
Chip_TIMER_PrescaleSet (LPC_TIMER32_0, Chip_Clock_GetSystemClockRate ());
Chip_TIMER_SetMatch (LPC_TIMER32_0, 0, CALL_INTERVAL_SEC);
Chip_TIMER_ResetOnMatchEnable (LPC_TIMER32_0, 0);
Chip_TIMER_Enable (LPC_TIMER32_0);
NVIC_ClearPendingIRQ (TIMER_32_0_IRQn);
NVIC_EnableIRQ (TIMER_32_0_IRQn);
}
void Board_TIMER_EnableTimerAsTimer(uint8_t timerNum, uint32_t presc,uint32_t matchValue,bool flagOnce)
{
// always using match0
int8_t match=0;
LPC_TIMER_T* t = getTimerFomIndex(timerNum);
Chip_TIMER_PrescaleSet(t, presc);
Chip_TIMER_SetMatch(t, match, matchValue);
Chip_TIMER_MatchEnableInt(t, match); // enable int for match 0
if(flagOnce==1)
{
Board_TIMER_DisableTimer(timerNum);
Board_TIMER_SetTimerCounter(timerNum,0);
Chip_TIMER_ResetOnMatchDisable(t, match); // reset count on match0
}
else
{
Chip_TIMER_ResetOnMatchEnable(t, match); // reset count on match0
}
Chip_TIMER_Enable(t);
}
void
call_transmit_if_needed (void)
{
NVIC_DisableIRQ (TIMER_32_0_IRQn);
if (transmit_call) {
DBG (DBG_LEVEL_INFO, "Transmitting station ID (%s)", CALL_STRING);
tx_enable ();
while (!tx_is_ready ());
morse_send (CALL_STRING, strlen (CALL_STRING));
systick_delay (CALL_POST_DELAY_MS);
tx_disable ();
transmit_call = false;
Chip_TIMER_Reset (LPC_TIMER32_0);
Chip_TIMER_ClearMatch(LPC_TIMER32_0, 0);
Chip_TIMER_SetMatch (LPC_TIMER32_0, 0, CALL_INTERVAL_SEC);
NVIC_ClearPendingIRQ (TIMER_32_0_IRQn);
}
NVIC_EnableIRQ (TIMER_32_0_IRQn);
}
void
main (void)
{
SystemInit ();
Chip_IOCON_PinMuxSet (LPC_IOCON, LED_STATUS_PIO, IOCON_MODE_INACT | IOCON_FUNC0);
Chip_GPIO_SetPinDIROutput (LPC_GPIO, LED_STATUS_PORT, LED_STATUS_PIN);
Chip_GPIO_SetPinState (LPC_GPIO, LED_STATUS_PORT, LED_STATUS_PIN, false);
Chip_TIMER_Init (LPC_TIMER32_0);
Chip_TIMER_Reset (LPC_TIMER32_0);
Chip_TIMER_MatchEnableInt (LPC_TIMER32_0, 1);
Chip_TIMER_SetMatch (LPC_TIMER32_0, 1, (Chip_Clock_GetSystemClockRate () / (1 * 32)));
Chip_TIMER_ResetOnMatchEnable (LPC_TIMER32_0, 1);
Chip_TIMER_Enable (LPC_TIMER32_0);
/* Enable timer interrupt */
NVIC_ClearPendingIRQ (TIMER_32_0_IRQn);
NVIC_EnableIRQ (TIMER_32_0_IRQn);
while (1) {
__WFI ();
}
}
/**
* @details Where all the magic happens
* @return Shouldn't return
*/
int main(void) {
Init_Core();
Init_SM();
Init_Board();
Init_Globals();
Init_CAN();
Init_Timers();
// ------------------------------------------------
// Begin
DEBUG_Print("Started Up\r\n");
while(1) {
uint8_t count;
if ((count = Chip_UART_Read(LPC_USART, Rx_Buf, UART_RX_BUF_SIZE)) != 0) {
switch (Rx_Buf[0]) {
case 'a': // Print out Brusa Mains Info
DEBUG_Print("Actual Mains Voltage: ");
itoa(brusa_actual_1.mains_mVolts, str, 10);
DEBUG_Print(str);
DEBUG_Print("\r\n");
DEBUG_Print("Mains type: ");
itoa(brusa_actual_1.mains_cAmps, str, 10);
DEBUG_Print(str);
DEBUG_Print("\r\n");
DEBUG_Print("Temp: ");
itoa((brusa_temp.power_temp / 10) - 40 , str, 10);
DEBUG_Print(str);
DEBUG_Print("\r\n");
DEBUG_Print("Temp: 0x");
itoa(brusa_temp.power_temp , str, 16);
DEBUG_Print(str);
DEBUG_Print("\r\n");
break;
case 'b': // Print out Actual Brusa Output
DEBUG_Print("Actual Out Voltage: ");
itoa(brusa_actual_1.output_mVolts, str, 10);
DEBUG_Println(str);
DEBUG_Print("Actual Out Current: ");
itoa(brusa_actual_1.output_cAmps, str, 10);
DEBUG_Println(str);
break;
case 'f': // Print out Pack State
itoa(pack_state.pack_min_mVolts, str, 10);
DEBUG_Print("Pack Min Voltage: ");
DEBUG_Print(str);
DEBUG_Print("\r\n");
itoa(pack_state.pack_max_mVolts, str, 10);
DEBUG_Print("Pack Max Voltage: ");
DEBUG_Print(str);
DEBUG_Print("\r\n");
break;
case 'y': // Print out Module Balance State
itoa(PackManager_GetExtModId(0), str, 16);
DEBUG_Print("Mod 0x");
DEBUG_Print(str);
itoa(PackManager_GetExtBal(0), str, 2);
DEBUG_Print(": 0b");
DEBUG_Println(str);
itoa(PackManager_GetExtModId(1), str, 16);
DEBUG_Print("Mod 0x");
DEBUG_Print(str);
itoa(PackManager_GetExtBal(1), str, 2);
DEBUG_Print(": 0b");
DEBUG_Println(str);
break;
case 'e':
itoa(brusa_error,str, 2);
DEBUG_Println(str);
break;
case 'm': // Print out charge mode and brusa error
DEBUG_Print("Charge Mode: ");
itoa(Charge_GetMode(), str, 10);
DEBUG_Println(str);
DEBUG_Print("Error Messages: ");
itoa((uint64_t)brusa_error, str, 2);
DEBUG_Println(str);
break;
default:
DEBUG_Print("Unknown Command\r\n");
}
}
//-----------------------------
// Detect Input Changes (Default to IDLE)
MODE_INPUT_T inp = INP_IDLE;
if (!Board_Switch_Read()) {
inp = INP_CHRG;
} else {
inp = INP_IDLE;
}
//-----------------------------
// Update pack_state
pack_state.contactors_closed = Board_Contactors_Closed();
pack_state.msTicks = msTicks;
pack_state.brusa_error = brusa_error;
pack_state.pack_cAmps_in = brusa_actual_1.output_cAmps;
//-----------------------------
// SSM Step
ERROR_T result = SSM_Step(&pack_state, inp, &out_state);
if (result != ERROR_NONE) {
_error(result, true, false);
}
//-----------------------------
// Check if SSM has Changed State
// Currently only changes Poll Frequency
// [TODO] Set a status LED!!
if (SSM_GetMode() != mode) {
mode = SSM_GetMode();
switch (SSM_GetMode()) {
case IDLE:
Chip_TIMER_SetMatch(LPC_TIMER32_1, 0, Hertz2Ticks(BCM_POLL_IDLE_FREQ));
Chip_TIMER_Reset(LPC_TIMER32_1); // Otherwise shit gets F****D
break;
case CHARGING:
Chip_TIMER_SetMatch(LPC_TIMER32_1, 0, Hertz2Ticks(BCM_POLL_CHARGING_FREQ));
Chip_TIMER_Reset(LPC_TIMER32_1);
break;
case DRAINING:
Chip_TIMER_SetMatch(LPC_TIMER32_1, 0, Hertz2Ticks(BCM_POLL_DRAINING_FREQ));
Chip_TIMER_Reset(LPC_TIMER32_1);
break;
}
}
//-----------------------------
// Carry out out_state
if (out_state.close_contactors && !Board_Contactors_Closed()) {
Board_Close_Contactors(true);
} else if (!out_state.close_contactors && Board_Contactors_Closed()) {
Board_Close_Contactors(false);
}
if (out_state.brusa_output) {
brusa_control.clear_error = out_state.brusa_clear_latch;
brusa_control.output_mVolts = out_state.brusa_mVolts;
brusa_control.output_cAmps = out_state.brusa_cAmps;
Chip_TIMER_Enable(LPC_TIMER32_0);
} else {
brusa_control.output_mVolts = 0;
brusa_control.output_cAmps = 0;
Chip_TIMER_Disable(LPC_TIMER32_0);
}
//-----------------------------
// Retrieve available brusa messages
int8_t tmp = MCP2515_GetFullReceiveBuffer();
int8_t res = 0;
if (tmp == 2) {
MCP2515_ReadBuffer(&mcp_msg_obj, 0);
res = Brusa_Decode(&brusa_messages, &mcp_msg_obj);
if (res == -1) {
DEBUG_Println("Brusa Decode Error");
res = 0;
}
MCP2515_ReadBuffer(&mcp_msg_obj, 1);
res = Brusa_Decode(&brusa_messages, &mcp_msg_obj);
} else if (tmp == 0) { // Receive Buffer 0 Full
MCP2515_ReadBuffer(&mcp_msg_obj, tmp);
res = Brusa_Decode(&brusa_messages, &mcp_msg_obj);
} else if (tmp == 1) { //Receive buffer 1 full
MCP2515_ReadBuffer(&mcp_msg_obj, tmp);
res = Brusa_Decode(&brusa_messages, &mcp_msg_obj);
}
if (res == -1) {
DEBUG_Println("Brusa Decode Error");
res = 0;
}
//-----------------------------
// Send brusa message if its time
if (brusa_message_send) {
brusa_message_send = false;
Brusa_MakeCTL(&brusa_control, &mcp_msg_obj);
MCP2515_LoadBuffer(0, &mcp_msg_obj);
MCP2515_SendBuffer(0);
}
//-----------------------------
// Check for and decode A123 Messages
if (!RingBuffer_IsEmpty(&rx_buffer)) {
CCAN_MSG_OBJ_T temp_msg;
RingBuffer_Pop(&rx_buffer, &temp_msg);
res = PackManager_Update(&temp_msg);
if (new_std_msg_sent) {
PackManager_Commit(&pack_state);
new_std_msg_sent = false;
}
}
if (res == -1) {
DEBUG_Println("A123 Decode Error");
}
//-----------------------------
// Timed output
if (msTicks - last_debug_message > TIMED_MESSAGE_DELAY) {
message_count++;
last_debug_message = msTicks;
switch (message_count % 7) {
case 0:
if (out_state.balance) {
itoa(mbb_cmd.balance_target_mVolts, str, 10);
DEBUG_Print("Balancing to: ");
DEBUG_Println(str);
} else {
DEBUG_Println("Not balancing");
}
break;
case 1:
itoa(brusa_control.output_mVolts, str, 10);
DEBUG_Print("Brusa out V: ");
DEBUG_Println(str);
break;
case 2:
itoa(brusa_control.output_cAmps, str, 10);
DEBUG_Print("Brusa out C: ");
DEBUG_Println(str);
break;
case 3:
DEBUG_Print("Actual Out Voltage: ");
itoa(brusa_actual_1.output_mVolts, str, 10);
DEBUG_Println(str);
break;
case 4:
DEBUG_Print("Actual Out Current: ");
itoa(brusa_actual_1.output_cAmps, str, 10);
DEBUG_Println(str);
break;
case 5:
DEBUG_Print("Mode: ");
DEBUG_Println((SSM_GetMode() == CHARGING) ? "Chrg":"Idle");
break;
case 6:
DEBUG_Print("Brusa Output: ");
itoa(out_state.brusa_output, str, 2);
DEBUG_Println(str);
DEBUG_Print("\r\n");
break;
}
}
}
return 0;
}
/*
* @Purpose: Allows the user to change the compare value nº
* 'compareMatchNumber' of timer 'timerNumber'. This is specially useful to
* generate square waves if used in the function for the TIMERCOMPAREMATCH0
* (because that compare match resets the timer counter), which will be
* passed as a parameter when initializing a timer
* @note: The selected time (3rd parameter) must be less than
* TIMERCOMPAREMATCH0's compareMatchTime_uS for the compare match to make the
* interruption
*/
void Timer_SetCompareMatch( uint8_t timerNumber,
uint8_t compareMatchNumber,
uint32_t ticks){
Chip_TIMER_SetMatch(timer_sd[timerNumber].name, compareMatchNumber,ticks);
}
void Board_TIMER_SetTimerMatch(uint8_t timerNum,uint32_t value)
{
Chip_TIMER_SetMatch(getTimerFomIndex(timerNum), 0, value); // always match 0
}
