void main(void)
{
HAL_BOARD_INIT();
#if HAL_OTA_XNV_IS_SPI
XNV_SPI_INIT();
#endif
/* 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 );
while (1)
{
HalFlashRead(HAL_OTA_CRC_ADDR / HAL_FLASH_PAGE_SIZE,
HAL_OTA_CRC_ADDR % HAL_FLASH_PAGE_SIZE,
(uint8 *)&OTA_crcControl, sizeof(OTA_crcControl));
if (OTA_crcControl.crc[0] == OTA_crcControl.crc[1])
{
break;
}
else if ((OTA_crcControl.crc[0] != 0) && (OTA_crcControl.crc[0] == crcCalc()))
{
OTA_crcControl.crc[1] = OTA_crcControl.crc[0];
HalFlashWrite((HAL_OTA_CRC_ADDR / HAL_FLASH_WORD_SIZE), (uint8 *)OTA_crcControl.crc, 1);
}
else
{
dl2rc();
}
}
// Simulate a reset for the Application code by an absolute jump to location 0x0800.
asm("LJMP 0x800\n");
}
/**************************************************************************************************
* @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();
/* This is in place of calling HalDmaInit() which would require init of the other 4 DMA
* descriptors in addition to just Channel 0.
*/
//P0DIR |= 1;
//P0_0 = 0;
//P0_0 = 1;
//P0_0 = 0;
//P0_0 = 1;
//P0_0 = 0;
//P0_0 = 1;
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();
}
}
/*---------------------------------------------------------------------------
* main
*-------------------------------------------------------------------------*/
int main(void)
{
/* Initialize hardware */
HAL_BOARD_INIT();
// Initialize board I/O
InitBoard( OB_COLD );
/* PCB specific initialization */
cbHW_init();
/* Initialze the HAL driver */
HalDriverInit();
/* Initialize NV system */
osal_snv_init();
/* Initialize the operating system */
osal_init_system();
/* Enable interrupts */
HAL_ENABLE_INTERRUPTS();
/* Final board initialization */
InitBoard( OB_READY );
#if defined ( POWER_SAVING )
osal_pwrmgr_device( PWRMGR_BATTERY );
#endif
/* Start OSAL */
osal_start_system(); // No Return from here
return 0;
}
/**************************************************************************************************
* @fn main
*
* @brief Start of application.
*
* @param none
*
* @return none
**************************************************************************************************
*/
int main(void)
{
/* Initialize hardware */
HAL_BOARD_INIT();
/* Initialze the HAL driver */
HalDriverInit();
/* Initialize NV system */
osal_snv_init();
/* Initialize the operating system */
osal_init_system();
/* Enable interrupts */
HAL_ENABLE_INTERRUPTS();
#if defined POWER_SAVING
osal_pwrmgr_device( PWRMGR_BATTERY );
#endif
/* Start OSAL */
osal_start_system(); // No Return from here
return 0;
}
/**************************************************************************************************
* @fn main
*
* @brief Start of application.
*
* @param none
*
* @return none
**************************************************************************************************
*/
int main(void)
{
/* Initialize hardware */
HAL_BOARD_INIT();
/* Initialze the HAL driver */
HalDriverInit();
/* Initialize NV system */
osal_snv_init();
/* Initialize LL */
/* Initialize the operating system */
osal_init_system();
/* Enable interrupts */
HAL_ENABLE_INTERRUPTS();
/* Setup Keyboard callback */
HalKeyConfig(false, MSA_Main_KeyCallback);
/* Blink LED on startup */
HalLedSet (HAL_LED_4, HAL_LED_MODE_ON);
/* Start OSAL */
osal_start_system(); // No Return from here
return 0;
}
/**
* @brief Start of application.
*/
int main(void)
{
/* Initialize hardware */
HAL_BOARD_INIT();
// Initialize board I/O
InitBoard( OB_COLD );
/* Initialze the HAL driver */
HalDriverInit();
/* Initialize NV system */
osal_snv_init();
/* Initialize LL */
/* Initialize the operating system */
osal_init_system();
/* Enable interrupts */
HAL_ENABLE_INTERRUPTS();
// Final board initialization
InitBoard( OB_READY );
osal_pwrmgr_device( PWRMGR_ALWAYS_ON );
HCI_EXT_ClkDivOnHaltCmd(HCI_EXT_DISABLE_CLK_DIVIDE_ON_HALT);
/* Start OSAL */
osal_start_system(); // No Return from here
return 0;
}
/**************************************************************************************************
* @fn main
*
* @brief Start of application.
*
* @param none
*
* @return none
**************************************************************************************************
*/
int main(void)
{
/* Initialize hardware */
HAL_BOARD_INIT();
/* Initialze the HAL driver */
HalDriverInit();
/* Initialize MAC */
MAC_Init();
/* Initialize the operating system */
osal_init_system();
/* Enable interrupts */
HAL_ENABLE_INTERRUPTS();
/* Setup OSAL Timer */
HalTimerConfig ( OSAL_TIMER, // 16bit timer3
HAL_TIMER_MODE_CTC, // Clear Timer on Compare
HAL_TIMER_CHANNEL_SINGLE, // Channel 1 - default
HAL_TIMER_CH_MODE_OUTPUT_COMPARE, // Output Compare mode
FALSE, // Use interrupt
MSA_Main_TimerCallBack); // Channel Mode
/* Setup Keyboard callback */
HalKeyConfig(MSA_KEY_INT_ENABLED, MSA_Main_KeyCallback);
/* Initialize UART */
UartCnfg.baudRate = HAL_UART_BR_9600;
UartCnfg.callBackFunc = HalUARTCBack;
UartCnfg.flowControl = FALSE;
UartCnfg.flowControlThreshold = 0; /* max Buffer Size in Byte*/
UartCnfg.idleTimeout = 200;
/*
* halUARTOpen provvederà tramite la funzione halUartAllocBuffers ad allocare e inizializzare
* le strutture dati RxUART e TxUART.
*/
UartCnfg.rx = RxUART;
UartCnfg.tx = TxUART;
UartCnfg.rx.maxBufSize = UART_MAX_BUFFER_SIZE;
UartCnfg.tx.maxBufSize = UART_MAX_BUFFER_SIZE;
UartCnfg.intEnable = TRUE ; /* enable or disable the interrupts */
UartCnfg.configured = TRUE;
uint8 status = HalUARTOpen(HAL_UART_PORT, &UartCnfg); /* passo l'indirizzo di memoria della struttura dati
UartCnfg, Passaggio per riferimento!!!*/
/* Start OSAL */
osal_start_system(); // No Return from here
return 0;
}
/**************************************************************************************************
* @fn main
*
* @brief Start of application.
*
* @param none
*
* @return none
**************************************************************************************************
*/
int main(void)
{
/* Initialize hardware */
HAL_BOARD_INIT();
// Initialize board I/O
InitBoard( OB_COLD );
/* Initialze the HAL driver */
HalDriverInit();
/* Initialize NV system */
osal_snv_init();
/* Initialize LL */
/* Initialize the operating system */
osal_init_system();
/* Enable interrupts */
HAL_ENABLE_INTERRUPTS();
// Final board initialization
InitBoard( OB_READY );
#if defined ( POWER_SAVING )
osal_pwrmgr_device( PWRMGR_BATTERY );
#endif
#if 0
P0DIR |= 0x32;
P0_1 = 0;
P0_4 = 0;
P0_5 = 0;
#endif
#if 0
P1DIR |= 0x08;
P1_3 = 0;
P2DIR |= 0x01;
P2_0 = 1;
#endif
// E009_Init();
// E009_ActivatePwrKey();
//HalLedSet(HAL_LED1_G,HAL_LED_MODE_ON);
/* Start OSAL */
osal_start_system(); // No Return from here
return 0;
}
/**************************************************************************************************
* @fn sblInit
*
* @brief Initialization for SBL.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
**************************************************************************************************
*/
static void sblInit(void)
{
HAL_BOARD_INIT();
vddWait(VDD_MIN_RUN);
magicByte = SB_MAGIC_VALUE;
/* 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);
HalUARTInitUSB();
}
//JFang, 任何8051单片机c程序， 都是由 main 函数开始的，
// 我们拿到一份代码，首先需要找到main函数
int main(void)
{
/* Initialize hardware */
HAL_BOARD_INIT(); //JFang,初始化时钟稳定时钟等等
// Initialize board I/O
//JFang, 冷启动，关闭了led灯与中断， 一边接下来的各种初始化不受干扰
InitBoard( OB_COLD );
/* Initialze the HAL driver */
HalDriverInit(); //JFang, 各种驱动的初始化、如按键、lcd、adc、usb、uart等
/* Initialize NV system */
//JFang, snv 内部用于保存配对数据或你的用户自定义数据的一段flash，4kB空间
osal_snv_init();
/* Initialize LL */
/* Initialize the operating system */
//JFang, oasl 操作系统初始化, 包含内存分配、消息队列、定时器、电源管理和任务等
osal_init_system();
/* Enable interrupts */
HAL_ENABLE_INTERRUPTS();//JFang, 开启全局中断
// Final board initialization
InitBoard( OB_READY ); //JFang,设置标志标示系统初始化完毕
#if defined ( POWER_SAVING )
//JFang, 如果你使能了低功耗， 就启动低功耗模式，
osal_pwrmgr_device( PWRMGR_BATTERY );
#endif
/*
低功耗部分
1.如何总是在PM1
osal_pwrmgr_device( PWRMGR_ALWAYS_ON );
2.如何进入PM2
osal_pwrmgr_device( PWRMGR_BATTERY );在空闲的时候就会进入到PM2模式
3.如何进入PM3
存在连接就断开连接，存在广播就停掉广播，并确认自己创建的所有定时任务都已关闭，
则系统应该就会进入PM3模式，只能进行外部中断唤醒
*/
/* Start OSAL */
osal_start_system(); // No Return from here
/* osal 操作系统启动，实际上是一个大循环，只是检查相对应的标志位，
就指定相对应的任务,看到这里，同学们应该往哪里看呢?其实，这已经是尽头了?那么我们的应用程序是在哪里写的呢
其实是在上面的 上面的函数 osal_init_system 里就初始化了，现在回过头去看看
osal_init_system 这个函数内部就知道了
*/
return 0;
}
/**************************************************************************************************
* @fn sblInit
*
* @brief Initialization for SBL.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
**************************************************************************************************
*/
static void sblInit(void)
{
HAL_BOARD_INIT();
vddWait(VDD_MIN_RUN);
magicByte = SB_MAGIC_VALUE;
/* 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);
#if defined CC2530_MK
znpCfg1 = ZNP_CFG1_SPI;
#else
znpCfg1 = P2_0;
#endif
if (znpCfg1 == ZNP_CFG1_SPI)
{
SRDY_CLR();
// Select general purpose on I/O pins.
P0SEL &= ~(NP_RDYIn_BIT); // P0.3 MRDY - GPIO
P0SEL &= ~(NP_RDYOut_BIT); // P0.4 SRDY - GPIO
// Select GPIO direction.
P0DIR &= ~NP_RDYIn_BIT; // P0.3 MRDY - IN
P0DIR |= NP_RDYOut_BIT; // P0.4 SRDY - OUT
P0INP &= ~NP_RDYIn_BIT; // Pullup/down enable of MRDY input.
P2INP &= ~BV(5); // Pullup all P0 inputs.
HalUARTInitSPI();
}
else
{
halUARTCfg_t uartConfig;
HalUARTInitISR();
uartConfig.configured = TRUE;
uartConfig.baudRate = HAL_UART_BR_115200;
uartConfig.flowControl = FALSE;
uartConfig.flowControlThreshold = 0; // CC2530 by #define - see hal_board_cfg.h
uartConfig.rx.maxBufSize = 0; // CC2530 by #define - see hal_board_cfg.h
uartConfig.tx.maxBufSize = 0; // CC2530 by #define - see hal_board_cfg.h
uartConfig.idleTimeout = 0; // CC2530 by #define - see hal_board_cfg.h
uartConfig.intEnable = TRUE;
uartConfig.callBackFunc = NULL;
HalUARTOpenISR(&uartConfig);
}
}
/**************************************************************************************************
* @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();
}
}
/**************************************************************************************************
* @fn sblInit
*
* @brief SBL initialization.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
*/
static void sblInit(uint8 bootloaderForcedByMainApp)
{
HAL_BOARD_INIT();
if (! bootloaderForcedByMainApp)
{
// If power on reset (i.e. reset not due to main software request) - pull down D+.
// If reset is due to software request - do not touch the pull, otherwise the USB bus will reset and re-enumerate on the host.
HAL_USB_PULLUP_DISABLE();
}
/* 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);
HalUARTInitUSB();
SB_INIT_LEDS();
}
/**************************************************************************************************
* @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 main
*
* @brief Start of application.
*
* @param none
*
* @return none
**************************************************************************************************
*/
int main(void)
{
/* Initialize hardware */
HAL_BOARD_INIT();
// Initialize board I/O
InitBoard( OB_COLD );
/* Initialze the HAL driver */
HalDriverInit();
/* Initialize NV system */
osal_snv_init();
/* Initialize the operating system */
osal_init_system();
/* Enable interrupts */
HAL_ENABLE_INTERRUPTS();
// Final board initialization
InitBoard( OB_READY );
#if defined ( POWER_SAVING )
osal_pwrmgr_device( PWRMGR_BATTERY );
#endif
#if (ALLOW_SELF_TEST == ENABLE)
#if !defined(FEATURE_OAD)
/* Run power on self-test */
sensorTag_test();
#endif
#endif
/* Start OSAL */
osal_start_system(); // No Return from here
return 0;
}
void main(void)
{
uint16 crc[2];
HAL_BOARD_INIT();
#if HAL_OAD_XNV_IS_SPI
XNV_SPI_INIT();
#endif
/* 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 );
HalFlashInit();
HalFlashRead(HAL_OAD_CRC_ADDR / HAL_FLASH_PAGE_SIZE,
HAL_OAD_CRC_ADDR % HAL_FLASH_PAGE_SIZE,
(uint8 *)crc, sizeof(crc));
if (crc[0] != crc[1])
{
// If the CRC is erased or the RC code fails a sanity check, instantiate the DL code (again).
if ((crc[0] == 0) || (crc[0] != crcCalc()))
{
dl2rc();
/* If dl2rc() fails, a flawed image is allowed to run -
* maybe the damage is not fatal to OTA ops?
*/
}
else
{
crc[1] = crc[0];
HalFlashWrite((HAL_OAD_CRC_ADDR / HAL_FLASH_WORD_SIZE), (uint8 *)crc, 1);
}
}
// Simulate a reset for the Application code by an absolute jump to location 0x0800.
asm("LJMP 0x800\n");
}
/**************************************************************************************************
* @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 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();
}
/*******************************************
* @fun : main
* @brief : Start of application.
*
* @param : none
*
* @return : none
******************************************/
int main(void)
{
HAL_BOARD_INIT(); //硬件初始化
InitBoard( OB_COLD ); //板级IO初始化
HalDriverInit(); //HAL驱动初始化
osal_snv_init(); //NV系统初始化
osal_init_system(); //OSAL初始化
HAL_ENABLE_INTERRUPTS(); //使能总中断
InitBoard( OB_READY ); //板级初始化
#if defined ( POWER_SAVING )
osal_pwrmgr_device( PWRMGR_BATTERY ); //低功耗管理
#endif
osal_start_system(); // No Return from here 启动OSAL
return 0;
}
/**************************************************************************************************
* @fn main
*
* @brief Start of application.
*
* @param none
*
* @return none
**************************************************************************************************
*/
int main(void)
{
/* Initialize hardware */
HAL_BOARD_INIT();
/* Initialze the HAL driver */
HalDriverInit();
/* Initialize MAC */
MAC_Init();
/* Initialize the operating system */
osal_init_system();
#ifdef HAL_BOARD_CC2538
/* Master enable interrupts */
IntMasterEnable();
/* Setup SysTick to generate interrupt every 1 ms */
SysTickSetup();
#endif /* HAL_BOARD_CC2538 */
/* Enable interrupts */
HAL_ENABLE_INTERRUPTS();
/* Setup Keyboard callback */
HalKeyConfig(MSA_KEY_INT_ENABLED, MSA_Main_KeyCallback);
/* Blink LED on startup */
HalLedBlink (HAL_LED_4, 0, 40, 200);
/* Start OSAL */
OSAL_START_SYSTEM();
return 0;
}
/*************************************************************************************************
Main
**************************************************************************************************/
void main(void)
{
HAL_BOARD_INIT();
UART_init();
U0CSR &= ~0x04;
ENABLE_RX();
/*setup sensors*/
sensors_init();
sensor_int_init();
/* Setup LED's */
P1DIR |= BV(0);
P0DIR |= BV(4);
P1_0 = 0;
start_gyro(); //start the gyro
init_acc(); //start the accelerometer
start_mag();
start_baro();
//zero_mag();
EA = 1;
SLEEPCMD |= 0x02; //pm 2
uint8 flag;
uint8 IDbyte;
uint8 baro_stage = 1;
while(1){
if (RXin)
{
//If it is a cal data request
if ( active_sensors & BV(4) )
{
flag = 0x03;
flush_data(&flag);
baro_read_cal();
//End of line char
flag = 0x00;
flush_byte(&flag);
} else if ( active_sensors > 0 ) {
// P0_4 = 1;
/**************************************************************************/
/* Read and transmit sensor data */
flag = 0x04;
flush_byte(&flag);
flush_byte(&active_sensors);
/*---------------------------------------------------------------------*/
//Read accelerometer and gyro
if ( active_sensors & BV(0) )
{
IDbyte = BV(0);
flush_data(&IDbyte);
while( !( acc_int_status() ) ); //wait for interrupt
read_acc(); //read the accelerometer
while( !(gyro_int_status() & BV(0) ) ); //wait for interrupt
read_gyro();
}
/*---------------------------------------------------------------------*/
//Read Magnetometer
//start_interrupts(MAG_INT);
if ( active_sensors & BV(1) )
{
IDbyte = BV(1);
flush_data(&IDbyte);
//PCON |= 1;
while( !(mag_status() & 0x08 ) );
read_mag();
// mag_sleep(TRUE);
}
/*---------------------------------------------------------------------*/
//Barometer
//uint16 delay_ticks;
uint8 baro_res = 2;
if ( active_sensors & BV(2) )
{
IDbyte = BV(2);
flush_data(&IDbyte);
if (active_sensors & 0x40)
{
//delay_ticks = 0xFA00;
baro_capture_press(baro_res);
//while(delay_ticks--);
baro_read_press(TRUE);
//delay_ticks = 0xFA00;
baro_capture_temp();
//while(delay_ticks--);
baro_read_temp(TRUE);
}else{
uint8 nullbyte = 3;
switch (baro_stage)
{
case 1 :
baro_capture_press(baro_res);
baro_read_press(FALSE);
baro_read_temp(FALSE);
baro_stage++;
break;
case 2 :
baro_read_press(TRUE);
baro_read_temp(FALSE);
baro_stage++;
break;
case 3 :
baro_capture_temp();
baro_read_press(FALSE);
baro_read_temp(FALSE);
baro_stage++;
break;
case 4 :
baro_read_press(FALSE);
baro_read_temp(TRUE);
baro_stage = 1;
break;
}
}
//baro_shutdown();
}
/*---------------------------------------------------------------------*/
//Humidity
if ( active_sensors & BV(3) )
{
IDbyte = BV(3);
flush_data(&IDbyte);
humid_init();
humid_read_humidity(TRUE);
}
/*---------------------------------------------------------------------*/
//End of line char
flag = 0x00;
flush_byte(&flag);
}
if ( !(active_sensors & BV(5)) ) //if autopoll is off
{
P0_4 = 1;
RXin = 0; //clear the RX flag
}else{
P0_4 = 0;
}
}
IEN0 |= 0x04;
U0CSR &= ~0x04;
}
}
/**************************************************************************************************
* @fn halAssertHazardLights
*
* @brief Blink LEDs to indicate an error.
*
* @param none
*
* @return none
**************************************************************************************************
*/
void halAssertHazardLights(void)
{
enum
{
DEBUG_DATA_RSTACK_HIGH_OFS,
DEBUG_DATA_RSTACK_LOW_OFS,
DEBUG_DATA_TX_ACTIVE_OFS,
DEBUG_DATA_RX_ACTIVE_OFS,
#if (defined HAL_MCU_AVR) || (defined HAL_MCU_CC2430)
DEBUG_DATA_INT_MASK_OFS,
#elif (defined HAL_MCU_CC2530) || (defined HAL_MCU_CC2533)
DEBUG_DATA_INT_MASK0_OFS,
DEBUG_DATA_INT_MASK1_OFS,
#endif
DEBUG_DATA_SIZE
};
uint8 buttonHeld;
uint8 debugData[DEBUG_DATA_SIZE];
/* disable all interrupts before anything else */
HAL_DISABLE_INTERRUPTS();
/*-------------------------------------------------------------------------------
* Initialize LEDs and turn them off.
*/
HAL_BOARD_INIT();
HAL_TURN_OFF_LED1();
HAL_TURN_OFF_LED2();
HAL_TURN_OFF_LED3();
HAL_TURN_OFF_LED4();
/*-------------------------------------------------------------------------------
* Master infinite loop.
*/
for (;;)
{
buttonHeld = 0;
/*-------------------------------------------------------------------------------
* "Hazard lights" loop. A held keypress will exit this loop.
*/
do
{
HAL_LED_BLINK_DELAY();
/* toggle LEDS, the #ifdefs are in case HAL has logically remapped non-existent LEDs */
#if (HAL_NUM_LEDS >= 1)
HAL_TOGGLE_LED1();
#if (HAL_NUM_LEDS >= 2)
HAL_TOGGLE_LED2();
#if (HAL_NUM_LEDS >= 3)
HAL_TOGGLE_LED3();
#if (HAL_NUM_LEDS >= 4)
HAL_TOGGLE_LED4();
#endif
#endif
#endif
#endif
/* escape hatch to continue execution, set escape to '1' to continue execution */
{
static uint8 escape = 0;
if (escape)
{
escape = 0;
return;
}
}
/* break out of loop if button is held long enough */
if (HAL_PUSH_BUTTON1())
{
buttonHeld++;
}
else
{
buttonHeld = 0;
}
}
while (buttonHeld != 10); /* loop until button is held specified number of loops */
/*-------------------------------------------------------------------------------
* Just exited from "hazard lights" loop.
*/
/* turn off all LEDs */
HAL_TURN_OFF_LED1();
HAL_TURN_OFF_LED2();
HAL_TURN_OFF_LED3();
HAL_TURN_OFF_LED4();
/* wait for button release */
HAL_DEBOUNCE(!HAL_PUSH_BUTTON1());
/*-------------------------------------------------------------------------------
* Load debug data into memory.
*/
#ifdef HAL_MCU_AVR
{
uint8 * pStack;
pStack = (uint8 *) SP;
pStack++; /* point to return address on stack */
debugData[DEBUG_DATA_RSTACK_HIGH_OFS] = *pStack;
pStack++;
debugData[DEBUG_DATA_RSTACK_LOW_OFS] = *pStack;
}
debugData[DEBUG_DATA_INT_MASK_OFS] = EIMSK;
#endif
#if (defined HAL_MCU_CC2430)
debugData[DEBUG_DATA_INT_MASK_OFS] = RFIM;
#elif (defined HAL_MCU_CC2530) || (defined HAL_MCU_CC2533)
debugData[DEBUG_DATA_INT_MASK0_OFS] = RFIRQM0;
debugData[DEBUG_DATA_INT_MASK1_OFS] = RFIRQM1;
#endif
#if (defined HAL_MCU_AVR) || (defined HAL_MCU_CC2430) || (defined HAL_MCU_CC2530) || \
(defined HAL_MCU_CC2533) || (defined HAL_MCU_MSP430)
debugData[DEBUG_DATA_TX_ACTIVE_OFS] = macTxActive;
debugData[DEBUG_DATA_RX_ACTIVE_OFS] = macRxActive;
#endif
/* initialize for data dump loop */
{
uint8 iBit;
uint8 iByte;
iBit = 0;
iByte = 0;
/*-------------------------------------------------------------------------------
* Data dump loop. A button press cycles data bits to an LED.
*/
while (iByte < DEBUG_DATA_SIZE)
{
/* wait for key press */
while(!HAL_PUSH_BUTTON1());
/* turn on all LEDs for first bit of byte, turn on three LEDs if not first bit */
HAL_TURN_ON_LED1();
HAL_TURN_ON_LED2();
HAL_TURN_ON_LED3();
if (iBit == 0)
{
HAL_TURN_ON_LED4();
}
else
{
HAL_TURN_OFF_LED4();
}
/* wait for debounced key release */
HAL_DEBOUNCE(!HAL_PUSH_BUTTON1());
/* turn off all LEDs */
HAL_TURN_OFF_LED1();
HAL_TURN_OFF_LED2();
HAL_TURN_OFF_LED3();
HAL_TURN_OFF_LED4();
/* output value of data bit to LED1 */
if (debugData[iByte] & (1 << (7 - iBit)))
{
HAL_TURN_ON_LED1();
}
else
{
HAL_TURN_OFF_LED1();
}
/* advance to next bit */
iBit++;
if (iBit == 8)
{
iBit = 0;
iByte++;
}
}
}
/*
* About to enter "hazard lights" loop again. Turn off LED1 in case the last bit
* displayed happened to be one. This guarantees all LEDs are off at the start of
* the flashing loop which uses a toggle operation to change LED states.
*/
HAL_TURN_OFF_LED1();
}
}