/*!
* @brief main function
*/
int main(void)
{
#if FSL_FEATURE_ADC16_HAS_CALIBRATION
adc16_calibration_param_t tempSnseCalibraitionParam;
#endif
hardware_init();
GPIO_DRV_Init(NULL, ledPins);
// Configure the power mode protection
SMC_HAL_SetProtection(SMC_BASE_PTR, kAllowPowerModeVlp);
ADC16_DRV_StructInitUserConfigDefault(&tempSnseAdcConfig);
#if (FSL_FEATURE_ADC16_MAX_RESOLUTION >= 16)
tempSnseAdcConfig.resolution = kAdc16ResolutionBitOf16;
#endif
#if BOARD_ADC_USE_ALT_VREF
tempSnseAdcConfig.refVoltSrc = kAdc16RefVoltSrcOfValt;
#endif
// Init ADC
ADC16_DRV_Init(ADC_INSTANCE, &tempSnseAdcConfig);
// Calibrate VDD and ADCR_TEMP25
#if FSL_FEATURE_ADC16_HAS_CALIBRATION
// Auto calibraion
ADC16_DRV_GetAutoCalibrationParam(ADC_INSTANCE, &tempSnseCalibraitionParam);
ADC16_DRV_SetCalibrationParam(ADC_INSTANCE, &tempSnseCalibraitionParam);
#endif // FSL_FEATURE_ADC16_HAS_CALIBRATION
calibrateParams();
// get cpu uid low value for slave
gSlaveId = SIM_UIDL_UID(SIM_BASE_PTR);
PRINTF("i2c_rtos_slave_bm demo\r\n");
// task list initialize
OSA_Init();
// create task(in BM: only the first registered task can be executed)
OSA_TaskCreate(task_slave,
(uint8_t *)"slave",
512,
task_slave_stack,
0,
(void *)0,
false,
&task_slave_task_handler);
OSA_Start();
return 0;
}
/*!
* @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
}
}
/*!
* @brief main function
*/
int main(void)
{
i2c_slave_state_t slave;
i2cData_t i2cData =
{
.subAddress = Invalid_Subaddress_Index,
.data = 0,
.state = CMD_MODE
};
i2c_slave_user_config_t userConfig =
{
.address = 0x3A,
.slaveListening = true,
.slaveCallback = i2c_slave_event_callback_passive,
.callbackParam = &i2cData,
#if FSL_FEATURE_I2C_HAS_START_STOP_DETECT
.startStopDetect = false,
#endif
#if FSL_FEATURE_I2C_HAS_STOP_DETECT
.stopDetect = false,
#endif
};
// Low Power Configuration
smc_power_mode_config_t smcConfig;
// Init struct
memset(&smcConfig, 0, sizeof(smcConfig));
hardware_init();
OSA_Init();
GPIO_DRV_Init(0, ledPins);
// Initiate I2C instance module
I2C_DRV_SlaveInit(BOARD_I2C_INSTANCE, &userConfig, &slave);
PRINTF("\r\n====== I2C Slave ======\r\n\r\n");
// turn LED_slave on to indicate I2C slave status is waiting for date receiving
LED_turnon_slave();
LED_turnoff_master();
OSA_TimeDelay(50);
PRINTF("\r\n I2C slave enters low power mode...\r\n");
// set to allow entering specific modes
SMC_HAL_SetProtection(SMC, kAllowPowerModeVlp);
// set power mode to specific Run mode
#if FSL_FEATURE_SMC_HAS_LPWUI
smcConfig.lpwuiOptionValue = kSmcLpwuiEnabled;
#endif
#if FSL_FEATURE_SMC_HAS_PORPO
smcConfig.porOptionValue = kSmcPorEnabled;
#endif
#if FSL_FEATURE_SMC_HAS_HIGH_SPEED_RUN_MODE
smcConfig.powerModeName = kPowerModeRun;
// If current status is HSRUN mode, change to RUN mode first.
if (kStatHsrun == SMC_HAL_GetStat(SMC_BASE_PTR))
{
SMC_HAL_SetMode(SMC_BASE_PTR, &smcConfig);
}
#endif
smcConfig.powerModeName = kPowerModeWait;
// Entry to Low Power Mode
SMC_HAL_SetMode(SMC_BASE_PTR, &smcConfig);
// LED_slave is still on during low power mode until I2C master send data to slave.
// Turn off LED_slave to indicate MCU wake up by I2C address matching interrupt
LED_turnoff_slave();
PRINTF("\r\n I2C slave wakes up from low power mode by I2C address matching.\r\n");
while(1);
}
