// Power off gsm modem
void turn_off_modem_pwr_physical(void)
{
GPIO_DRV_SetPinOutput(SIM808_PWRKEY);
vTaskDelay(1200 / portTICK_RATE_MS);
GPIO_DRV_ClearPinOutput(SIM808_PWRKEY);
vTaskDelay(400 / portTICK_RATE_MS);
// GPIO_DRV_ClearPinOutput(SIM808_PWRKEY);
GPIO_DRV_ClearPinOutput(SIM808_RESET);
}
/**
* set BLE_RST pin to 0 and then release it
*/
void power_ResetKW40()
{
GPIO_DRV_ClearPinOutput( KW40_RST );
OSA_TimeDelay( 10 );
GPIO_DRV_SetPinOutput( KW40_RST );
OSA_TimeDelay( 200 );
}
void MicoRfLed(bool onoff)
{
if (onoff) {
GPIO_DRV_ClearPinOutput(kGpioLED2);
} else {
GPIO_DRV_SetPinOutput(kGpioLED2);
}
}
// Reset gsm modem
void reset_gsm_modem(void)
{
// Reset GSM module min 105mS delay
GPIO_DRV_ClearPinOutput(SIM808_RESET);
vTaskDelay(200 / portTICK_RATE_MS);
GPIO_DRV_SetPinOutput(SIM808_RESET);
vTaskDelay(1000 / portTICK_RATE_MS);
}
/**
* turn the screen off by sending the command
* and turning off the power supply
*/
void power_TurnScreenOFF()
{
if ( true == isPowerActive_OLED )
{
while ( OLED_STATUS_SUCCESS != OLED_SendCmd( OLED_CMD_DISPLAYOFF, FIRST_BYTE ) ) {}
PWR_OLED_TurnOFF();
GPIO_DRV_ClearPinOutput( KW40_GPIO );
}
}
void PORTD_IRQHandler(void)
{
PORT_HAL_ClearPortIntFlag(PORTD_BASE_PTR);
if(haptic_MutexLock(0) == kStatus_OSA_Success)
{
GPIO_DRV_ClearPinOutput( KW40_GPIO );
OSA_TimeDelay(1);
GPIO_DRV_SetPinOutput( KW40_GPIO );
haptic_MutexUnlock();
}
}
/*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 */
/*** Processor Expert internal initialization. DON'T REMOVE THIS CODE!!! ***/
PE_low_level_init();
/*** End of Processor Expert internal initialization. ***/
/* Write your code here */
/* For example: for(;;) { } */
for(;;){
GPIO_DRV_ClearPinOutput(RGB_RedLed); // On Red Led
OSA_TimeDelay(300);
GPIO_DRV_ClearPinOutput(RGB_GreenLed); // On Green Led
OSA_TimeDelay(300);
GPIO_DRV_ClearPinOutput(RGB_BlueLed); // On Blue Led
OSA_TimeDelay(300);
GPIO_DRV_SetPinOutput(RGB_RedLed); // Off Red Led
OSA_TimeDelay(300);
GPIO_DRV_SetPinOutput(RGB_GreenLed); // Off Green Led
OSA_TimeDelay(300);
GPIO_DRV_SetPinOutput(RGB_BlueLed); // Off Blue Led
OSA_TimeDelay(300);
}
/*** 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!!! ***/
static void AppTaskStart (void *p_arg)
{
OS_ERR err;
CPU_ERR cpu_err;
uint32_t value;
static uint32_t pulse_flag = 0;
CPU_TS64 before, after;
char tmp[80];
(void)p_arg;
CPU_Init();
Mem_Init();
Math_Init();
BSP_Ser_Init(115200u);
while (DEF_ON) {
GPIO_DRV_TogglePinOutput( outPTB23 );
value = GPIO_DRV_ReadPinInput( inPTB9 );
if( value ){
if(pulse_flag == 0)
before = CPU_TS_Get64(); // in cpu_cfg.h must set: #define CPU_CFG_TS_64_EN DEF_ENABLED
pulse_flag = 1;
GPIO_DRV_ClearPinOutput( BOARD_GPIO_LED_BLUE );
}
else{
GPIO_DRV_SetPinOutput( BOARD_GPIO_LED_BLUE );
if(pulse_flag == 1)
{
after = CPU_TS_Get64(); // see comment above
sprintf( tmp, "Elapsed time in Task R = %f s\n\r", (float)((1.0*(after-before))/CPU_TS_TmrFreqGet( &cpu_err )) );
APP_TRACE_DBG(( tmp ));
}
pulse_flag = 0;
}
OSTimeDlyHMSM(0u, 0u, 0u, 200u, OS_OPT_TIME_HMSM_STRICT, &err);
}
}
/*FUNCTION**********************************************************************
*
* Function Name : SMARTCARD_DRV_NCN8025Deactivate
* Description : De-activates the smartcard interface
*
*END**************************************************************************/
void SMARTCARD_DRV_NCN8025Deactivate(uint32_t instance)
{
assert(instance < HW_SMARTCARD_INSTANCE_COUNT);
smartcard_state_t * smartcardStatePtr = (smartcard_state_t *)g_smartcardStatePtr[instance];
smartcard_interface_slot_t * interfaceSlotParams = (smartcard_interface_slot_t *)(smartcardStatePtr->interfaceState->slot[smartcardStatePtr->interfaceConfig.cardSoltNo]);
#if defined(EMVSIM_INSTANCE_COUNT)
EMVSIM_Type * base = g_emvsimBase[instance];
#endif
/*Tell PHY to start Deactivation sequence by pulling CMD high*/
#if defined(EMVSIM_INSTANCE_COUNT)
EMVSIM_HAL_ResetCard(base, kEmvsimResetAssert);
EMVSIM_HAL_SetVCCEnable(base, true);
EMVSIM_HAL_SetCardVCCEnablePolarity(base, kEmvsimVccEnIsHigh);
#else
GPIO_DRV_SetPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.controlPort, (uint32_t)smartcardStatePtr->interfaceConfig.controlPin));
GPIO_DRV_ClearPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.resetPort, (uint32_t)smartcardStatePtr->interfaceConfig.resetPin));
#endif
/* here the card was deactivated */
interfaceSlotParams->active = false;
}
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;
}
}
}
/*FUNCTION**********************************************************************
*
* Function Name : SMARTCARD_DRV_NCN8025Activate
* Description : Activates the smartcard interface
*
*END**************************************************************************/
void SMARTCARD_DRV_NCN8025Activate(uint32_t instance, smartcard_reset_type_t resetType)
{
assert(instance < HW_SMARTCARD_INSTANCE_COUNT);
smartcard_state_t * smartcardStatePtr = (smartcard_state_t *)g_smartcardStatePtr[instance];
smartcard_interface_slot_t * interfaceSlotParams = (smartcard_interface_slot_t *)(smartcardStatePtr->interfaceState->slot[smartcardStatePtr->interfaceConfig.cardSoltNo]);
#if defined(EMVSIM_INSTANCE_COUNT)
EMVSIM_Type * base = g_emvsimBase[instance];
#else
uint32_t temp;
UART_Type * base = g_uartBase[instance];
#endif
smartcardStatePtr->timersState.initCharTimerExpired = false;
smartcardStatePtr->resetType = resetType;
/* Set data convention format into default direct mode */
#if defined(EMVSIM_INSTANCE_COUNT)
smartcardStatePtr->cardParams.Fi = 372;
smartcardStatePtr->cardParams.currentD = 1;
EMVSIM_HAL_SetControl(base, kEmvsimCtrlInverseConvention, false);
EMVSIM_HAL_SetBaudrateDivisor(base, (smartcardStatePtr->cardParams.Fi / smartcardStatePtr->cardParams.currentD));
#else
UART_BWR_S2_RXINV(base, 0);
UART_BWR_S2_MSBF(base, 0);
UART_BWR_C3_TXINV(base, 0);
#endif
if(resetType == kSmartcardColdReset)
{
/* Ensure that RST is LOW and CMD is high here so that PHY goes in normal mode */
#if defined(EMVSIM_INSTANCE_COUNT)
EMVSIM_HAL_SetVCCEnable(base, true);
EMVSIM_HAL_SetCardVCCEnablePolarity(base, kEmvsimVccEnIsHigh);
EMVSIM_HAL_ResetCard(base, kEmvsimResetAssert);
#else
GPIO_DRV_ClearPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.resetPort, (uint32_t)smartcardStatePtr->interfaceConfig.resetPin));
GPIO_DRV_SetPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.controlPort, (uint32_t)smartcardStatePtr->interfaceConfig.controlPin));
#endif
if (smartcardStatePtr->cardParams.vcc == kSmartcardVoltageClassA5_0V)
{
/* vcc = 5v: vsel0=0,vsel1= 1 */
GPIO_DRV_SetPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.vsel1Port, (uint32_t)smartcardStatePtr->interfaceConfig.vsel1Pin));
GPIO_DRV_ClearPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.vsel0Port, (uint32_t)smartcardStatePtr->interfaceConfig.vsel0Pin));
}
else if (smartcardStatePtr->cardParams.vcc == kSmartcardVoltageClassB3_3V)
{
/* vcc = 3.3v: vsel0=x,vsel1= 0 */
GPIO_DRV_ClearPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.vsel1Port, (uint32_t)smartcardStatePtr->interfaceConfig.vsel1Pin));
GPIO_DRV_ClearPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.vsel0Port, (uint32_t)smartcardStatePtr->interfaceConfig.vsel0Pin));
}
else
{
/* vcc = 1.8v: vsel0=1,vsel1= 1 */
GPIO_DRV_SetPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.vsel1Port, (uint32_t)smartcardStatePtr->interfaceConfig.vsel1Pin));
GPIO_DRV_SetPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.vsel0Port, (uint32_t)smartcardStatePtr->interfaceConfig.vsel0Pin));
}
/* Set PHY to start Activation sequence by pulling CMDVCC low */
#if defined(EMVSIM_INSTANCE_COUNT)
EMVSIM_HAL_SetCardVCCEnablePolarity(base, kEmvsimVccEnIsLow);
#else
GPIO_DRV_ClearPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.controlPort, (uint32_t)smartcardStatePtr->interfaceConfig.controlPin));
#endif
/* Wait for sometime as specified by EMV before pulling RST High */
/* As per EMV delay <= 42000 Clock cycles
* as per PHY delay >= 1us
*/
#if defined(EMVSIM_INSTANCE_COUNT)
/* Down counter trigger, and clear any pending counter status flag */
EMVSIM_HAL_SetControl(base, kEmvsimCtrlReceiverEnable, false);
EMVSIM_HAL_ClearTransmitStatus(base, kEmvsimGPCNT1Timeout);
/* Disable counter interrupt */
EMVSIM_HAL_SetIntMode(base, kEmvsimIntGPCnt1, false);
/* Set counter value */
EMVSIM_HAL_SetGPCNTValue(base, 1, interfaceSlotParams->clockToResetDelay);
/* Select the clock for GPCNT */
EMVSIM_HAL_SetGPCClockSelect(base, 1, kEmvsimGPCCardClock);
/* Trigger the counter */
EMVSIM_HAL_SetControl(base, kEmvsimCtrlReceiverEnable, true);
/* In polling mode */
while(!EMVSIM_HAL_GetTransmitStatus(base, kEmvsimGPCNT1Timeout))
{}
/* Disable the counter */
EMVSIM_HAL_SetGPCClockSelect(base, 1, kEmvsimGPCClockDisable);
/* Down counter trigger, and clear any pending counter status flag */
EMVSIM_HAL_SetControl(base, kEmvsimCtrlReceiverEnable, false);
EMVSIM_HAL_ClearTransmitStatus(base, kEmvsimGPCNT1Timeout);
#else
temp = (uint32_t)((float)(1 + (float)(((float)(1000*interfaceSlotParams->clockToResetDelay)) / ((float)smartcardStatePtr->interfaceConfig.sCClock))));
OSA_TimeDelay(temp);
#endif
/* Pull reset HIGH Now to mark the end of Activation sequence */
#if defined(EMVSIM_INSTANCE_COUNT)
EMVSIM_HAL_ResetCard(base, kEmvsimResetDeassert);
#else
GPIO_DRV_SetPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.resetPort, (uint32_t)smartcardStatePtr->interfaceConfig.resetPin));
#endif
}
else if(resetType == kSmartcardWarmReset)
{
/* Ensure that card is not already active */
if(!interfaceSlotParams->active)
{
/* Card is not active;hence return */
return;
}
/* Pull RESET low to start warm Activation sequence */
#if defined(EMVSIM_INSTANCE_COUNT)
EMVSIM_HAL_ResetCard(base, kEmvsimResetAssert);
#else
GPIO_DRV_ClearPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.resetPort, (uint32_t)smartcardStatePtr->interfaceConfig.resetPin));
#endif
/* Wait for sometime as specified by EMV before pulling RST High */
/* As per EMV delay <= 42000 Clock cycles
* as per PHY delay >= 1us
*/
#if defined(EMVSIM_INSTANCE_COUNT)
/* Down counter trigger, and clear any pending counter status flag */
EMVSIM_HAL_SetControl(base, kEmvsimCtrlReceiverEnable, false);
EMVSIM_HAL_ClearTransmitStatus(base, kEmvsimGPCNT1Timeout);
/* Disable counter interrupt */
EMVSIM_HAL_SetIntMode(base, kEmvsimIntGPCnt1, false);
/* Set counter value */
EMVSIM_HAL_SetGPCNTValue(base, 1, interfaceSlotParams->clockToResetDelay);
/* Select the clock for GPCNT */
EMVSIM_HAL_SetGPCClockSelect(base, 1, kEmvsimGPCCardClock);
/* Trigger the counter */
EMVSIM_HAL_SetControl(base, kEmvsimCtrlReceiverEnable, true);
/* In polling mode */
while(!EMVSIM_HAL_GetTransmitStatus(base, kEmvsimGPCNT1Timeout))
{}
/* Disable the counter */
EMVSIM_HAL_SetGPCClockSelect(base, 1, kEmvsimGPCClockDisable);
/* Down counter trigger, and clear any pending counter status flag */
EMVSIM_HAL_SetControl(base, kEmvsimCtrlReceiverEnable, false);
EMVSIM_HAL_ClearTransmitStatus(base, kEmvsimGPCNT1Timeout);
#else
temp = (uint32_t)((float)(1 + (float)(((float)(1000*interfaceSlotParams->clockToResetDelay)) / ((float)smartcardStatePtr->interfaceConfig.sCClock))));
OSA_TimeDelay(temp);
#endif
/* Pull reset HIGH to mark the end of Activation sequence*/
#if defined(EMVSIM_INSTANCE_COUNT)
EMVSIM_HAL_ResetCard(base, kEmvsimResetDeassert);
#else
GPIO_DRV_SetPinOutput(GPIO_MAKE_PIN((uint32_t)smartcardStatePtr->interfaceConfig.resetPort, (uint32_t)smartcardStatePtr->interfaceConfig.resetPin));
#endif
}
#if defined(EMVSIM_INSTANCE_COUNT)
/* Down counter trigger, and clear any pending counter status flag */
EMVSIM_HAL_SetControl(base, kEmvsimCtrlReceiverEnable, false);
EMVSIM_HAL_ClearTransmitStatus(base, kEmvsimGPCNT0Timeout);
EMVSIM_HAL_ClearTransmitStatus(base, kEmvsimGPCNT1Timeout);
/* Set counter value for TS detection delay */
EMVSIM_HAL_SetGPCNTValue(base, 0, (INIT_DELAY_CLOCK_CYCLES + INIT_DELAY_CLOCK_CYCLES_ADJUSTMENT));
/* Pre-load counter value for ATR duration delay */
EMVSIM_HAL_SetGPCNTValue(base, 1, (EMV_ATR_DURATION_ETU + ATR_DURATION_ADJUSTMENT));
/* Select the clock for GPCNT for both TS detection and early start of ATR duration counter */
EMVSIM_HAL_SetGPCClockSelect(base, 0, kEmvsimGPCCardClock);
EMVSIM_HAL_SetGPCClockSelect(base, 1, kEmvsimGPCTxClock);
/* Enable counter interrupt for TS detection */
EMVSIM_HAL_SetIntMode(base, kEmvsimIntGPCnt0, true);
/* Trigger the counter */
EMVSIM_HAL_SetControl(base, kEmvsimCtrlReceiverEnable, true);
#endif
/* Here the card was activated */
interfaceSlotParams->active = true;
}
static void LED_turnon_slave(void)
{
GPIO_DRV_ClearPinOutput(kGpioLED2);
}
