/**************************************************************************************************
* @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;
}
int main( void )
{
halInit();
moduleInit();
printf("\r\n****************************************************\r\n");
printf("Fragmentation Example - ROUTER - using AFZDO\r\n");
buttonIsr = &handleButtonPress;
#define MODULE_START_DELAY_IF_FAIL_MS 5000
/* See basic communications examples for more information about module startup. */
struct moduleConfiguration defaultConfiguration = DEFAULT_MODULE_CONFIGURATION_ROUTER;
start:
while ((result = startModule(&defaultConfiguration, GENERIC_APPLICATION_CONFIGURATION)) != MODULE_SUCCESS)
{
printf("Module start unsuccessful. Error Code 0x%02X. Retrying...\r\n", result);
delayMs(MODULE_START_DELAY_IF_FAIL_MS);
}
printf("On Network!\r\n");
setLed(0);
/* On network, display info about this network */
#ifdef DISPLAY_NETWORK_INFORMATION //excluded to reduce code size
displayNetworkConfigurationParameters();
displayDeviceInformation();
#endif
HAL_ENABLE_INTERRUPTS();
/* Now the network is running - send a message to the coordinator every few seconds.*/
#define TEST_CLUSTER 0x77
/* Fill test message buffer with an incrementing counter */
int i = 0;
for (i=0; i<MESSAGE_LENGTH; i++)
{
testMessage[i] = i;
}
printf("Sending the following message:\r\n");
uint8_t counter = 0;
while (1)
{
printf("Sending Message #%u L%u to Short Address 0x0000 (Coordinator) ", counter++, MESSAGE_LENGTH);
/* Send an extended length message to a short address */
moduleResult_t result = afSendDataExtendedShort(DEFAULT_ENDPOINT, DEFAULT_ENDPOINT, 0, TEST_CLUSTER, testMessage, MESSAGE_LENGTH); //a short message - coordinator will receive an AF_INCOMING_MSG_EXT
if (result == MODULE_SUCCESS)
{
printf("Success\r\n");
} else {
printf("ERROR %i ", result);
#ifdef RESTART_AFTER_ZM_FAILURE
printf("\r\nRestarting\r\n");
goto start;
#else
printf("stopping\r\n");
while(1);
#endif
}
delayMs(2000);
}
}
/**
* @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 Write_Data
*
* @brief This func for read data form slave device
*
* @param uint8 - Address of slave device
*
* @return uint8 - The byte read form the Addr
*/
uint8 Read_Data(uint8 Addr)
{
uint8 Value;
HAL_DISABLE_INTERRUPTS();
I2c_Start(); //make the I2C bus begin
//if((Addr != Last_Addr + 1) || (Addr & 0xFF))
//{
I2c_Write_Byte(0xC8 ); // write address 1100100 and make the R/w with 0
I2c_Ack();
I2c_Write_Byte(Addr);// write register to slaver
I2c_Ack();
I2c_Start(); //repeat make the I2C bus begin
I2c_Write_Byte(0xC9);// write address 1100100 and make the R/w with 1
I2c_Ack();
Value = I2c_Read_Byte(); // we recive the content from slaver
I2c_Stop();
HAL_ENABLE_INTERRUPTS();
return Value;
}
HAL_ISR_FUNCTION(port1Isr, P1INT_VECTOR)
#endif
{
HAL_ENTER_ISR();
#endif
PxIFG = 0;
PxIF = 0;
spiRdyIsr = 1;
#if !defined HAL_SPI_MASTER
if (spiTxLen == 0)
{
#if !defined HAL_SBL_BOOT_CODE
CLEAR_SLEEP_MODE();
UxDBUF = 0x00;
SPI_SET_RDY_OUT();
#endif
SPI_CLR_RDY_OUT(); /* SPI_RDYOut = 1 */
}
#endif
#if !defined HAL_SBL_BOOT_CODE
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
#endif
HAL_ENABLE_INTERRUPTS();
}
/**************************************************************************************************
* @fn sblExec
*
* @brief Infinite SBL execute loop that returns upon receiving a code enable.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
**************************************************************************************************
*/
static void sblExec(void)
{
uint32 dlyCnt = 0;
vddWait(VDD_MIN_NV);
HAL_ENABLE_INTERRUPTS();
while (1)
{
if (dlyCnt++ & 0x4000)
{
SB_TOGGLE_LED1();
}
HalUARTPollUSB();
if (sbExec())
{
break;
}
}
SB_TURN_ON_LED1();
SB_TURN_ON_LED2();
// Delay to allow the SB_ENABLE_CMD response to be flushed.
for (dlyCnt = 0; dlyCnt < 0x40000; dlyCnt++)
{
HalUARTPollUSB();
}
}
void handle_pending_hsrs(void)
{
extern int32_t sched_lock;
int nr;
list_head_t *list, *node;
hsr_t *hsr;
if (sched_lock > 0)
return;
// just only to prevent hisrs to schedule
++sched_lock;
while (1) {
nr = HAL_FIND_FIRST_SET(hsr_bitmap);
if (nr < 0)
break;
list = hsr_array + nr;
node = LIST_FIRST(list);
BUG_ON(NULL == node);
hsr = LIST_ENTRY(node, hsr_t, node);
hsr->function(hsr->data);
HAL_DISABLE_INTERRUPTS();
--hsr->count;
if (hsr->count <= 0)
LIST_DEL(node);
if (LIST_EMPTY(list))
hsr_bitmap &= ~(1 << nr);
HAL_ENABLE_INTERRUPTS();
}
--sched_lock;
}
/*---------------------------------------------------------------------------
* 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;
}
/****************************************************************************
Function: cyg_user_start
Description: This routine is the entry point of the application task.
Inputs: none
Returns: none
****************************************************************************/
void cyg_user_start(void)
{
/* Turn all led's on */
P4205_LED_ON(P4205_BOARD_CNTL_STATUS, P4205_FP_LED_ALL);
#ifdef CYGPKG_KERNEL /* Using eCos kernel */
/* Create a dacMode Thread */
cyg_thread_create(10, /* Thread priority */
(cyg_thread_entry_t *)TskFunc_dacMode, /* Entry function */
0, /* Thread function arg */
"dacMode", /* Thread name */
stThread_dacMode, /* Thread Stack Base */
CYGNUM_HAL_STACK_SIZE_TYPICAL, /* Thread Stack Size */
&hThread_dacMode, /* Thread Handle */
&oThread_dacMode); /* Thread Housekeeping Info */
/* Take thread out of suspended state */
cyg_thread_resume(hThread_dacMode);
#else /* No eCos kernel */
/* Enable Processor Interrupts - not required but enables gdb/insight
* for stopping an executing program using the stop button or Ctrl-C.
*/
HAL_ENABLE_INTERRUPTS();
/* Invoke application directly */
TskFunc_dacMode();
#endif
} /* end cyg_user_start() */
int main( void )
{
halInit();
moduleInit();
printf("\r\nWriting NV Items\r\n");
result = moduleReset();
if (result == MODULE_SUCCESS)
{
displaySysResetInd(); // Display the contents of the received SYS_RESET_IND message
} else {
printf("Module Reset ERROR 0x%02X\r\n", result);
}
debugConsoleIsr = &handleDebugConsoleInterrupt; //call method handleDebugConsoleInterrupt() when a byte is received
HAL_ENABLE_INTERRUPTS(); //Enable Interrupts
while (1)
{
uint8_t whichNvItem = getWhichNvItemToWrite();
if (whichNvItem != NO_CHARACTER_RECEIVED)
{
uint8_t nvItemSize = getNvItemSize(whichNvItem);
printf("\r\nWriting to NV item %u, L%u:", whichNvItem, nvItemSize);
printHexBytes(dataToWrite, nvItemSize);
result = sysNvWrite(whichNvItem, dataToWrite);
if (result != MODULE_SUCCESS)
{
printf("sysNvWrite ERROR 0x%02X\r\n", result);
}
}
}
}
int main( void )
{
halInit();
printf("\r\n****************************************************\r\n");
printf("Simple Application Example - COORDINATOR - using AFZDO\r\n");
HAL_ENABLE_INTERRUPTS();
startZnp(COORDINATOR);
printf("On Network!\r\n");
/* On network, display info about this network */
getNetworkConfigurationParameters();
getDeviceInformation();
/* Now the network is running - wait for any received messages from the ZNP */
#ifdef VERBOSE_MESSAGE_DISPLAY
printAfIncomingMsgHeaderNames();
#endif
while (1)
{
while (SRDY_IS_HIGH()); //wait until SRDY goes low indicating a message has been received.
displayMessages();
}
}
/**************************************************************************************************
* @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 sblWait
*
* @brief A timed-out wait loop that exits early upon receiving a force code/sbl byte.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return TRUE to run the code image, FALSE to run the SBL.
**************************************************************************************************
*/
static uint8 sblWait(void)
{
uint32 dlyCnt = 0x260000;
uint8 rtrn = FALSE;
HAL_ENABLE_INTERRUPTS();
while (1)
{
uint8 ch;
HalUARTPollUSB();
if (HalUARTRx(&ch, 1))
{
if (ch == SB_FORCE_BOOT)
{
break;
}
else if (ch == SB_FORCE_RUN)
{
dlyCnt = 0;
}
}
if (SB1_PRESS)
{
break;
}
if (SB2_PRESS || (dlyCnt-- == 0))
{
rtrn = TRUE;
break;
}
// RR-xing LED display while waiting.
if (dlyCnt & 0x2000)
{
SB_TURN_OFF_LED2();
SB_TURN_ON_LED1();
}
else
{
SB_TURN_OFF_LED1();
SB_TURN_ON_LED2();
}
}
HAL_DISABLE_INTERRUPTS();
SB_TURN_OFF_LED1();
SB_TURN_OFF_LED2();
return rtrn;
}
int main( void )
{
halInit();
moduleInit();
printf("\r\n****************************************************\r\n");
printf("Secure Communications Example - ROUTER - using AFZDO\r\n");
HAL_ENABLE_INTERRUPTS();
#define MODULE_START_DELAY_IF_FAIL_MS 5000
struct moduleConfiguration defaultConfiguration = DEFAULT_MODULE_CONFIGURATION_ROUTER;
defaultConfiguration.securityMode = SECURITY_MODE_PRECONFIGURED_KEYS;
defaultConfiguration.securityKey = key;
start:
while ((result = startModule(&defaultConfiguration, GENERIC_APPLICATION_CONFIGURATION)) != MODULE_SUCCESS)
{
printf("Module start unsuccessful. Error Code 0x%02X. Retrying...\r\n", result);
delayMs(MODULE_START_DELAY_IF_FAIL_MS);
}
printf("On Network!\r\n");
setLed(0);
/* On network, display info about this network */
#ifdef DISPLAY_NETWORK_INFORMATION
displayNetworkConfigurationParameters();
displayDeviceInformation();
#endif
/* Now the network is running - send a message to the coordinator every few seconds.*/
#define TEST_CLUSTER 0x77
while (1)
{
printf("Sending Message %u ", counter++);
result = afSendData(DEFAULT_ENDPOINT,DEFAULT_ENDPOINT,0, TEST_CLUSTER, testMessage, 5);
if (result == MODULE_SUCCESS)
{
printf("Success\r\n");
} else {
printf("ERROR %02X ", result);
#ifdef RESTART_AFTER_ZM_FAILURE
printf("\r\nRestarting\r\n");
goto start;
#else
printf("stopping\r\n");
while(1);
#endif
}
toggleLed(1);
delayMs(2000);
}
}
//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 sblExec
*
* @brief Infinite SBL execute loop that returns upon receiving a code enable.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
**************************************************************************************************
*/
static void sblExec(void)
{
uint32 dlyCnt = 0;
uint8 sbExec_rc;
if (znpCfg1 == ZNP_CFG1_UART)
{
URX0IE = 1;
HAL_ENABLE_INTERRUPTS();
sbReportState(SB_STATE_BOOTLOADER_ACTIVE);
}
else
{
/* For preventing an unknown delay after sending SB_FORCE_BOOT and before being able to send
SB_HANDSHAKE_CMD, this call was moved to the processing of SB_HANDSHAKE_CMD, which has an
associated response (SB_FORCE_BOOT does not have any response). This change was required
for the bootloader to work on the Alektrona gateway reference board. It was verified only
with UART, so at the moment the behavior for SPI is left unchanged. */
vddWait(VDD_MIN_NV);
}
while (1)
{
if (znpCfg1 == ZNP_CFG1_UART)
{
sbUartPoll();
}
sbExec_rc = sbExec();
if (sbExec_rc == SB_CMND_ENABLE_STATE_REPORTING)
{
sbReportState(SB_STATE_BOOTLOADER_ACTIVE);
}
else if (sbExec_rc == SB_CMND_ENABLED_CMD_OK)
{
// Delay to allow the SB_ENABLE_CMD response to be flushed.
if (znpCfg1 == ZNP_CFG1_UART)
{
for (dlyCnt = 0; dlyCnt < 0x40000; dlyCnt++)
{
sbUartPoll();
}
URX0IE = 0;
}
break;
}
}
}
int main( void )
{
halInit();
moduleInit();
buttonIsr = &handleButtonPress;
sysTickIsr = &sysTick;
printf("\r\n****************************************************\r\n");
printf("Config Application Example - COORDINATOR\r\n");
clearLeds();
halRgbLedPwmInit();
initSysTick();
HAL_ENABLE_INTERRUPTS(); //NEW
stateMachine(); //run the state machine
}
cyg_start( void )
#endif
{
int loops;
CYG_TEST_INIT();
CYG_TEST_INFO( "cyg_user_start()" );
HAL_ENABLE_INTERRUPTS();
loops = start();
// Typically about 1200 loops execute on the 33MHz 86832;
// I hoped to put in a check that we hadn't wasted time in
// spurious interrupts, but kernel instrumentation, for example,
// is more than enough to slow the world down... so keep this
// very weak test in, as a placeholder.
CYG_TEST_CHECK( 100 <= loops, "Not enough tests executed" );
CYG_TEST_EXIT( "All done" );
}
int main( void )
{
halInit();
moduleInit();
printf("\r\n****************************************************\r\n");
printf("Zigbee Network Explorer\r\n");
debugConsoleIsr = &handleDebugConsoleInterrupt;
HAL_ENABLE_INTERRUPTS();
clearLeds();
/* Now the network is running - wait for any received messages from the ZM */
#ifdef VERBOSE_MESSAGE_DISPLAY
printAfIncomingMsgHeaderNames();
#endif
stateMachine();
}
HAL_ISR_FUNCTION(port1Isr, P1INT_VECTOR)
#endif
{
HAL_ENTER_ISR();
#endif
PxIFG = 0;
PxIF = 0;
spiRdyIsr = 1;
#if !defined HAL_SBL_BOOT_CODE
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
#endif
HAL_ENABLE_INTERRUPTS();
}
int main( void )
{
halInit();
moduleInit();
printf("\r\nResetting Module, then getting MAC Address\r\n");
HAL_ENABLE_INTERRUPTS();
result = moduleReset();
if (result == MODULE_SUCCESS)
{
/* Display the contents of the received SYS_RESET_IND message */
displaySysResetInd();
} else {
printf("ERROR 0x%02X\r\n", result);
}
while (1)
{
result = zbGetDeviceInfo(DIP_MAC_ADDRESS);
if (result == MODULE_SUCCESS)
{
uint8_t* mac = zmBuf+SRSP_DIP_VALUE_FIELD;
printf("MAC (as sent, LSB first):");
printHexBytes(mac, 8);
/* Note: the MAC address comes over the wire in reverse order (LSB first)
So we swap the order of the bytes so we can display it correctly. */
uint8_t temp[8];
int i;
for (i=0; i<8; i++)
{
temp[i] = mac[7-i];
}
printf("MAC (correct, MSB first):");
printHexBytes(temp, 8);
printf("\r\n");
} else {
printf("ERROR 0x%02X\r\n", result);
}
toggleLed(1);
delayMs(1000);
}
}
/**************************************************************************************************
* @fn halSleepEnterIdleMode
*
* @brief This function puts the device into idle mode.
* Note that interrupts must have been disabled before this function call.
*
* input parameters
*
* @param timeout - Timeout value in 320 usec units. The sleep timer compare is set to
* this value.
*
* output parameters
*
* None.
*
* @return None.
**************************************************************************************************
*/
void halSleepEnterIdleMode(uint32 timeout)
{
/* enable sleep timer interrupt */
if (timeout != 0)
{
if (timeout > HAL_SLEEP_MS_TO_320US( MAX_SLEEP_TIME ))
{
timeout = HAL_SLEEP_MS_TO_320US( MAX_SLEEP_TIME );
}
/* set sleep timer */
halSleepSetTimer(timeout);
/* set up sleep timer interrupt */
HAL_SLEEP_TIMER_CLEAR_INT();
HAL_SLEEP_TIMER_ENABLE_INT();
}
HAL_SLEEP_PREP_IDLE_MODE();
HAL_ENABLE_INTERRUPTS();
HAL_SLEEP_SET_POWER_MODE();
}
void intr_main( void )
{
CYG_INTERRUPT_STATE oldints;
cyg_drv_interrupt_create(CYGNUM_HAL_INTERRUPT_RTC, 1,
ISR_DATA, isr, NULL, &intr_handle, &intr);
cyg_drv_interrupt_attach(intr_handle);
HAL_CLOCK_INITIALIZE( CYGNUM_HAL_RTC_PERIOD );
cyg_drv_interrupt_unmask(CYGNUM_HAL_INTERRUPT_RTC);
HAL_ENABLE_INTERRUPTS();
while( ticks < 10 )
{
}
HAL_DISABLE_INTERRUPTS(oldints);
CYG_TEST_PASS_FINISH("HAL interrupt test");
}
int main( void )
{
halInit();
moduleInit();
printf("\r\nResetting Module\r\n");
HAL_ENABLE_INTERRUPTS();
moduleReset();
while (1)
{
printf("Module Reset: ");
result = moduleReset();
if (result == MODULE_SUCCESS)
{
displaySysResetInd(); // Display the contents of the received SYS_RESET_IND message
} else {
printf("ERROR 0x%02X\r\n", result);
}
delayMs(3000);
}
}
int main( void )
{
structInit();
halInit();
moduleInit();
buttonIsr = &handleButtonPress;
printf("\r\n****************************************************\r\n");
printf("Simple Application Example - COORDINATOR\r\n");
routers[0].MAC_address[0] = 0x5E;
routers[0].MAC_address[1] = 0xD2;
routers[0].MAC_address[2] = 0x5D;
routers[0].MAC_address[3] = 0x02;
routers[0].MAC_address[4] = 0x00;
routers[0].MAC_address[5] = 0x4B;
routers[0].MAC_address[6] = 0x12;
routers[0].MAC_address[7] = 0x00;
routers[1].MAC_address[0] = 0xD3;
routers[1].MAC_address[1] = 0xD3;
routers[1].MAC_address[2] = 0x5D;
routers[1].MAC_address[3] = 0x02;
routers[1].MAC_address[4] = 0x00;
routers[1].MAC_address[5] = 0x4B;
routers[1].MAC_address[6] = 0x12;
routers[1].MAC_address[7] = 0x00;
HAL_ENABLE_INTERRUPTS();
clearLeds();
halRgbLedPwmInit();
while (1) {
stateMachine(); //run the state machine
if (alarm_sounding == 1 && !alarm_silenced) {
delayMs(2);
toggleLed(0);
}
}
}
int main( void )
{
halInit();
moduleInit();
HAL_DISABLE_INTERRUPTS();
printf("\r\n****************************************************\r\n");
printf("Simple Application Example - END DEVICE\r\n");
uint16_t vlo = calibrateVlo();
printf("VLO = %u Hz\r\n", vlo);
timerIsr = &handleTimer;
clearLeds();
HAL_ENABLE_INTERRUPTS();
/* Most of the of infoMessage are the same, so we can create most of the message ahead of time. */
hdr.sequence = 0; //this will be incremented each message
hdr.version = INFO_MESSAGE_VERSION;
hdr.flags = INFO_MESSAGE_FLAGS_NONE;
initializeSensors();
delayMs(100);
stateMachine();
}
/**************************************************************************************************
* @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;
}
/*******************************************
* @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;
}