/*!
* @Brief enable the trigger source of LPTimer
*/
void init_trigger_source(uint32_t adcInstance)
{
uint32_t freqUs;
lptmr_user_config_t lptmrUserConfig =
{
.timerMode = kLptmrTimerModeTimeCounter,
.freeRunningEnable = false,
.prescalerEnable = false, // bypass perscaler
#if (CLOCK_INIT_CONFIG == CLOCK_VLPR)
// use MCGIRCCLK, 4M or 32KHz
.prescalerClockSource = kClockLptmrSrcMcgIrClk,
#else
// Use LPO clock 1KHz
.prescalerClockSource = kClockLptmrSrcLpoClk,
#endif
.isInterruptEnabled = false
};
// Init LPTimer driver
LPTMR_DRV_Init(0, &gLPTMRState, &lptmrUserConfig);
// Set the LPTimer period
freqUs = 1000000U/(INPUT_SIGNAL_FREQ*NR_SAMPLES)*2;
LPTMR_DRV_SetTimerPeriodUs(0, freqUs);
// Start the LPTimer
LPTMR_DRV_Start(0);
// Configure SIM for ADC hw trigger source selection
#if defined(KM34Z7_SERIES)
SIM_HAL_EnableClock(gSimBase[0], kSimClockGateXbar0);
SIM_HAL_SetAdcTrgSelMode(gSimBase[0], kSimAdcTrgSelXbar);
XBAR_DRV_ConfigSignalConnection(kXbaraInputLPTMR0_Output, kXbaraOutputADC_TRGA);
#else
SIM_HAL_SetAdcAlternativeTriggerCmd(gSimBase[0], adcInstance, true);
SIM_HAL_SetAdcPreTriggerMode(gSimBase[0], adcInstance, kSimAdcPretrgselA);
SIM_HAL_SetAdcTriggerMode(gSimBase[0], adcInstance, kSimAdcTrgSelLptimer);
#endif
}
/*!
* @Brief disable the trigger source
*/
void deinit_trigger_source(uint32_t adcInstance)
{
LPTMR_DRV_Stop(0);
LPTMR_DRV_Deinit(0);
}
/*lint -save -e970 Disable MISRA rule (6.3) checking. */
int main(void)
/*lint -restore Enable MISRA rule (6.3) checking. */
{
/* Write your local variable definition here */
uint32_t currentCounter = 0;
/*** Processor Expert internal initialization. DON'T REMOVE THIS CODE!!! ***/
PE_low_level_init();
/*** End of Processor Expert internal initialization. ***/
hw_average_config.hwAverageCountMode = kAdc16HwAverageCountOf32; //enable hardware average.
ADC16_DRV_ConfigHwAverage(FSL_ADCONV1,&hw_average_config);
ADC16_DRV_GetAutoCalibrationParam(FSL_ADCONV1,&calibration_param);
calibrateParams();
//ADC16_DRV_Init(FSL_ADCONV1, &adConv1_InitConfig0);
LPTMR_DRV_SetTimerPeriodUs(FSL_LPTMR1,1000000); // Set lptmr period
printf("\r\nLPTMR is running!!\r\n");
LPTMR_DRV_Start(FSL_LPTMR1);
/* Write your code here */
/* For example: for(;;) { } */
while(1)
{
if(currentCounter != lptmrCounter)
{
currentCounter = lptmrCounter;
printf("\r\nLPTMR interrupt No.%d \r\n",currentCounter);
GPIO_DRV_TogglePinOutput(LEDRGB_GREEN);
}
}
/*** Don't write any code pass this line, or it will be deleted during code generation. ***/
/*** RTOS startup code. Macro PEX_RTOS_START is defined by the RTOS component. DON'T MODIFY THIS CODE!!! ***/
#ifdef PEX_RTOS_START
PEX_RTOS_START(); /* Startup of the selected RTOS. Macro is defined by the RTOS component. */
#endif
/*** End of RTOS startup code. ***/
/*** Processor Expert end of main routine. DON'T MODIFY THIS CODE!!! ***/
for(;;){}
/*** Processor Expert end of main routine. DON'T WRITE CODE BELOW!!! ***/
} /*** End of main routine. DO NOT MODIFY THIS TEXT!!! ***/
/*!
* @Brief enable the trigger source of LPTimer
*/
void init_trigger_source(uint32_t adcInstance)
{
uint32_t freqUs;
lptmr_user_config_t lptmrUserConfig =
{
.timerMode = kLptmrTimerModeTimeCounter,
.freeRunningEnable = false,
.prescalerEnable = false, // bypass perscaler
.prescalerClockSource = kClockLptmrSrcMcgIrClk, // use MCGIRCCLK, 4M or 32KHz
.isInterruptEnabled = false
};
// Init LPTimer driver
LPTMR_DRV_Init(0, &lptmrUserConfig, &gLPTMRState);
// Set the LPTimer period
freqUs = 1000000U/(INPUT_SIGNAL_FREQ*NR_SAMPLES)*2;
LPTMR_DRV_SetTimerPeriodUs(0, freqUs);
// Start the LPTimer
LPTMR_DRV_Start(0);
// Configure SIM for ADC hw trigger source selection
SIM_HAL_SetAdcAlternativeTriggerCmd(gSimBase[0], adcInstance, true);
SIM_HAL_SetAdcPreTriggerMode(gSimBase[0], adcInstance, kSimAdcPretrgselA);
SIM_HAL_SetAdcTriggerMode(gSimBase[0], adcInstance, kSimAdcTrgSelLptimer);
}
/*!
* @Brief disable the trigger source
*/
void deinit_trigger_source(uint32_t adcInstance)
{
LPTMR_DRV_Stop(0);
LPTMR_DRV_Deinit(0);
}
void Application()
{
uint32_t minutes=0, hours=0, samples=0, arrayIndex=0;
static state_t currentState = RECEIVE_CONFIG;
static uint32_t sendPeriodHours, samplesPerHour,minutesLeaveIdle;
static uint32_t distanceSamplesArray[MAX_ALLOWED_SEND_PERIOD_HOURS];
static message_t messageType = SAMPLES;
static uint16_t distance;
static uint8_t HTTP_BUFFER[256];
static float temperature;
static SIM800L_error_t exitCode;
static MMA8451_state_t boardState;
uint8_t fullAlarmSent = 0, fireAlarmSent = 0, fallAlarmSent = 0;
while(1)
{
switch(currentState)
{
case RECEIVE_CONFIG:
RECEIVE_CONFIG_TASK(&sendPeriodHours,&samplesPerHour,&minutesLeaveIdle);
currentState = IDLE;
break;
case IDLE:
LPTMR_DRV_SetTimerPeriodUs(LPTMR_0_IDX,LPTMR_INTERRUPT_PERIOD_US);
LPTMR_DRV_Start(LPTMR_0_IDX);
CONSOLE_INIT();
CONSOLE_SEND("TO IDLE...\r\n",12);
/*PROCESSOR IN LOW POWER MODE*/
POWER_SYS_SetWakeupModule(kLlwuWakeupModule0,true);
if( POWER_SYS_SetMode(1,kPowerManagerPolicyAgreement) != kPowerManagerSuccess)
{
GPIO_DRV_ClearPinOutput(LEDRGB_RED);
}
/*AFTER LLWU INTERRUPT*/
GPIO_DRV_TogglePinOutput(LEDRGB_BLUE);
minutes++;
currentState = MEASURE_TEMPERATURE;
break;
case MEASURE_TEMPERATURE: /*EVERY MINUTE*/
LM35_INIT();
temperature = LM35_GET_TEMPERATURE_CELSIUS();
LM35_DEINIT();
MMA8451Q_INIT();
/*TIME TO MEASURE DISTANCE*/
if(minutes == minutesLeaveIdle)
{
minutes=0;
currentState = MEASURE_DISTANCE;
}
else
{
currentState = IDLE;
}
/*CONTAINER FALL*/
if ( (boardState = MMA8451_GET_STATE(MMA8451_VERTICAL)) == MMA8451_FALL)
{
if(!fallAlarmSent)
{
messageType = FALL_ALARM;
currentState = SEND_DATA;
}
}
else
{
/*CONTAINER AGAIN IN ITS RIGHT PLACE*/
if(fallAlarmSent)
{
fallAlarmSent = 0;
}
}
/*EXTREME CASE: SET FIRE ALARM*/
if(temperature > TEMPERATURE_THRESHOLD)
{
if(!fireAlarmSent)
{
messageType = FIRE_ALARM;
currentState = SEND_DATA;
}
}
else
{ /*TEMPERATURE WENT DOWN*/
if(fireAlarmSent)
{
fireAlarmSent = 0;
}
}
break;
case MEASURE_DISTANCE:
MB7360_INIT();
MB7360_START_RANGING();
distance = MB7360_GET_DISTANCE_MM();
MB7360_DEINIT();
/*ONE HOUR LAPSE*/
if (++samples == samplesPerHour)
{
samples = 0;
distanceSamplesArray[arrayIndex++] = distance;
/*SEND PERIOD HOUR LAPSE: TIME TO SEND DATA*/
if(++hours == sendPeriodHours)
{
hours = 0;
arrayIndex = 0;
LPTMR_DRV_Stop(LPTMR_0_IDX);
messageType = SAMPLES;
currentState = SEND_DATA;
}
else
{
currentState = IDLE;
}
}
else
{
currentState = IDLE;
}
/*EXTREME CASE: SET FULL ALARM*/
if(distance < DISTANCE_THRESHOLD)
{
if(!fullAlarmSent)
{
messageType = FULL_ALARM;
currentState = SEND_DATA;
}
}
else
{ /*COINTAINER EMPTY AGAIN, PREPARE FOR NEXT FULL ALARM*/
if(fullAlarmSent)
{
fullAlarmSent = 0;
}
}
break;
case SEND_DATA:
switch( exitCode = SEND_DATA_GPRS_TASK(messageType, distanceSamplesArray,sendPeriodHours) )
{
case SIM800L_SUCCESS_GPRS:
switch(messageType)
{
case SAMPLES:
CONSOLE_SEND("SAMPLES SENT - GPRS\r\n",21);
break;
case FULL_ALARM:
CONSOLE_SEND("FULL ALARM SENT - GPRS\r\n",24);
fullAlarmSent = 1;
break;
case FIRE_ALARM:
CONSOLE_SEND("FIRE ALARM SENT - GPRS\r\n",24);
fireAlarmSent = 1;
break;
case FALL_ALARM:
CONSOLE_SEND("FALL ALARM SENT - GPRS\r\n",24);
fallAlarmSent = 1;
break;
default:
break;
}
break;
case SIM800L_NO_GPRS:
switch( exitCode = SEND_DATA_SMS_TASK(messageType, distanceSamplesArray,sendPeriodHours))
{
case SIM800L_SUCCESS_SMS:
switch(messageType)
{
case SAMPLES:
CONSOLE_SEND("SAMPLES SENT - SMS\r\n",2);
break;
case FULL_ALARM:
CONSOLE_SEND("FULL ALARM SENT - SMS\r\n",23);
fullAlarmSent = 1;
break;
case FIRE_ALARM:
CONSOLE_SEND("FIRE ALARM SENT - SMS\r\n",23);
fireAlarmSent = 1;
break;
case FALL_ALARM:
CONSOLE_SEND("FALL ALARM SENT - SMS\r\n",23);
fallAlarmSent = 1;
break;
default:
break;
}
break;
default:
CONSOLE_SEND("COULD NOT SEND SMS\r\n",20);
break;
}
break;
/*NO GPRS OR SMS*/
default:
CONSOLE_SEND("COULD NOT SEND DATA\r\n",21);
break;
}
currentState = IDLE;
break;
default:
break;
}
}
}
/*!
* @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
}
}
