/**************************************************************************************************
* @fn DataUpdateTask_Init
*
* @brief Set up task and variables for the data update task
*
* @param uint8 task_id
*
* @return none
**************************************************************************************************
*/
void DataUpdateTask_Init( uint8 task_id )
{
DataUpdate_TaskID = task_id;
// event_id ms
osal_start_reload_timer (DataUpdate_TaskID, 0x1, DEFAULT_DATA_COLLECT_PERIOD);
} // end DataUpdateTask_Init()
/**************************************************************************************************
* @fn HalMotionHandleGyroActiveEvent
*
* @brief Handles event indicating gyro should be producing samples.
*
* @param None
*
* @return None
**************************************************************************************************/
static void HalMotionHandleGyroActiveEvent( void )
{
if (HalMotionState == HAL_MOTION_STATE_POWERING_ON)
{
/* Start timer for taking measurements */
osal_start_reload_timer( Hal_TaskID,
HAL_MOTION_MEASUREMENT_START_EVENT,
HAL_MOTION_TIME_BETWEEN_MEASUREMENTS );
if (HalMotionCalibrateGyro == FALSE)
{
/* Update state */
HalMotionState = HAL_MOTION_STATE_WAITING_FOR_NEXT_MEASUREMENT;
}
else
{
/* Initiating a cal process ==> Reset Movea's motion processing library */
motion_init.DeltaGain.X = HalMotionMouseGainTable[HalMotionMouseGainTableIndex].gainX;
motion_init.DeltaGain.Y = HalMotionMouseGainTable[HalMotionMouseGainTableIndex].gainY;
motion_init.GyroOffsets.X = HalMotionGyroOffsets.x;
motion_init.GyroOffsets.Y = HalMotionGyroOffsets.y;
motion_init.GyroOffsets.Z = HalMotionGyroOffsets.z;
AIR_MOTION_Init(&motion_init);
}
}
}
/**************************************************************************************************
* @fn Hal_Init
*
* @brief Hal Initialization function.
*
* @param task_id - Hal TaskId
*
* @return None
**************************************************************************************************/
void Hal_Init( uint8 task_id )
{
/* Register task ID */
Hal_TaskID = task_id;
#ifdef CC2591_COMPRESSION_WORKAROUND
osal_start_reload_timer( Hal_TaskID, PERIOD_RSSI_RESET_EVT, PERIOD_RSSI_RESET_TIMEOUT );
#endif
}
int main(void)
{
hal_init();
print_version(version);
osal_init_system();
if(gSystem_t->mdc_test){
osal_start_timerEx(gSTTID, MDC_TEST_POLL_MSG, 20000);
}
osal_start_reload_timer(gSTTID, SERIAL_POLL_MSG, 500);
osal_start_reload_timer(gBT_TaskID, BT_POLL_MSG, 150);
osal_start_reload_timer(gNADUartID, NAD_UART_POLL_MSG, 200);
osal_start_timerEx(gSTTID, IR_IN_POLARITY_CHECK_MSG, 150);
while(1)
{
osal_start_system();
}
}
/*********************************************************************
* @fn hidappEstablishLink
*
* @brief Establish a link to a peer device.
*
* @param whiteList - determines use of the white list
* @param addrType - address type of the peer devic
* @param remoteAddr - peer device address
*
* @return none
*/
static void hidappEstablishLink( uint8 whiteList, uint8 addrType, uint8 *remoteAddr )
{
if ( hidappBLEState != BLE_STATE_CONNECTED )
{
hidappBLEState = BLE_STATE_CONNECTING;
// Try to connect to remote device
VOID GAPCentralRole_EstablishLink( DEFAULT_LINK_HIGH_DUTY_CYCLE,
whiteList, addrType, remoteAddr );
VOID osal_start_reload_timer( hidappTaskId, HIDAPP_EVT_INIT_CONNECT,
(uint32)INIT_CONNECT_TIMEOUT );
}
}
char OS_timer_start(unsigned char id, unsigned long timeout, unsigned char repeat, unsigned short linenum)
{
if (id >= OS_MAX_TIMER)
{
return 0;
}
blueBasic_timers[id].linenum = linenum;
if (repeat)
{
osal_start_reload_timer(blueBasic_TaskID, BLUEBASIC_EVENT_TIMER << id, timeout);
}
else
{
osal_start_timerEx(blueBasic_TaskID, BLUEBASIC_EVENT_TIMER << id, timeout);
}
return 1;
}
/**************************************************************************************************
* @fn znpBasicCfg
*
* @brief Process the Conglomerate Basic Configuration command.
*
* input parameters
*
* @param pBuf - Pointer to the MT buffer containing the conglomerated configuration.
*
* output parameters
*
* None.
*
* @return None.
*/
static void znpBasicCfg(uint8 *pBuf)
{
uint32 t32 = osal_build_uint32( &pBuf[0], 4 );
if (MT_PeriodicMsgRate != t32)
{
MT_PeriodicMsgRate = t32;
(void)osal_start_reload_timer(MT_TaskID, MT_PERIODIC_MSG_EVENT, t32);
}
t32 = osal_build_uint32( &pBuf[4], 4 );
if (osal_memcmp(&zgDefaultChannelList, &t32, 4) == FALSE)
{
(void)osal_nv_write(ZCD_NV_CHANLIST, 0, 4, &t32);
}
uint16 t16 = osal_build_uint16( &pBuf[8] );
if (osal_memcmp(&zgConfigPANID, &t16, 2) == FALSE)
{
(void)osal_nv_write(ZCD_NV_PANID, 0, 2, &t16);
}
if (zgDeviceLogicalType != pBuf[10])
{
(void)osal_nv_write(ZCD_NV_LOGICAL_TYPE, 0, 1, pBuf+10);
}
if (pBuf[11] & MT_ZNP_CMD_DISC_RESET_NWK)
{
pBuf[0] = ZCD_STARTOPT_DEFAULT_NETWORK_STATE;
(void)osal_nv_write(ZCD_NV_STARTUP_OPTION, 0, 1, pBuf);
#if defined CC2531ZNP
SystemResetSoft();
#else
SystemReset();
#endif
}
else if (pBuf[11] & MT_ZNP_CMD_DISC_ZDO_START)
{
if (devState == DEV_HOLD)
{
ZDOInitDevice(0);
}
}
}
/**
* @fn sensorTag_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 sensorTag_HandleKeys(uint8 shift, uint8 keys)
{
VOID shift; // Intentionally unreferenced parameter
uint8 current_adv_status;
if (keys & HAL_KEY_SW_1) {
// press KEY1
key1_press = TRUE;
// display
oled_exit_sleep();
// KEY action
osal_start_timerEx(sensorTag_TaskID, EVT_MODE, PERIOD_MODE_SWITCH);
osal_start_timerEx(sensorTag_TaskID, EVT_SLEEP, PERIOD_MODE_SLEEP);
osal_start_timerEx(sensorTag_TaskID, EVT_SYSRST, PERIOD_SYSRST);
if (pwmgr == PWMGR_S1) {
switch (opmode & 0xF0) {
case MODE_NORMAL:
opmode++;
#if defined(HAL_IMAGE_B)
if (opmode > (MODE_NORMAL + MODE_DISTANCE)) {
#else
if (opmode > (MODE_NORMAL + MODE_DBG)) {
#endif
opmode = MODE_NORMAL | MODE_TIME;
}
break;
case MODE_WORKOUT:
opmode++;
#if defined(HAL_IMAGE_B)
if (opmode > (MODE_WORKOUT + MODE_DISTANCE)) {
#else
if (opmode > (MODE_WORKOUT + MODE_DBG)) {
#endif
opmode = MODE_WORKOUT | MODE_TIME;
}
break;
case MODE_SLEEP:
default:
break;
}
}
// power management
switch (pwmgr) {
case PWMGR_S5:
osal_start_reload_timer(sensorTag_TaskID, EVT_RTC, PERIOD_RTC);
pwmgr_state_change(PWMGR_S6, TIME_OLED_OFF);
case PWMGR_S6:
return;
case PWMGR_S4:
adxl345_exit_sleep();
case PWMGR_S1:
default:
pwmgr_state_change(PWMGR_S1, TIME_OLED_OFF);
break;
}
// find the current GAP advertising status
Batt_SetLevel(batt_precision());
GAPRole_GetParameter(GAPROLE_ADVERT_ENABLED, ¤t_adv_status);
if ((current_adv_status == FALSE) && (gapProfileState != GAPROLE_CONNECTED)) {
current_adv_status = TRUE;
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8), ¤t_adv_status);
}
} else {
// release KEY1
key1_press = FALSE;
}
}
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;
}
