void hardware_init(void) {
/* enable clock for PORTs */
CLOCK_SYS_EnablePortClock(PORTE_IDX);
CLOCK_SYS_EnablePortClock(PORTF_IDX);
CLOCK_SYS_EnablePortClock(PORTI_IDX);
CLOCK_SYS_EnablePortClock(PORTL_IDX);
/* enable XBAR clock */
CLOCK_SYS_EnableXbarClock(0);
/* Init board EXTAL 32.768KHz clock */
BOARD_InitRtcOsc();
/* configure MCG mode as FEE, FLL 24MHz 1:1:1 */
CLOCK_SYS_SetConfiguration(&clkFll24MCfg);
/* init debug uart */
dbg_uart_init();
configure_xbar_pins(0U);
}
/*FUNCTION**********************************************************************
*
* Function Name : CLOCK_SYS_UpdateConfiguration
* Description : Send notification and change system clock configuration.
* This function sends the notification to all callback functions, if all
* callbacks return OK or forceful policy is used, this function will change
* system clock configuration.
*
*END**************************************************************************/
clock_manager_error_code_t CLOCK_SYS_UpdateConfiguration(uint8_t targetConfigIndex,
clock_manager_policy_t policy)
{
uint8_t callbackIdx;
clock_manager_error_code_t ret = kClockManagerSuccess;
clock_manager_callback_user_config_t* callbackConfig;
clock_notify_struct_t notifyStruct;
notifyStruct.targetClockConfigIndex = targetConfigIndex;
notifyStruct.policy = policy;
/* Clock configuration index is out of range. */
if (targetConfigIndex >= g_clockState.clockConfigNum)
{
return kClockManagerErrorOutOfRange;
}
OSA_EnterCritical(kCriticalLockSched);
/* Set errorcallbackindex as callbackNum, which means no callback error now.*/
g_clockState.errorCallbackIndex = g_clockState.callbackNum;
/* First step: Send "BEFORE" notification. */
notifyStruct.notifyType = kClockManagerNotifyBefore;
/* Send notification to all callback. */
for (callbackIdx=0; callbackIdx<g_clockState.callbackNum; callbackIdx++)
{
callbackConfig = g_clockState.callbackConfig[callbackIdx];
if ((NULL != callbackConfig) &&
((uint8_t)callbackConfig->callbackType & (uint8_t)kClockManagerNotifyBefore))
{
if (kClockManagerSuccess !=
(*callbackConfig->callback)(¬ifyStruct,
callbackConfig->callbackData))
{
g_clockState.errorCallbackIndex = callbackIdx;
/* Save the error callback index. */
ret = kClockManagerErrorNotificationBefore;
if (kClockManagerPolicyAgreement == policy)
{
break;
}
}
}
}
/* If all callback success or forceful policy is used. */
if ((kClockManagerSuccess == ret) ||
(policy == kClockManagerPolicyForcible))
{
/* clock mode switch. */
OSA_EnterCritical(kCriticalDisableInt);
CLOCK_SYS_SetConfiguration(g_clockState.configTable[targetConfigIndex]);
g_clockState.curConfigIndex = targetConfigIndex;
OSA_ExitCritical(kCriticalDisableInt);
notifyStruct.notifyType = kClockManagerNotifyAfter;
for (callbackIdx=0; callbackIdx<g_clockState.callbackNum; callbackIdx++)
{
callbackConfig = g_clockState.callbackConfig[callbackIdx];
if ((NULL != callbackConfig) &&
((uint8_t)callbackConfig->callbackType & (uint8_t)kClockManagerNotifyAfter))
{
if (kClockManagerSuccess !=
(*callbackConfig->callback)(¬ifyStruct,
callbackConfig->callbackData))
{
g_clockState.errorCallbackIndex = callbackIdx;
/* Save the error callback index. */
ret = kClockManagerErrorNotificationAfter;
if (kClockManagerPolicyAgreement == policy)
{
break;
}
}
}
}
}
else /* Error occurs, need to send "RECOVER" notification. */
{
notifyStruct.notifyType = kClockManagerNotifyRecover;
while (callbackIdx--)
{
callbackConfig = g_clockState.callbackConfig[callbackIdx];
if (NULL != callbackConfig)
{
(*callbackConfig->callback)(¬ifyStruct,
callbackConfig->callbackData);
}
}
}
OSA_ExitCritical(kCriticalLockSched);
return ret;
}
/*!
* @brief Main function
*/
int main (void)
{
/* enable clock for PORTs */
CLOCK_SYS_EnablePortClock(PORTA_IDX);
//CLOCK_SYS_EnablePortClock(PORTB_IDX);
CLOCK_SYS_EnablePortClock(PORTC_IDX);
CLOCK_SYS_EnablePortClock(PORTD_IDX);
CLOCK_SYS_EnablePortClock(PORTE_IDX);
/* Set allowed power mode, allow all. */
SMC_HAL_SetProtection(SMC, kAllowPowerModeAll);
/* Set system clock configuration. */
CLOCK_SYS_SetConfiguration(&g_defaultClockConfigVlpr);
/* Initialize LPTMR */
lptmr_state_t lptmrState;
LPTMR_DRV_Init(LPTMR0_IDX, &lptmrState, &g_lptmrConfig);
LPTMR_DRV_SetTimerPeriodUs(LPTMR0_IDX, 100000);
LPTMR_DRV_InstallCallback(LPTMR0_IDX, lptmr_call_back);
/* Initialize DMA */
dma_state_t dma_state;
DMA_DRV_Init(&dma_state);
/* Initialize PIT */
PIT_DRV_Init(0, false);
PIT_DRV_InitChannel(0, 0, &g_pitChan0);
/* Initialize CMP */
CMP_DRV_Init(0, &g_cmpState, &g_cmpConf);
CMP_DRV_ConfigDacChn(0, &g_cmpDacConf);
PORT_HAL_SetMuxMode(g_portBase[GPIOC_IDX], 0, kPortMuxAlt5);
CMP_DRV_Start(0);
/* Buttons */
GPIO_DRV_InputPinInit(&g_switch1);
GPIO_DRV_InputPinInit(&g_switch2);
GPIO_DRV_InputPinInit(&g_switchUp);
GPIO_DRV_InputPinInit(&g_switchDown);
GPIO_DRV_InputPinInit(&g_switchLeft);
GPIO_DRV_InputPinInit(&g_switchRight);
GPIO_DRV_InputPinInit(&g_switchSelect);
/* Start LPTMR */
LPTMR_DRV_Start(LPTMR0_IDX);
/* Setup LPUART1 */
LPUART_DRV_Init(1, &g_lpuartState, &g_lpuartConfig);
LPUART_DRV_InstallRxCallback(1, lpuartRxCallback, rxBuff, NULL, true);
LPUART_DRV_InstallTxCallback(1, lpuartTxCallback, NULL, NULL);
LPUART_BWR_CTRL_TXINV(g_lpuartBase[1], 1);
PORT_HAL_SetMuxMode(g_portBase[GPIOE_IDX], 0, kPortMuxAlt3);
PORT_HAL_SetMuxMode(g_portBase[GPIOE_IDX], 1, kPortMuxAlt3);
/* Setup FlexIO for the WS2812B */
FLEXIO_Type *fiobase = g_flexioBase[0];
CLOCK_SYS_SetFlexioSrc(0, kClockFlexioSrcMcgIrClk);
FLEXIO_DRV_Init(0, &g_flexioConfig);
FLEXIO_HAL_ConfigureTimer(fiobase, 0, &g_timerConfig);
FLEXIO_HAL_ConfigureShifter(fiobase, 0, &g_shifterConfig);
PORT_HAL_SetMuxMode(g_portBase[GPIOE_IDX], 20, kPortMuxAlt6);
FLEXIO_DRV_Start(0);
FLEXIO_HAL_SetShifterStatusDmaCmd(fiobase, 1, true);
DMA_DRV_RequestChannel(kDmaAnyChannel, kDmaRequestMux0FlexIOChannel0,
&g_fioChan);
DMA_DRV_RegisterCallback(&g_fioChan, fioDmaCallback, NULL);
/* Connect buzzer to TPM0_CH3 */
PORT_HAL_SetMuxMode(g_portBase[GPIOE_IDX], 30, kPortMuxAlt3);
tpm_general_config_t tmpConfig = {
.isDBGMode = false,
.isGlobalTimeBase = false,
.isTriggerMode = false,
.isStopCountOnOveflow = false,
.isCountReloadOnTrig = false,
.triggerSource = kTpmTrigSel0,
};
TPM_DRV_Init(0, &tmpConfig);
TPM_DRV_SetClock(0, kTpmClockSourceModuleMCGIRCLK, kTpmDividedBy1);
/* Blank LED just in case, saves power */
led(0x00, 0x00, 0x00);
/* Init e-paper display */
EPD_Init();
/* Throw up first image */
int ret = EPD_Draw(NULL, images[current_image]);
if (-1 == ret) {
led(0xff, 0x00, 0x00);
} else if (-2 == ret) {
led(0xff, 0xff, 0x00);
} else if (-3 == ret) {
led(0x00, 0x00, 0xff);
} else {
led(0x00, 0xff, 0x00);
}
blank_led = 30;
/* Deinit so we can mess around on the bus pirate */
//EPD_Deinit();
/* We're done, everything else is triggered through interrupts */
for(;;) {
if (cue_next_image) {
int old_image = current_image;
current_image = (current_image + 1) % image_count;
EPD_Draw(images[old_image], images[current_image]);
cue_next_image = 0;
}
#ifndef DEBUG
SMC_HAL_SetMode(SMC, &g_idlePowerMode);
#endif
}
}
