/**************************************************************************************************
* @fn main
*
* @brief ISR for the reset vector.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
**************************************************************************************************
*/
void main(void)
{
sblInit();
if (sbImgValid())
{
if (sblWait())
{
HalUARTUnInitUSB();
// Simulate a reset for the Application code by an absolute jump to location 0x2000.
asm("LJMP 0x2000\n");
HAL_SYSTEM_RESET();
}
}
sblExec();
HAL_SYSTEM_RESET();
}
/**************************************************************************************************
* @fn sblPoll
*
* @brief Serial Boot poll & parse according to the RPC protocol.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return TRUE if the downloaded code has been enabled; FALSE otherwise.
*/
uint8 sblPoll(void)
{
uint8 ch;
while (HalUARTRead(0, &ch, 1))
{
switch (rpcSte)
{
case rpcSteSOF:
if (RPC_UART_SOF == ch)
{
rpcSte = rpcSteLen;
}
break;
case rpcSteLen:
if (ch > SBL_MAX_SIZE)
{
rpcSte = rpcSteSOF;
break;
}
else
{
rpcSte = rpcSteData;
sbFcs = sbIdx = 0;
sbLen = ch + 3; // Combine the parsing of Len, Cmd0 & Cmd1 with the data.
// no break;
}
case rpcSteData:
sbFcs ^= ch;
sbBuf[sbIdx] = ch;
if (++sbIdx == sbLen)
{
rpcSte = rpcSteFcs;
}
break;
case rpcSteFcs:
rpcSte = rpcSteSOF;
if ((sbFcs == ch) && ((sbBuf[RPC_POS_CMD0] & RPC_SUBSYSTEM_MASK) == RPC_SYS_BOOT))
{
sblProc();
return sblResp(); // Send the SB response setup in the sbBuf passed to sblProc().
}
break;
default:
HAL_SYSTEM_RESET();
break;
}
}
return FALSE;
}
/*********************************************************************
* @fn SimpleBLEPeripheral_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 SimpleBLEPeripheral_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( simpleBLEPeripheral_TaskID )) != NULL )
{
simpleBLEPeripheral_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & SBP_START_DEVICE_EVT )
{
P0_7 = 0; //防止继电器跳变，初始化为高
P0DIR |= BV(7); //设置为输出
P0SEL &=~BV(7); //设置该脚为普通GPIO
//HCI_EXT_SetTxPowerCmd (HCI_EXT_TX_POWER_MINUS_23_DBM);
// Start the Device
VOID GAPRole_StartDevice( &simpleBLEPeripheral_PeripheralCBs );
// Start Bond Manager
VOID GAPBondMgr_Register( &simpleBLEPeripheral_BondMgrCBs );
return ( events ^ SBP_START_DEVICE_EVT );
}
if ( events & SBP_PERIODIC_EVT )
{
//成功写入后，重启从机
HAL_SYSTEM_RESET();
return (events ^ SBP_PERIODIC_EVT);
}
#if defined ( PLUS_BROADCASTER )
if ( events & SBP_ADV_IN_CONNECTION_EVT )
{
uint8 turnOnAdv = TRUE;
// Turn on advertising while in a connection
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &turnOnAdv );
return (events ^ SBP_ADV_IN_CONNECTION_EVT);
}
#endif // PLUS_BROADCASTER
// Discard unknown events
return 0;
}
/**************************************************************************************************
* @fn halAssertHandler
*
* @brief Logic to handle an assert.
*
* @param none
*
* @return none
**************************************************************************************************
*/
void halAssertHandler(void)
{
/* execute code that handles asserts */
#ifdef ASSERT_RESET
HAL_SYSTEM_RESET();
#else
halAssertHazardLights();
#endif
}
/**************************************************************************************************
* @fn sblJump
*
* @brief Execute a simple long jump from non-banked SBL code to non-banked RC code space.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
*/
static void sblJump(void)
{
SB_TURN_ON_LED1();
SB_TURN_ON_LED2();
while (SB1_PRESS || SB2_PRESS);
SB_TURN_OFF_LED1();
SB_TURN_OFF_LED2();
asm("LJMP 0x2000\n"); // Immediate jump to run-code.
HAL_SYSTEM_RESET();
}
/**************************************************************************************************
* @fn halAssertHandler
*
* @brief Logic to handle an assert.
*
* @param none
*
* @return none
**************************************************************************************************
*/
void halAssertHandler(void)
{
/* execute code that handles asserts */
#ifdef ASSERT_RESET
HAL_SYSTEM_RESET();
#elif !defined ASSERT_WHILE
halAssertHazardLights();
#else
while(1);
#endif
}
/**************************************************************************************************
* @fn main
*
* @brief C-code main function.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
**************************************************************************************************
*/
void main(void)
{
uint16 crc[2];
// Prefer to run Image-B over Image-A so that Image-A does not have to invalidate itself.
HalFlashRead(BIM_IMG_B_PAGE, BIM_CRC_OSET, (uint8 *)crc, 4);
if ((crc[0] != 0xFFFF) && (crc[0] != 0x0000))
{
if (crc[0] == crc[1])
{
JumpToImageAorB = 1;
// Simulate a reset for the Application code by an absolute jump to the expected INTVEC addr.
asm("LJMP 0x4030");
HAL_SYSTEM_RESET(); // Should not get here.
}
crcCheck(BIM_IMG_B_PAGE, crc);
}
HalFlashRead(BIM_IMG_A_PAGE, BIM_CRC_OSET, (uint8 *)crc, 4);
if ((crc[0] != 0xFFFF) && (crc[0] != 0x0000))
{
if (crc[0] == crc[1])
{
JumpToImageAorB = 0;
// Simulate a reset for the Application code by an absolute jump to the expected INTVEC addr.
asm("LJMP 0x0830");
HAL_SYSTEM_RESET(); // Should not get here.
}
else if (crc[1] == 0xFFFF) // If first run of an image that was physically downloaded.
{
crcCheck(BIM_IMG_A_PAGE, crc);
}
}
SLEEPCMD |= 0x03; // PM3, All clock oscillators off, voltage regulator off.
halSleepExec();
HAL_SYSTEM_RESET(); // Should not get here.
}
static void imgRun(uint8 imgSelect)
{
// Simulate a reset for the Application code by an absolute jump to the expected INTVEC addr.
if ((JumpToImageAorB = imgSelect) == 0)
{
asm("LJMP 0x0830");
}
else
{
asm("LJMP 0x4030");
}
HAL_SYSTEM_RESET(); // Should not get here.
}
/**************************************************************************************************
* @fn halAssertHandler
*
* @brief Logic to handle an assert.
*
* @param none
*
* @return none
**************************************************************************************************
*/
void halAssertHandler( void )
{
#if defined( HAL_ASSERT_RESET )
HAL_SYSTEM_RESET();
#elif defined ( HAL_ASSERT_LIGHTS )
halAssertHazardLights();
#elif defined( HAL_ASSERT_SPIN )
volatile uint8 i = 1;
HAL_DISABLE_INTERRUPTS();
while(i);
#endif
return;
}
/**************************************************************************************************
* @fn crcCheck
*
* @brief Calculate the image CRC and set it ready-to-run if it is good.
*
* input parameters
*
* @param page - Flash page on which to beging the CRC calculation.
*
* output parameters
*
* None.
*
* @return None, but no return from this function if the CRC check is good.
**************************************************************************************************
*/
static void crcCheck(uint8 page, uint16 *crc)
{
HAL_BOARD_INIT();
if (crc[0] == crcCalcDMA(page))
{
//P0_0 = 0;
uint16 addr = page * (HAL_FLASH_PAGE_SIZE / HAL_FLASH_WORD_SIZE) +
BIM_CRC_OSET / HAL_FLASH_WORD_SIZE;
crc[1] = crc[0];
crc[0] = 0xFFFF;
HAL_DMA_SET_ADDR_DESC0(&dmaCh0);
HalFlashWrite(addr, (uint8 *)crc, 1);
HAL_SYSTEM_RESET();
}
}
void tcp_reset_ip_addr(uint8 len, uint8 * newIpAddr)
{
if (IPADDR_LEN != len)
{
return;
}
memcpy(ipAddr, newIpAddr, IPADDR_LEN);
nv_write_ipaddr(ipAddr);
tpc_app_init();
HAL_SYSTEM_RESET();
return;
}
/*********************************************************************
* @fn DualImageConcept_handleKeys
*
* @brief Handles all key events for this device.
*
* @param shift - true if in shift/alt.
* @param keys - bit field for key events. Valid entries:
* HAL_KEY_SW_2
* HAL_KEY_SW_1
*
* @return none
*/
static void DualImageConcept_handleKeys(uint8_t shift, uint8_t keys)
{
(void)shift; // Intentionally unreferenced parameter
if (keys & DIC_SWITCH_IMAGE_BUTTON)
{
// Increment and write shared data
sharedData++;
osal_snv_write(NV_ID_SHARED_DATA, sizeof(uint8_t), &sharedData);
// Signal a change in images to run.
switchImage();
// Reset.
HAL_SYSTEM_RESET();
// Should never get here.
}
}
void lock_init(void)
{
uint8 read_tmp[6] = {0};
uint8 use_lock_times[2] = {0};
uint8 ret8;
osal_memset(read_tmp, '0', sizeof(read_tmp));
ret8 = osal_snv_write(admin_flash_start_addr, sizeof(read_tmp), read_tmp);
if(ret8 == NV_OPER_FAILED)
return;
osal_memset(read_tmp, '1', sizeof(read_tmp));
ret8 = osal_snv_write(user_flash_start_addr, sizeof(read_tmp), read_tmp);
if(ret8 == NV_OPER_FAILED)
return;
osal_memcpy(read_tmp, ssid, 6);
ret8 = osal_snv_write(ssid_flash_start_addr, sizeof(read_tmp), read_tmp);
if(ret8 == NV_OPER_FAILED)
return;
osal_memcpy(scanRspData + 2, read_tmp, 6);
osal_memcpy(attDeviceName, read_tmp, 6);
GAP_UpdateAdvertisingData( simpleBLEPeripheral_TaskID, FALSE, sizeof( scanRspData ), scanRspData );
GGS_SetParameter( GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, attDeviceName );
osal_memset(read_tmp, '0', sizeof(read_tmp));
ret8 = osal_snv_write(dead_date_flash_start_addr, sizeof(read_tmp), read_tmp);
if(ret8 == NV_OPER_FAILED)
return;
osal_memset(read_tmp, '0', sizeof(read_tmp));
ret8 = osal_snv_write(carlock_id_flash_start_addr, sizeof(read_tmp), read_tmp);
if(ret8 == NV_OPER_FAILED)
return;
osal_memset(use_lock_times, 0, sizeof(use_lock_times));
ret8 = osal_snv_write(use_lock_times_start_addr, sizeof(use_lock_times), use_lock_times);
if(ret8 == NV_OPER_FAILED)
return;
HAL_SYSTEM_RESET();//reset
}
/**************************************************************************************************
* @fn main
*
* @brief C-code main functionality.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
**************************************************************************************************
*/
void main(void)
{
/* Setup the clock startup sequence to 32 MHz external
* osc and 32k sourced from external oscillator
*/
IOCPadConfigSet(GPIO_D_BASE, 0xC0, IOC_OVERRIDE_ANA);
SysCtrlClockSet(OSC_32KHZ, false, SYS_CTRL_SYSDIV_32MHZ);
/* Check if clock is stable */
HAL_CLOCK_STABLE();
/* Turn on cache prefetch mode */
PREFETCH_ENABLE();
/* Boot Loader code execute */
sblExec();
/* Code should not come here */
HAL_SYSTEM_RESET();
}
/**************************************************************************************************
* @fn main
*
* @brief C-code main function.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
**************************************************************************************************
*/
void main(void)
{
vddWait();
HAL_BOARD_INIT();
/* This is in place of calling HalDmaInit() which would require init of the other 4 DMA
* descriptors in addition to just Channel 0.
*/
HAL_DMA_SET_ADDR_DESC0(&dmaCh0);
// Map flash bank #7 into XDATA for access to "ROM mapped as data".
MEMCTR = (MEMCTR & 0xF8) | 0x07;
imgSelect(); // Attempt to select and run an image.
SLEEPCMD |= 0x03; // PM3, All clock oscillators off, voltage regulator off.
halSleepExec();
HAL_SYSTEM_RESET(); // Should not get here.
}
/**************************************************************************************************
* @fn appForceBoot
*
* @brief Force the boot loader to run.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
*/
void appForceBoot(void)
{
uint16 crc[2];
SBL_NVM_GET(SBL_ADDR_CRC, crc, sizeof(crc));
// A simple check if the image is built for a boot loader is a valid CRC & shadow where expected.
if ((crc[0] == 0xFFFF) || (crc[0] == 0x0000) ||
(crc[1] == 0xFFFF) || (crc[1] == 0x0000) ||
(crc[1] != crc[0]))
{
return;
}
HAL_DISABLE_INTERRUPTS();
crc[0] ^= 0xFFFF; // Only write to zero bits that are not already zero.
crc[1] = 0xFFFF; // No need to write any bits to zero.
SBL_NVM_SET(SBL_ADDR_CRC, crc, sizeof(crc));
HAL_SYSTEM_RESET();
}
/**************************************************************************************************
* @fn sblRun
*
* @brief Serial Boot run code for the UART transport.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
*/
static void sblRun(void)
{
uint8 resetF = 0;
uartInit();
while (1)
{
if (txLen == 0)
{
if ((resetF != 0) && ((UxCSR & CSR_ACTIVE) == 0)) // If the last Tx byte has flushed out.
{
HAL_SYSTEM_RESET();
}
}
else if (UxCSR & CSR_TX_BYTE)
{
UxCSR &= ~CSR_TX_BYTE;
UxDBUF = pTxBuf[txIdx];
if (++txIdx == txLen)
{
txLen = 0;
}
}
#if defined POWER_SAVING
else if (!HAL_UART_SBL_RDY_IN())
{
// Master may have timed-out the SRDY asserted state & may need a new edge.
HAL_UART_SBL_CLR_RDY_OUT();
ASM_NOP; ASM_NOP; ASM_NOP; ASM_NOP;
HAL_UART_SBL_SET_RDY_OUT();
}
#endif
if (UxCSR & CSR_RX_BYTE)
{
resetF |= sblPoll();
}
}
}
/**************************************************************************************************
* @fn appForceBoot
*
* @brief Force the boot loader to run.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
*/
void appForceBoot(void)
{
uint16 crc[2];
// Make sure SBL is present.
HalFlashRead(UBL_PAGE_FIRST, UBL_MD_PG_OFFSET, (uint8 *)crc, 4);
if ((crc[0] == 0xFFFF) || (crc[0] == 0x0000) ||
(crc[1] == 0xFFFF) || (crc[1] == 0x0000) ||
(crc[1] != crc[0]))
{
return;
}
HAL_DISABLE_INTERRUPTS();
crc[1] ^= 0xFFFF; // Only write to zero bits that are not already zero.
crc[0] = 0xFFFF;
HalFlashWrite(((uint16)&_ublMetaData) / HAL_FLASH_WORD_SIZE, (uint8 *)crc, 1);
HAL_SYSTEM_RESET();
}
/**************************************************************************************************
* @fn main
*
* @brief C-code main functionality.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
**************************************************************************************************
*/
void main(void)
{
vddWait(VDD_MIN_RUN);
HAL_BOARD_INIT();
// make sure the DMA channel is selected before we attempt to
// to write anything to flash.
sblInit();
if (sbImgValid())
{
if ((SB_UART_DELAY == 0) || ResetWasWatchDog)
{
sblJump();
}
sblWait();
}
vddWait(VDD_MIN_NV);
sblExec();
HAL_SYSTEM_RESET();
}
/**************************************************************************************************
* @fn main
*
* @brief This function is the C-main function invoked from the IAR reset ISR handler.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
*/
void main(void)
{
uint32 ledgerPageAddr = FLASH_BASE + (HAL_IBM_LEDGER_PAGE * HAL_FLASH_PAGE_SIZE);
for (int pgCnt = 0; pgCnt < HAL_IBM_LEDGER_PAGE; pgCnt++, ledgerPageAddr -= HAL_FLASH_PAGE_SIZE)
{
ibm_ledger_t *pLedger = (ibm_ledger_t *)ledgerPageAddr;
int ledgerCnt = 0;
if (memcmp(pLedger, &LedgerPageSignature, sizeof(ibm_ledger_t)))
{
continue;
}
for (pLedger++; ledgerCnt < (HAL_FLASH_PAGE_SIZE/sizeof(ibm_ledger_t)); ledgerCnt++, pLedger++)
{
if ( (pLedger->imageCRC[0] == 0xFFFFFFFF) || // Not expected except first 2-step programming.
((pLedger->imageCRC[0] != 0) && (pLedger->imageCRC[0] == pLedger->imageCRC[1])) )
{
// Sanity check NVIC entries.
if ((pLedger->nvicJump[0] > 0x20004000) &&
(pLedger->nvicJump[0] < 0x27007FFF) &&
(pLedger->nvicJump[1] > FLASH_BASE) &&
(pLedger->nvicJump[1] < 0x0027EFFF))
{
EnterNvmApplication(pLedger->nvicJump[0], pLedger->nvicJump[1]);
}
}
}
}
SysCtrlDeepSleepSetting();
HAL_DISABLE_INTERRUPTS();
SysCtrlDeepSleep();
HAL_SYSTEM_RESET();
}
/**************************************************************************************************
* @fn main
*
* @brief C-code main functionality.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
**************************************************************************************************
*/
void main(void)
{
vddWait(VDD_MIN_RUN);
HAL_BOARD_INIT();
if (sbImgValid())
{
if ((SB_UART_DELAY == 0) || ResetWasWatchDog)
{
sblJump();
}
sblInit();
sblWait();
}
else
{
sblInit();
}
vddWait(VDD_MIN_NV);
sblExec();
HAL_SYSTEM_RESET();
}
/*********************************************************************
* @fn OADTarget_systemReset
*
* @brief Prepare system for a reset and trigger a reset to the boot
* image manager.
*
* @param None.
*
* @return None.
*/
void OADTarget_systemReset(void)
{
HAL_SYSTEM_RESET();
}
/*********************************************************************
* @fn oadImgBlockWrite
*
* @brief Process the Image Block Write.
*
* @param connHandle - connection message was received on
* @param pValue - pointer to data to be written
*
* @return status
*/
static bStatus_t oadImgBlockWrite( uint16 connHandle, uint8 *pValue )
{
uint16 blkNum = BUILD_UINT16( pValue[0], pValue[1] );
// make sure this is the image we're expecting
if ( blkNum == 0 )
{
img_hdr_t ImgHdr;
uint16 ver = BUILD_UINT16( pValue[6], pValue[7] );
uint16 blkTot = BUILD_UINT16( pValue[8], pValue[9] ) / (OAD_BLOCK_SIZE / HAL_FLASH_WORD_SIZE);
HalFlashRead(OAD_IMG_R_PAGE, OAD_IMG_HDR_OSET, (uint8 *)&ImgHdr, sizeof(img_hdr_t));
if ( ( oadBlkNum != blkNum ) ||
( oadBlkTot != blkTot ) ||
( OAD_IMG_ID( ImgHdr.ver ) == OAD_IMG_ID( ver ) ) )
{
return ( ATT_ERR_WRITE_NOT_PERMITTED );
}
}
if (oadBlkNum == blkNum)
{
uint16 addr = oadBlkNum * (OAD_BLOCK_SIZE / HAL_FLASH_WORD_SIZE) +
(OAD_IMG_D_PAGE * OAD_FLASH_PAGE_MULT);
oadBlkNum++;
#if defined FEATURE_OAD_SECURE
if (blkNum == 0)
{
// Stop attack with crc0==crc1 by forcing crc1=0xffff.
pValue[4] = 0xFF;
pValue[5] = 0xFF;
}
#endif
#if defined HAL_IMAGE_B
// Skip the Image-B area which lies between the lower & upper Image-A parts.
if (addr >= (OAD_IMG_B_PAGE * OAD_FLASH_PAGE_MULT))
{
addr += OAD_IMG_B_AREA * OAD_FLASH_PAGE_MULT;
}
#endif
if ((addr % OAD_FLASH_PAGE_MULT) == 0)
{
HalFlashErase(addr / OAD_FLASH_PAGE_MULT);
}
HalFlashWrite(addr, pValue+2, (OAD_BLOCK_SIZE / HAL_FLASH_WORD_SIZE));
}
if (oadBlkNum == oadBlkTot) // If the OAD Image is complete.
{
#if defined FEATURE_OAD_SECURE
HAL_SYSTEM_RESET(); // Only the secure OAD boot loader has the security key to decrypt.
#else
if (checkDL())
{
#if !defined HAL_IMAGE_A
// The BIM always checks for a valid Image-B before Image-A,
// so Image-A never has to invalidate itself.
uint16 crc[2] = { 0x0000, 0xFFFF };
uint16 addr = OAD_IMG_R_PAGE * OAD_FLASH_PAGE_MULT + OAD_IMG_CRC_OSET / HAL_FLASH_WORD_SIZE;
HalFlashWrite(addr, (uint8 *)crc, 1);
#endif
HAL_SYSTEM_RESET();
}
#endif
}
else // Request the next OAD Image block.
{
oadImgBlockReq(connHandle, oadBlkNum);
}
return ( SUCCESS );
}
/***************************************************************************************************
* @fn BLE_Reboot
*
* @brief BLE_Reboot
*
* @param None
*
* @return None
***************************************************************************************************/
void BLE_Reboot( void )
{
NPI_PrintValue("reboot all system",0);
HAL_SYSTEM_RESET();
}
uint16 SensorTag_ProcessEvent(uint8 task_id, uint16 events)
{
VOID task_id; // OSAL required parameter that isn't used in this function
///////////////////////////////////////////////////////////////////////
// system event handle //
///////////////////////////////////////////////////////////////////////
if (events & SYS_EVENT_MSG) {
uint8 *msg;
if ((msg = osal_msg_receive(sensorTag_TaskID)) != NULL) {
sensorTag_ProcessOSALMsg((osal_event_hdr_t *) msg);
// release the OSAL message
osal_msg_deallocate(msg);
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
///////////////////////////////////////////////////////////////////////
// start device event //
///////////////////////////////////////////////////////////////////////
if (events & EVT_START_DEVICE) {
// start the device
GAPRole_StartDevice(&sensorTag_PeripheralCBs);
// start bond manager
#if !defined(GAPBONDMGR_NO_SUPPORT)
GAPBondMgr_Register(&sensorTag_BondMgrCBs);
#endif
// start peripheral device
oled_init();
adxl345_softrst();
// adxl345_self_calibration();
steps = 0;
BATCD_PXIFG = ~(BATCD_BV);
BATCD_IEN |= BATCD_IENBIT;
osal_start_reload_timer(sensorTag_TaskID, EVT_RTC, PERIOD_RTC);
pwmgr_state_change(PWMGR_S0, 0);
fmsg(("\033[40;32m\n[power on]\033[0m\n"));
return (events ^ EVT_START_DEVICE);
}
///////////////////////////////////////////////////////////////////////
// key long press handle //
///////////////////////////////////////////////////////////////////////
if (events & EVT_MODE) {
if (key1_press) {
oled_clr_screen();
if ((opmode & 0xF0) == MODE_NORMAL) {
opmode = MODE_WORKOUT | MODE_TIME;
workout.steps = normal.steps;
workout.time = osal_getClock();
fmsg(("\033[40;32m[workout mode]\033[0m\n"));
} else {
opmode = MODE_NORMAL | MODE_TIME;
fmsg(("\033[40;32m[normal mode]\033[0m\n"));
}
pwmgr_state_change(pwmgr, TIME_OLED_OFF);
}
return (events ^ EVT_MODE);
}
if (events & EVT_SLEEP) {
if (key1_press) {
oled_clr_screen();
opmode = MODE_SLEEP;
fmsg(("\033[40;32m[sleep mode]\033[0m\n"));
pwmgr_state_change(pwmgr, TIME_OLED_OFF);
}
return (events ^ EVT_SLEEP);
}
if (events & EVT_SYSRST) {
if (key1_press) {
fmsg(("\033[40;32m[system reset]\033[0m\n"));
HAL_SYSTEM_RESET();
// adxl345_self_calibration();
}
return (events ^ EVT_SYSRST);
}
///////////////////////////////////////////////////////////////////////
// display handle //
///////////////////////////////////////////////////////////////////////
if (events & EVT_DISP) {
if (pwmgr == PWMGR_S1) {
sensorTag_HandleDisp(opmode, acc);
} else {
// display battery only
sensorTag_BattDisp(batt_get_level());
}
if (pwmgr != PWMGR_S6) {
osal_start_timerEx(sensorTag_TaskID, EVT_DISP, PERIOD_DISP);
}
return (events ^ EVT_DISP);
}
///////////////////////////////////////////////////////////////////////
// g-sensor handle //
///////////////////////////////////////////////////////////////////////
if (events & EVT_GSNINT1) {
adxl345_exit_sleep();
pwmgr_state_change(PWMGR_S3, TIME_GSEN_OFF);
return (events ^ EVT_GSNINT1);
}
if (events & EVT_GSNINT2) {
unsigned char sampling;
unsigned char i;
sampling = adxl345_chk_fifo();
for (i=0; i<sampling; i++) {
adxl345_read(acc);
#if (DEBUG_MESSAGE & MSG_STEPS)
{
unsigned long tmp = algo_step(acc);
if (normal.steps != tmp) {
stepmsg(("\033[1;33mstep=%0lu\n\033[0m", tmp));
}
normal.steps = tmp;
}
#else
normal.steps = algo_step(acc);
#endif
}
normal.distance = calc_distance(normal.steps, pi.stride);
workout.distance = calc_distance((normal.steps - workout.steps), pi.stride);
normal.calorie = calc_calorie(normal.distance, pi.weight);
workout.calorie = calc_calorie(workout.distance, pi.weight);
return (events ^ EVT_GSNINT2);
}
if (events & EVT_GSENSOR) {
adxl345_exit_sleep();
return (events ^ EVT_GSENSOR);
}
///////////////////////////////////////////////////////////////////////
// RTC handle //
///////////////////////////////////////////////////////////////////////
if (events & EVT_RTC) {
// performed once per second
// record data
if ((pwmgr != PWMGR_S5) && (pwmgr != PWMGR_S6)) {
#if defined(HAL_IMAGE_A) || defined(HAL_IMAGE_B)
if ((osal_getClock() - mark.time) >= (12UL*60UL)) {
#else
if ((osal_getClock() - mark.time) >= (12UL)) {
#endif
if (!hash_is_full()) {
unsigned short tmp = normal.steps - mark.steps;
switch (opmode & 0xF0) {
case MODE_WORKOUT: tmp |= 0x8000; break;
case MODE_SLEEP: tmp |= 0x4000; break;
}
hash_put(&tmp);
}
mark.time = osal_getClock();
#if defined(HAL_IMAGE_A) || defined(HAL_IMAGE_B)
if ((mark.time % (24UL*60UL*60UL)) <= (13UL*60UL)) {
#else
if ((mark.time % (24UL*60UL*60UL)) <= (13UL)) {
#endif
dmsg(("reset steps...\n"));
normal.steps = 0;
workout.steps = 0;
STEPS = 0;
}
mark.steps = normal.steps;
}
}
// power management
switch (pwmgr) {
case PWMGR_S0:
pmsg(("\033[40;35mS0 (power on)\033[0m\n"));
if (pwmgr_saving_timer()) {
adxl345_enter_sleep();
osal_pwrmgr_device(PWRMGR_BATTERY);
pwmgr_state_change(PWMGR_S4, 0);
}
break;
case PWMGR_S1:
pmsg(("\033[40;35mS1 (rtc+gsen+ble+oled)\033[0m\n"));
if (pwmgr_saving_timer()) {
oled_enter_sleep();
osal_stop_timerEx(sensorTag_TaskID, EVT_MODE);
osal_stop_timerEx(sensorTag_TaskID, EVT_SLEEP);
osal_stop_timerEx(sensorTag_TaskID, EVT_SYSRST);
pwmgr_state_change(PWMGR_S3, TIME_GSEN_OFF);
}
break;
case PWMGR_S2:
pmsg(("\033[40;35mS2 (rtc+gsen+ble)\033[0m\n"));
if (gapProfileState == GAPROLE_WAITING) {
// enable key interrupt mode
InitBoard(OB_READY);
pwmgr_state_change(PWMGR_S3, TIME_GSEN_OFF);
}
break;
case PWMGR_S3:
pmsg(("\033[40;35mS3 (rtc+gsen)\033[0m\n"));
if (steps == normal.steps) {
if (pwmgr_saving_timer()) {
adxl345_enter_sleep();
pwmgr_state_change(PWMGR_S4, 0);
}
} else {
steps = normal.steps;
pwmgr_state_change(pwmgr, TIME_GSEN_OFF);
}
break;
case PWMGR_S4:
pmsg(("\033[40;35mS4 (rtc)\033[0m\n"));
dmsg(("$"));
break;
default:
case PWMGR_S5:
pmsg(("\033[40;35mS5 (shutdown)\033[0m\n"));
adxl345_shutdown();
osal_stop_timerEx(sensorTag_TaskID, EVT_RTC);
break;
case PWMGR_S6:
pmsg(("\033[40;35mS6 (rtc+oled)\033[0m\n"));
if (pwmgr_saving_timer()) {
oled_enter_sleep();
// enable key interrupt mode
InitBoard(OB_READY);
pwmgr_state_change(PWMGR_S5, 0);
}
break;
}
// battery measure
if ((!batt_measure()) && (pwmgr != PWMGR_S6)) {
pwmgr_state_change(PWMGR_S5, 0);
}
return (events ^ EVT_RTC);
}
///////////////////////////////////////////////////////////////////////
// battery charge detect handle //
///////////////////////////////////////////////////////////////////////
if (events & EVT_CHARGING) {
if (pwmgr != PWMGR_S1) {
if (!BATCD_SBIT) {
dmsg(("[charging]\n"));
oled_exit_sleep();
if ((pwmgr == PWMGR_S5) || (pwmgr == PWMGR_S6)) {
osal_start_reload_timer(sensorTag_TaskID, EVT_RTC, PERIOD_RTC);
pwmgr_state_change(PWMGR_S4, 0);
}
} else {
dmsg(("[no charge]\n"));
oled_enter_sleep();
}
}
return (events ^ EVT_CHARGING);
}
///////////////////////////////////////////////////////////////////////
// discard unknown events //
///////////////////////////////////////////////////////////////////////
return 0;
}
/*********************************************************************
* @fn simpleProfile_WriteAttrCB
*
* @brief Validate attribute data prior to a write operation
*
* @param connHandle - connection message was received on
* @param pAttr - pointer to attribute
* @param pValue - pointer to data to be written
* @param len - length of data
* @param offset - offset of the first octet to be written
* @param complete - whether this is the last packet
* @param oper - whether to validate and/or write attribute value
*
* @return Success or Failure
*/
static bStatus_t simpleProfile_WriteAttrCB( uint16 connHandle, gattAttribute_t *pAttr,
uint8 *pValue, uint8 len, uint16 offset )
{
bStatus_t status = SUCCESS;
uint8 notifyApp = 0xFF;
// If attribute permissions require authorization to write, return error
if ( gattPermitAuthorWrite( pAttr->permissions ) )
{
// Insufficient authorization
return ( ATT_ERR_INSUFFICIENT_AUTHOR );
}
if ( pAttr->type.len == ATT_BT_UUID_SIZE )
{
// 16-bit UUID
uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]);
switch ( uuid )
{
case SIMPLEPROFILE_CHAR1_UUID:
//Validate the value
// Make sure it's not a blob oper
if ( offset == 0 )
{
if ( len != 16 )
{
status = ATT_ERR_INVALID_VALUE_SIZE;
}
}
else
{
status = ATT_ERR_ATTR_NOT_LONG;
}
//Write the value
if ( status == SUCCESS )
{
uint8 beaconID[] = {
pValue[0],pValue[1],pValue[2],pValue[3],pValue[4],pValue[5],pValue[6],pValue[7],
pValue[8],pValue[9],pValue[10],pValue[11],pValue[12],pValue[13],pValue[14],pValue[15]
};
VOID osal_snv_write(BEACON_ID, BEACON_LEN, &beaconID);
SimpleProfile_SetParameter( SIMPLEPROFILE_CHAR1, SIMPLEPROFILE_CHAR1_LEN, &beaconID );
/*VOID osal_memcpy( pValue, pAttr->pValue, SIMPLEPROFILE_CHAR1_LEN );
if( pAttr->pValue == simpleProfileChar1 )
{
notifyApp = SIMPLEPROFILE_CHAR1;
}*/
}
break;
case SIMPLEPROFILE_CHAR2_UUID:
//Validate the value
// Make sure it's not a blob oper
if ( offset == 0 )
{
if ( len != 4 )
{
status = ATT_ERR_INVALID_VALUE_SIZE;
}
}
else
{
status = ATT_ERR_ATTR_NOT_LONG;
}
//Write the value
if ( status == SUCCESS )
{
uint8 major[] = {
pValue[0],pValue[1],pValue[2],pValue[3],pValue[4],pValue[5],pValue[6],pValue[7],
pValue[8],pValue[9],pValue[10],pValue[11],pValue[12],pValue[13],pValue[14],pValue[15]
};
VOID osal_snv_write(MAJOR_ID, MAJOR_LEN, &major);
SimpleProfile_SetParameter( SIMPLEPROFILE_CHAR2, SIMPLEPROFILE_CHAR2_LEN, &major );
/*VOID osal_memcpy( pValue, pAttr->pValue, SIMPLEPROFILE_CHAR2_LEN );
if( pAttr->pValue == simpleProfileChar2 )
{
notifyApp = SIMPLEPROFILE_CHAR2;
}*/
}
break;
case SIMPLEPROFILE_CHAR3_UUID:
//Validate the value
// Make sure it's not a blob oper
if ( offset == 0 )
{
if ( len != 1 )
{
status = ATT_ERR_INVALID_VALUE_SIZE;
}
}
else
{
status = ATT_ERR_ATTR_NOT_LONG;
}
//Write the value
if ( status == SUCCESS )
{
uint8 power[] = {
pValue[0]
};
VOID osal_snv_write(POWER_ID, POWER_LEN, &power);
}
break;
case SIMPLEPROFILE_CHAR4_UUID:
//Validate the value
// Make sure it's not a blob oper
if ( offset == 0 )
{
if ( len != 1 )
{
status = ATT_ERR_INVALID_VALUE_SIZE;
}
}
else
{
status = ATT_ERR_ATTR_NOT_LONG;
}
//Write the value
if ( status == SUCCESS )
{
if (pValue[0] == 0xFA)
{
HAL_SYSTEM_RESET();
}
}
break;
case GATT_CLIENT_CHAR_CFG_UUID:
status = GATTServApp_ProcessCCCWriteReq( connHandle, pAttr, pValue, len,
offset, GATT_CLIENT_CFG_NOTIFY );
break;
default:
// Should never get here! (characteristics 2 and 4 do not have write permissions)
status = ATT_ERR_ATTR_NOT_FOUND;
break;
}
}
else
{
// 128-bit UUID
status = ATT_ERR_INVALID_HANDLE;
}
// If a charactersitic value changed then callback function to notify application of change
if ( (notifyApp != 0xFF ) && simpleProfile_AppCBs && simpleProfile_AppCBs->pfnSimpleProfileChange )
{
simpleProfile_AppCBs->pfnSimpleProfileChange( notifyApp );
}
return ( status );
}
/*********************************************************************
* @fn OADTarget_imgBlockWrite
*
* @brief Process the Image Block Write.
*
* @param connHandle - connection message was received on
* @param pValue - pointer to data to be written
*
* @return status
*/
bStatus_t OADTarget_imgBlockWrite(uint16_t connHandle, uint8_t *pValue)
{
volatile uint16_t blkNum;
blkNum = BUILD_UINT16(pValue[0], pValue[1]);
// First block of OAD which included image header and CRC and CRC shadow
// values. Do a sanity check on the received image header
if (blkNum == 0)
{
img_hdr_t ImgHdr;
uint16_t blkTot;
blkTot = BUILD_UINT16(pValue[8], pValue[9]) /
(OAD_BLOCK_SIZE / HAL_FLASH_WORD_SIZE);
// Read out running image's header.
uint8_t *flashAddr = (uint8_t *)(APP_IMAGE_START + OAD_IMG_HDR_OSET);
memcpy(&ImgHdr,flashAddr,sizeof(img_hdr_t));
// Note: if additional customer criteria was checked in the Image
// Identification step, it may be important to check again here.
if ((oadBlkNum != blkNum) || (oadBlkTot != blkTot) )
{
// Cancel download
OADTarget_rejectImage(connHandle, &ImgHdr);
// NB! This is meaningless for a WriteNoResp operation
return (ATT_ERR_WRITE_NOT_PERMITTED);
}
#ifdef POWER_SAVING
Power_setConstraint(Power_SB_DISALLOW);
#endif
}
// Check that this is the expected block number.
if (oadBlkNum == blkNum && flashOk)
{
uint32_t addr;
// Calculate address to write as (start of OAD range) + (offset)
addr = APP_IMAGE_START + oadBlkNum * OAD_BLOCK_SIZE;
// If address starts a new page, erase that page first.
if ((addr % HAL_FLASH_PAGE_SIZE) == 0)
{
flashOk = extFlashErase(addr, HAL_FLASH_PAGE_SIZE);
}
// Write a 16 byte block to Flash.
if (flashOk)
{
flashOk = extFlashWrite(addr, OAD_BLOCK_SIZE, pValue+2);
// Increment received block count.
if (flashOk)
oadBlkNum++;
}
// Toggle Green LED for every 8th block
if ( (oadBlkNum % 8) == 0)
{
GPIO_toggle(Board_LED2);
}
}
else
{
img_hdr_t ImgHdr;
// Toggle RED LED and sound buzzer when overflow
GPIO_toggle(Board_LED1);
GPIO_toggle(Board_BUZZER);
#ifdef POWER_SAVING
Power_releaseConstraint(Power_SB_DISALLOW);
#endif
// Cancel download
ImgHdr.len = 0; // Don't care content
OADTarget_rejectImage(connHandle, &ImgHdr);
}
// Check if the OAD Image is complete.
if (oadBlkNum == oadBlkTot)
{
extFlashClose();
// Run CRC check on new image.
if (checkDL())
{
HAL_SYSTEM_RESET();
}
else
{
GPIO_toggle(Board_LED1);
}
#ifdef POWER_SAVING
Power_releaseConstraint(Power_SB_DISALLOW);
#endif
}
else
{
// Request the next OAD Image block.
OADTarget_getNextBlockReq(connHandle, oadBlkNum);
}
return (SUCCESS);
}
/*********************************************************************
* @fn SensorTag_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 SensorTag_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( sensorTag_TaskID )) != NULL )
{
sensorTag_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
// Handle system reset (long press on side key)
if ( events & ST_SYS_RESET_EVT )
{
if (sysResetRequest)
{
HAL_SYSTEM_RESET();
}
return ( events ^ ST_SYS_RESET_EVT );
}
if ( events & ST_START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &sensorTag_PeripheralCBs );
// Start Bond Manager
VOID GAPBondMgr_Register( &sensorTag_BondMgrCBs );
return ( events ^ ST_START_DEVICE_EVT );
}
//////////////////////////
// IR TEMPERATURE //
//////////////////////////
if ( events & ST_IRTEMPERATURE_READ_EVT )
{
if ( irTempEnabled )
{
if (HalIRTempStatus() == TMP006_DATA_READY)
{
readIrTempData();
osal_start_timerEx( sensorTag_TaskID, ST_IRTEMPERATURE_READ_EVT, sensorTmpPeriod-TEMP_MEAS_DELAY );
}
else if (HalIRTempStatus() == TMP006_OFF)
{
HalIRTempTurnOn();
osal_start_timerEx( sensorTag_TaskID, ST_IRTEMPERATURE_READ_EVT, TEMP_MEAS_DELAY );
}
}
else
{
//Turn off Temperatur sensor
VOID HalIRTempTurnOff();
VOID resetCharacteristicValue(IRTEMPERATURE_SERV_UUID,SENSOR_DATA,0,IRTEMPERATURE_DATA_LEN);
VOID resetCharacteristicValue(IRTEMPERATURE_SERV_UUID,SENSOR_CONF,ST_CFG_SENSOR_DISABLE,sizeof ( uint8 ));
}
return (events ^ ST_IRTEMPERATURE_READ_EVT);
}
//////////////////////////
// Accelerometer //
//////////////////////////
if ( events & ST_ACCELEROMETER_SENSOR_EVT )
{
if(accConfig != ST_CFG_SENSOR_DISABLE)
{
readAccData();
osal_start_timerEx( sensorTag_TaskID, ST_ACCELEROMETER_SENSOR_EVT, sensorAccPeriod );
}
else
{
VOID resetCharacteristicValue( ACCELEROMETER_SERV_UUID, SENSOR_DATA, 0, ACCELEROMETER_DATA_LEN );
VOID resetCharacteristicValue( ACCELEROMETER_SERV_UUID, SENSOR_CONF, ST_CFG_SENSOR_DISABLE, sizeof ( uint8 ));
}
return (events ^ ST_ACCELEROMETER_SENSOR_EVT);
}
//////////////////////////
// Humidity //
//////////////////////////
if ( events & ST_HUMIDITY_SENSOR_EVT )
{
if (humiEnabled)
{
HalHumiExecMeasurementStep(humiState);
if (humiState == 2)
{
readHumData();
humiState = 0;
osal_start_timerEx( sensorTag_TaskID, ST_HUMIDITY_SENSOR_EVT, sensorHumPeriod );
}
else
{
humiState++;
osal_start_timerEx( sensorTag_TaskID, ST_HUMIDITY_SENSOR_EVT, HUM_FSM_PERIOD );
}
}
else
{
resetCharacteristicValue( HUMIDITY_SERV_UUID, SENSOR_DATA, 0, HUMIDITY_DATA_LEN);
resetCharacteristicValue( HUMIDITY_SERV_UUID, SENSOR_CONF, ST_CFG_SENSOR_DISABLE, sizeof ( uint8 ));
}
return (events ^ ST_HUMIDITY_SENSOR_EVT);
}
//////////////////////////
// Magnetometer //
//////////////////////////
if ( events & ST_MAGNETOMETER_SENSOR_EVT )
{
if(magEnabled)
{
if (HalMagStatus() == MAG3110_DATA_READY)
{
readMagData();
}
else if (HalMagStatus() == MAG3110_OFF)
{
HalMagTurnOn();
}
osal_start_timerEx( sensorTag_TaskID, ST_MAGNETOMETER_SENSOR_EVT, sensorMagPeriod );
}
else
{
HalMagTurnOff();
resetCharacteristicValue( MAGNETOMETER_SERV_UUID, SENSOR_DATA, 0, MAGNETOMETER_DATA_LEN);
resetCharacteristicValue( MAGNETOMETER_SERV_UUID, SENSOR_CONF, ST_CFG_SENSOR_DISABLE, sizeof ( uint8 ));
}
return (events ^ ST_MAGNETOMETER_SENSOR_EVT);
}
//////////////////////////
// Barometer //
//////////////////////////
if ( events & ST_BAROMETER_SENSOR_EVT )
{
if (barEnabled)
{
if (barBusy)
{
barBusy = FALSE;
readBarData();
osal_start_timerEx( sensorTag_TaskID, ST_BAROMETER_SENSOR_EVT, sensorBarPeriod );
}
else
{
barBusy = TRUE;
HalBarStartMeasurement();
osal_start_timerEx( sensorTag_TaskID, ST_BAROMETER_SENSOR_EVT, BAR_FSM_PERIOD );
}
}
else
{
resetCharacteristicValue( BAROMETER_SERV_UUID, SENSOR_DATA, 0, BAROMETER_DATA_LEN);
resetCharacteristicValue( BAROMETER_SERV_UUID, SENSOR_CONF, ST_CFG_SENSOR_DISABLE, sizeof ( uint8 ));
resetCharacteristicValue( BAROMETER_SERV_UUID, SENSOR_CALB, 0, BAROMETER_CALI_LEN);
}
return (events ^ ST_BAROMETER_SENSOR_EVT);
}
//////////////////////////
// Gyroscope //
//////////////////////////
if ( events & ST_GYROSCOPE_SENSOR_EVT )
{
uint8 status;
status = HalGyroStatus();
if(gyroEnabled)
{
if (status == HAL_GYRO_STOPPED)
{
HalGyroSelectAxes(sensorGyroAxes);
HalGyroTurnOn();
osal_start_timerEx( sensorTag_TaskID, ST_GYROSCOPE_SENSOR_EVT, GYRO_STARTUP_TIME);
}
else
{
if(sensorGyroUpdateAxes)
{
HalGyroSelectAxes(sensorGyroAxes);
sensorGyroUpdateAxes = FALSE;
}
if (status == HAL_GYRO_DATA_READY)
{
readGyroData();
osal_start_timerEx( sensorTag_TaskID, ST_GYROSCOPE_SENSOR_EVT, sensorGyrPeriod - GYRO_STARTUP_TIME);
}
else
{
// Gyro needs to be activated;
HalGyroWakeUp();
osal_start_timerEx( sensorTag_TaskID, ST_GYROSCOPE_SENSOR_EVT, GYRO_STARTUP_TIME);
}
}
}
else
{
HalGyroTurnOff();
resetCharacteristicValue( GYROSCOPE_SERV_UUID, SENSOR_DATA, 0, GYROSCOPE_DATA_LEN);
resetCharacteristicValue( GYROSCOPE_SERV_UUID, SENSOR_CONF, ST_CFG_SENSOR_DISABLE, sizeof( uint8 ));
}
return (events ^ ST_GYROSCOPE_SENSOR_EVT);
}
#if defined ( PLUS_BROADCASTER )
if ( events & ST_ADV_IN_CONNECTION_EVT )
{
uint8 turnOnAdv = TRUE;
// Turn on advertising while in a connection
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &turnOnAdv );
return (events ^ ST_ADV_IN_CONNECTION_EVT);
}
#endif // PLUS_BROADCASTER
// Discard unknown events
return 0;
}
uint16 CurrentDetectionT1_ProcessEvent(uint8 task_id, uint16 events)
{
static uint16 timerCount = 0;
static uint32 heartBitFailNum = 0;
//uint8 deltaInfo[] = "delta = 1\n";
afIncomingMSGPacket_t* MSGpkt;
(void)task_id; // Intentionally unreferenced parameter
if (events & SYS_EVENT_MSG)
{
MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive(CurrentDetectionT1_TaskID);
while (MSGpkt)
{
switch (MSGpkt->hdr.event)
{
case CMD_SERIAL_MSG:
CurrentDetectionT1_SerialCMD((mtOSALSerialData_t *)MSGpkt);
break;
case AF_INCOMING_MSG_CMD:
CurrentDetectionT1_RfCMD(MSGpkt->cmd.DataLength, MSGpkt->cmd.Data);
HalLedBlink(HAL_LED_2, 2, 20, 50);
break;
// Received whenever the device changes state in the network
case ZDO_STATE_CHANGE:
CurrentDetectionT1_NwkState = (devStates_t)(MSGpkt->hdr.status);
if (CurrentDetectionT1_NwkState == DEV_END_DEVICE)
{
HalLedSet(HAL_LED_2, HAL_LED_MODE_ON);
HalUARTWrite(0, EndDeviceStatus, strlen((char *)EndDeviceStatus));
inNetwork = true;
}
break;
default:
break;
}
// Release the memory
osal_msg_deallocate((uint8 *)MSGpkt);
// Next - if one is available
MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive(CurrentDetectionT1_TaskID);
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
// Send a message out - This event is generated by a timer
// (setup in CurrentDetectionT1_Init()).
if (events & DTCT_HEARTBEAT_MSG_EVT)
{
uint8 sendToG1Data[HEART_BIT_MSG_LEN];
sendToG1Data[HEART_BIT_MSG_LEN - 1] = 0;
memcpy(sendToG1Data, serialNumber, SN_LEN);
reset_osal_SystemClock();
if (lastNvTime_l + get_osal_SystemClock() < lastNvTime_l)
{
nv_write_config();
HAL_SYSTEM_RESET();
}
if (CurrentDetectionT1_HandleSendRepairMessage(sendToG1Data))
{
CurrentDetectionT1_SampleCurrentAdcValue(true);
osal_start_timerEx(
CurrentDetectionT1_TaskID,
DTCT_HEARTBEAT_MSG_EVT,
DTCT_TIMER_MSG_TIMEOUT);
// The repairing status, no need to send ADC value any more.
return (events ^ DTCT_HEARTBEAT_MSG_EVT);
}
CurrentDetectionT1_SampleCurrentAdcValue(false);
++timerCount;
if ((timerCount == (480 * heartbitRate))
|| (timerCount == (960 * heartbitRate))
|| (timerCount == (1440 * heartbitRate)))
{
CurrentDetectionT1_RecoverHeartBeatMessage(sendToG1Data);
}
// send heart beat every 1.92s.
else if (timerCount == (HEARTBIT_TIME_UINT * heartbitRate))
{
CurrentDetectionT1_SetAverageCurrentAdcValue(sendToG1Data, CYCLE_NUM_IN_UINT * heartbitRate);
SET_HEART_BIT_STATUS(sendToG1Data , HEART_BIT_STATUS_POWER_SUPPLY_MASK, 0);
SET_HEART_BIT_STATUS(sendToG1Data , HEART_BIT_STATUS_BATTERY_CHARGING_MASK, 1);
if (inNetwork)
{
// Send the Heartbeat Message
if (!CurrentDetectionT1_SendHeartBeatMessage(sendToG1Data))
{
++heartBitFailNum;
CurrentDetectionT1_StoreHeartBeatMessage(sendToG1Data);
}
else
{
heartBitFailNum = 0;
}
}
else
{
++heartBitFailNum;
if (CurrentDetectionT1_CheckDelta(sendToG1Data))
{
CurrentDetectionT1_StoreHeartBeatMessage(sendToG1Data);
}
}
if (heartBitFailNum == FAIL_TIMES_TO_RESTART)
{
if (nv_mem_number())
{
nv_write_msg();
}
HAL_SYSTEM_RESET();
}
timerCount = 0;
}
osal_start_timerEx(
CurrentDetectionT1_TaskID,
DTCT_HEARTBEAT_MSG_EVT,
DTCT_TIMER_MSG_TIMEOUT);
// return unprocessed events
return (events ^ DTCT_HEARTBEAT_MSG_EVT);
}
if (events & DTCT_LED_WTD_EVT)
{
//Feed WatchDog
WDCTL = 0xa0;
WDCTL = 0x50;
if (P2_0)
{
HalLedSet(HAL_LED_1, HAL_LED_MODE_ON);
HalLedSet(HAL_LED_2, HAL_LED_MODE_OFF);
}
else
{
checkLedStatus();
}
osal_start_timerEx(
CurrentDetectionT1_TaskID,
DTCT_LED_WTD_EVT,
DTCT_LED_WTD_EVT_TIMEOUT);
return (events ^ DTCT_LED_WTD_EVT);
}
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn SensorTag_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 SensorTag_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( sensorTag_TaskID )) != NULL )
{
sensorTag_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
// Handle system reset (long press on side key)
if ( events & ST_SYS_RESET_EVT )
{
if (sysResetRequest)
{
HAL_SYSTEM_RESET();
}
return ( events ^ ST_SYS_RESET_EVT );
}
if ( events & ST_START_DEVICE_EVT )
{
// Start the Device
GAPRole_StartDevice( &sensorTag_PeripheralCBs );
// Start Bond Manager
GAPBondMgr_Register( &sensorTag_BondMgrCBs );
return ( events ^ ST_START_DEVICE_EVT );
}
////////////////////////////
//// Accelerometer //
////////////////////////////
// if ( events & ST_ACCELEROMETER_SENSOR_EVT )
// {
// if(accConfig != ST_CFG_SENSOR_DISABLE)
// {
// readAccData();
// osal_start_timerEx( sensorTag_TaskID, ST_ACCELEROMETER_SENSOR_EVT, sensorAccPeriod );
// }
// else
// {
// VOID resetCharacteristicValue( ACCELEROMETER_SERV_UUID, ACCELEROMETER_DATA, 0, ACCELEROMETER_DATA_LEN );
// VOID resetCharacteristicValue( ACCELEROMETER_SERV_UUID, ACCELEROMETER_CONF, ST_CFG_SENSOR_DISABLE, sizeof ( uint8 ));
// VOID resetCharacteristicValue( ACCELEROMETER_SERV_UUID, ACCELEROMETER_PERI, ACC_DEFAULT_PERIOD/ACCELEROMETER_TIME_UNIT, sizeof ( uint8 ));
// }
// return (events ^ ST_ACCELEROMETER_SENSOR_EVT);
// }
//////////////////////////
// Gyroscope //
//////////////////////////
if ( events & ST_GYROSCOPE_SENSOR_EVT )
{
uint8 status;
status = HalGyroStatus();
if(gyroEnabled)
{
if (status == HAL_GYRO_STOPPED)
{
HalGyroSelectAxes(sensorGyroAxes);
HalGyroTurnOn();
GAPRole_SendUpdateParam( 240, 256,0, 138, GAPROLE_TERMINATE_LINK);
//GAPRole_SendUpdateParam( 100, 105,0, 138, GAPROLE_TERMINATE_LINK);
osal_start_timerEx( sensorTag_TaskID, ST_GYROSCOPE_SENSOR_EVT, GYRO_STARTUP_TIME);
}
else
{
if(sensorGyroUpdateAxes)
{
HalGyroSelectAxes(sensorGyroAxes);
sensorGyroUpdateAxes = FALSE;
}
if (status == HAL_GYRO_DATA_READY)
{
readGyroData();
osal_start_timerEx( sensorTag_TaskID, ST_GYROSCOPE_SENSOR_EVT, GYRO_DEFAULT_PERIOD - GYRO_STARTUP_TIME);
}
else
{
// Gyro needs to be activated;
HalGyroWakeUp();
osal_start_timerEx( sensorTag_TaskID, ST_GYROSCOPE_SENSOR_EVT, GYRO_STARTUP_TIME);
}
}
}
else
{
HalGyroTurnOff();
if ( status == HAL_GYRO_STOPPED)
{
resetCharacteristicValue( GYROSCOPE_SERV_UUID, GYROSCOPE_DATA, 0, GYROSCOPE_DATA_LEN);
resetCharacteristicValue( GYROSCOPE_SERV_UUID, GYROSCOPE_CONF, ST_CFG_SENSOR_DISABLE, sizeof( uint8 ));
}
else
{
// Indicate error
resetCharacteristicValue( GYROSCOPE_SERV_UUID, GYROSCOPE_DATA, ST_CFG_ERROR, GYROSCOPE_DATA_LEN);
resetCharacteristicValue( GYROSCOPE_SERV_UUID, GYROSCOPE_CONF, ST_CFG_ERROR, sizeof( uint8 ));
}
}
return (events ^ ST_GYROSCOPE_SENSOR_EVT);
}
#if defined ( PLUS_BROADCASTER )
if ( events & ST_ADV_IN_CONNECTION_EVT )
{
uint8 turnOnAdv = TRUE;
// Turn on advertising while in a connection
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &turnOnAdv );
return (events ^ ST_ADV_IN_CONNECTION_EVT);
}
#endif // PLUS_BROADCASTER
// Discard unknown events
return 0;
}
