ZigBee学习笔记_InitBoard()_1

InitBoard()看注释上说是初始化板子上的I/O资源，进入到该函数实现体中，

void InitBoard( byte level )
{
if ( level == OB_COLD )
{
// Interrupts off
osal_int_disable( INTS_ALL );
// Turn all LEDs off
HalLedSet( HAL_LED_ALL, HAL_LED_MODE_OFF );
// Check for Brown-Out reset
ChkReset();
}
else  // !OB_COLD
{
#ifdef ZTOOL_PORT
MT_SysResetInd();
#endif

/* Initialize Key stuff */
OnboardKeyIntEnable = HAL_KEY_INTERRUPT_DISABLE;
HalKeyConfig( OnboardKeyIntEnable, OnBoard_KeyCallback);
}
}

从主函数中传递进来的是OB_COLD，该值为0，进来之后又是关闭中断，（貌似前面也没有打开过），之后进入HalLedSet()函数中，关闭所有LEDs，进入该函数中，

uint8 HalLedSet (uint8 leds, uint8 mode)
{

#if (defined (BLINK_LEDS)) && (HAL_LED == TRUE)
uint8 led;
HalLedControl_t *sts;

switch (mode)
{
case HAL_LED_MODE_BLINK:
/* Default blink, 1 time, D% duty cycle */
HalLedBlink (leds, 1, HAL_LED_DEFAULT_DUTY_CYCLE, HAL_LED_DEFAULT_FLASH_TIME);
break;

case HAL_LED_MODE_FLASH:
/* Default flash, N times, D% duty cycle */
HalLedBlink (leds, HAL_LED_DEFAULT_FLASH_COUNT, HAL_LED_DEFAULT_DUTY_CYCLE, HAL_LED_DEFAULT_FLASH_TIME);
break;

case HAL_LED_MODE_ON:
case HAL_LED_MODE_OFF:
case HAL_LED_MODE_TOGGLE:

led = HAL_LED_1;
leds &= HAL_LED_ALL;
sts = HalLedStatusControl.HalLedControlTable;

while (leds)
{
if (leds & led)
{
if (mode != HAL_LED_MODE_TOGGLE)
{
sts->mode = mode;  /* ON or OFF */
}
else
{
sts->mode ^= HAL_LED_MODE_ON;  /* Toggle */
}
HalLedOnOff (led, sts->mode);
leds ^= led;
}
led <<= 1;
sts++;
}
break;

default:
break;
}

#elif (HAL_LED == TRUE)
LedOnOff(leds, mode);
#else
// HAL LED is disabled, suppress unused argument warnings
(void) leds;
(void) mode;
#endif /* BLINK_LEDS && HAL_LED   */

return ( HalLedState );

}

首先是两个宏定义判断BLINK_LEDS以及HAL_LED，用于判断板子是否有LED资源，是否使能闪烁功能，可以找到定义处两个条件都符合，而后是一个HalLedControl_t结构体变量，查看该结构体定义

typedef struct {
uint8 mode;       /* Operation mode */
uint8 todo;       /* Blink cycles left */
uint8 onPct;      /* On cycle percentage */
uint16 time;      /* On/off cycle time (msec) */
uint32 next;      /* Time for next change */
} HalLedControl_t;

用该结构体来控制LED资源，了解一下就行，接下来就是对mode的判断有5的宏定义

/* Modes */
#define HAL_LED_MODE_OFF     0x00
#define HAL_LED_MODE_ON      0x01
#define HAL_LED_MODE_BLINK   0x02
#define HAL_LED_MODE_FLASH   0x04
#define HAL_LED_MODE_TOGGLE  0x08

在switch中可以看到BLINK与FLASH的区别就是BLINK只闪烁一次，而FLASH闪烁N次，两者都调用的是HalLedBlink (uint8 leds, uint8 numBlinks, uint8 percent, uint16 period)函数，只是第二个参数不同，这些参数有一些默认值如下

/* Defaults */
#define HAL_LED_DEFAULT_MAX_LEDS      4
#define HAL_LED_DEFAULT_DUTY_CYCLE    5
#define HAL_LED_DEFAULT_FLASH_COUNT   50
#define HAL_LED_DEFAULT_FLASH_TIME    1000

进入HalLedBlink函数查看

void HalLedBlink (uint8 leds, uint8 numBlinks, uint8 percent, uint16 period)
{
#if (defined (BLINK_LEDS)) && (HAL_LED == TRUE)
uint8 led;
HalLedControl_t *sts;

if (leds && percent && period)
{
if (percent < 100)
{
led = HAL_LED_1;
leds &= HAL_LED_ALL;
sts = HalLedStatusControl.HalLedControlTable;

while (leds)
{
if (leds & led)
{
/* Store the current state of the led before going to blinking */
preBlinkState |= (led & HalLedState);

sts->mode  = HAL_LED_MODE_OFF;                    /* Stop previous blink */
sts->time  = period;                              /* Time for one on/off cycle */
sts->onPct = percent;                             /* % of cycle LED is on */
sts->todo  = numBlinks;                           /* Number of blink cycles */
if (!numBlinks) sts->mode |= HAL_LED_MODE_FLASH;  /* Continuous */
sts->next = osal_GetSystemClock();                /* Start now */
sts->mode |= HAL_LED_MODE_BLINK;                  /* Enable blinking */
leds ^= led;
}
led <<= 1;
sts++;
}
osal_set_event (Hal_TaskID, HAL_LED_BLINK_EVENT);
}
else
{
HalLedSet (leds, HAL_LED_MODE_ON);                    /* >= 100%, turn on */
}
}
else
{
HalLedSet (leds, HAL_LED_MODE_OFF);                     /* No on time, turn off */
}
#elif (HAL_LED == TRUE)
percent = (leds & HalLedState) ? HAL_LED_MODE_OFF : HAL_LED_MODE_ON;
HalLedOnOff (leds, percent);                              /* Toggle */
#else
// HAL LED is disabled, suppress unused argument warnings
(void) leds;
(void) numBlinks;
(void) percent;
(void) period;
#endif /* BLINK_LEDS && HAL_LED */
}

一进来是宏定义判断，没啥可说的，然后对参数进行判断，得保证参数正确才行，之后将led赋值为LED1，leds与LED_ALL相与得到需要闪烁的leds值，后面用到了一个HalLedStatusControl变量，查看定义

#ifdef BLINK_LEDS
static HalLedStatus_t HalLedStatusControl;
#endif
typedef struct
{
HalLedControl_t HalLedControlTable[HAL_LED_DEFAULT_MAX_LEDS];
uint8           sleepActive;
} HalLedStatus_t;
#define HAL_LED_DEFAULT_MAX_LEDS      4

相当于建立了一个数组，里面放的是4个led资源，统一管理，并将sts指针指向HalLedControlTable，然后扫描leds的每一位从低位开始，闪烁置位的LED资源，这里面用到了preBlinkState变量，

static uint8 preBlinkState;            // Original State before going to blink mode
// bit 0, 1, 2, 3 represent led 0, 1, 2, 3

用于存储进入闪烁模式之前的状态，以及HalLedState变量，存储当前LED状态，HalLedState变量的值在别处有修改，跟其他结合着看就明白了，然后就是为sts指向的HalLedControl_t成员变量赋值，if (!numBlinks) sts->mode |= HAL_LED_MODE_FLASH;这句话说是继续的意思，但目前没理解还，先继续往下看，用到一个osal_GetSystemClock()函数：

uint32 osal_GetSystemClock( void )
{
return ( osal_systemClock );
}

// Milliseconds since last reboot
static uint32 osal_systemClock;

返回的是一个32位整型值，显示当前时钟，现在也还没理解这个next的含义，接着更换模式为BLINK，然后将这位清零，然后扫描下一位，4个LED资源扫描完毕之后（虽然这个板子只有两个LED），进入了osal_set_event()函数有两个参数

uint8 Hal_TaskID;
#define HAL_LED_BLINK_EVENT   0x0002

uint8 osal_set_event( uint8 task_id, uint16 event_flag )
{
if ( task_id < tasksCnt )
{
halIntState_t   intState;
HAL_ENTER_CRITICAL_SECTION(intState);    // Hold off interrupts
tasksEvents[task_id] |= event_flag;  // Stuff the event bit(s)
HAL_EXIT_CRITICAL_SECTION(intState);     // Release interrupts
}
else
return ( INVALID_TASK );

return ( SUCCESS );
}

看名字的意思是设置ID和LED的BLINK事件，进入该函数有个tasksCnt变量

const uint8 tasksCnt = sizeof( tasksArr ) / sizeof( tasksArr[0] );
const pTaskEventHandlerFn tasksArr[] = {
macEventLoop,
nwk_event_loop,
Hal_ProcessEvent,
#if defined( MT_TASK )
MT_ProcessEvent,
#endif
APS_event_loop,
#if defined ( ZIGBEE_FRAGMENTATION )
APSF_ProcessEvent,
#endif
ZDApp_event_loop,
#if defined ( ZIGBEE_FREQ_AGILITY ) || defined ( ZIGBEE_PANID_CONFLICT )
ZDNwkMgr_event_loop,
#endif
GenericApp_ProcessEvent
};

typedef unsigned short (*pTaskEventHandlerFn)( unsigned char task_id, unsigned short event );

InitBoard()函数貌似比前面的要复杂的多，跳了好几层，tasksCnt是事件的个数，目前还不能知道具体值，这个应该涉及到os层了，鸭梨来了那，首先判断任务ID是否超过任务数，检查其合法性，又碰到一个宏定义，形似函数并且字母都是大写的肯定就是宏定义了，

#define HAL_ENTER_CRITICAL_SECTION(x)   st( x = EA;  HAL_DISABLE_INTERRUPTS(); )
#define HAL_EXIT_CRITICAL_SECTION(x)    st( EA = x; )

第一个宏定义先获取当前EA的值，然后关掉中断，第二个宏定义是将EA的值恢复原值，要说好处嘛，可以不用管当前中断是否打开，对程序也没有影响，他们中间那条语句是为该任务设置事件标志，tasksEvents是一个指针，目前还没见到初始化，留待以后查看，最后返回到上一层。

回到HalLedBlink()函数，当percent大于等于100时，也就是超过100%，LED应当长亮即HalLedSet()函数来实现，当leds、percent、period有不合法的值时LED长灭，通用是用HalLedSet()函数实现，跑到HalLedBlink()函数的调用者去了，先把HalLedBlink()函数看完之后再去继续查看HalLedSet()函数吧，当没有定义BLINK_LEDS时，只是改变LED的状态，这里他用percent存储结果有点误人，不过这样可以充分利用内存资源，不用重新定义一个变量存储结果，加个注释会更好，leds和HalLedState相与得到当前状态，如果为1，那么就利用HalLedOnOff()函数关闭它，如果为0，就打开它，总之就是使得LED状态取反。这一节涉及到的函数实在是太多了，不晓得后面会不会更多？

HalLedOnOff()函数比较简单

void HalLedOnOff (uint8 leds, uint8 mode)
{
if (leds & HAL_LED_1)
{
if (mode == HAL_LED_MODE_ON)
{
HAL_TURN_ON_LED1();
}
else
{
HAL_TURN_OFF_LED1();
}
}

if (leds & HAL_LED_2)
{
if (mode == HAL_LED_MODE_ON)
{
HAL_TURN_ON_LED2();
}
else
{
HAL_TURN_OFF_LED2();
}
}

if (leds & HAL_LED_3)
{
if (mode == HAL_LED_MODE_ON)
{
HAL_TURN_ON_LED3();
}
else
{
HAL_TURN_OFF_LED3();
}
}

if (leds & HAL_LED_4)
{
if (mode == HAL_LED_MODE_ON)
{
HAL_TURN_ON_LED4();
}
else
{
HAL_TURN_OFF_LED4();
}
}

/* Remember current state */
if (mode)
{
HalLedState |= leds;
}
else
{
HalLedState &= (leds ^ 0xFF);
}
}

最后，将HalLedState赋为新的状态值。至此，HalLedBlink()函数就查看完了，返回到上一层HalLedSet()函数中继续查看。

在switch的判断中只剩下ON、OFF、以及TOGGLE三个case了，共用一段代码，比BLINK的简单多了也，有一个不理解的地方，当mode为TOGGLE时sts->mode又和ON异或了一下，除非当前mode是OFF，之后就会执行点亮LED操作，而当模式为On，都是执行的关掉LED操作，其他模式执行的也是关闭操作，但却为HalLedState相应位置1，总感觉有点矛盾？！当系统没有定义LED闪烁的时候直接调用LedOnOff()函数，可惜没有找到实现体，虽然这个函数的确不会执行。至此，HalLedSet()函数查看完毕了，返回上一层InitBoard()函数，进入到ChkRest()函数中，进行低压复位检测，进入该函数查看

void ChkReset( void )
{
uint8 led;
uint8 rib;

// Isolate reset indicator bits
rib = SLEEPSTA & LRESET;

if ( rib == RESETPO )
{
// Put code here to handle Power-On reset
}
else if ( rib == RESETEX )
{
// Put code here to handle External reset
}
else if ( rib == RESETWD )
{
// Put code here to handle WatchDog reset
}
else
{
// Unknown, hang and blink
HAL_DISABLE_INTERRUPTS();
led = HAL_LED_4;
while ( 1 ) {
HalLedSet( led, HAL_LED_MODE_ON );
MicroWait( 62500 );
MicroWait( 62500 );
HalLedSet( led, HAL_LED_MODE_OFF );
MicroWait( 37500 );
MicroWait( 37500 );
if ( !(led >>= 1) )
led = HAL_LED_4;
}
}
}

在该函数中是检测SLEEPSTA的RST属性，LRESET的值为0x18，即检测SLEEPSTA的3、4位如下



当值不是00,01,10的情况下，就是我们所需要的检测

// Reset bit definitions
#define LRESET     0x18  // Last reset bit mask
#define RESETPO    0x00  // Power-On reset
#define RESETEX    0x08  // External reset
#define RESETWD    0x10  // WatchDog reset

这里是进行闪烁操作，这里是从LED4开始到LED1循环闪烁，代码前面都叙述过了，在此就不赘述了，返回上一层InitBorad()函数。

在else中即非冷启动下有一个宏定义，通过查找定义找到如下代码

#if defined (ZTOOL_P1)
#define ZTOOL_PORT SERIAL_PORT1
#elif defined (ZTOOL_P2)
#define ZTOOL_PORT SERIAL_PORT2
#else
#undef ZTOOL_PORT
#endif

取的是第一个定义，但是ZTOOL_P1却找不到定义，也许在别处还有吧，进入MT_SystemResetInd()函数中查看

void MT_SysResetInd(void)
{
uint8 retArray[6];

retArray[0] = ResetReason(); /* Reason */
retArray[1] = 0x00; /* Transport Revision */
retArray[2] = 0x00; /* Product */
retArray[3] = 0x00; /* Major Revision */
retArray[4] = 0x00; /* Minor Revision */
retArray[5] = 0x00; /* Hardware Revision */

/* Send out Reset Response message */
MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_AREQ | (uint8)MT_RPC_SYS_SYS), MT_SYS_RESET_IND,
sizeof(retArray), retArray);
}

/* Reset reason for reset indication */
#define ResetReason() ((SLEEPSTA >> 3) & 0x03)
typedef enum {
MT_RPC_CMD_POLL = 0x00,
MT_RPC_CMD_SREQ = 0x20,
MT_RPC_CMD_AREQ = 0x40,
MT_RPC_CMD_SRSP = 0x60,
MT_RPC_CMD_RES4 = 0x80,
MT_RPC_CMD_RES5 = 0xA0,
MT_RPC_CMD_RES6 = 0xC0,
MT_RPC_CMD_RES7 = 0xE0
} mtRpcCmdType_t;

typedef enum {
MT_RPC_SYS_RES0,   /* Reserved. */
MT_RPC_SYS_SYS,
MT_RPC_SYS_MAC,
MT_RPC_SYS_NWK,
MT_RPC_SYS_AF,
MT_RPC_SYS_ZDO,
MT_RPC_SYS_SAPI,   /* Simple API. */
MT_RPC_SYS_UTIL,
MT_RPC_SYS_DBG,
MT_RPC_SYS_APP,
MT_RPC_SYS_MAX     /* Maximum value, must be last */
/* 10-32 available, not yet assigned. */
} mtRpcSysType_t;
#define MT_SYS_RESET_IND                     0x80

可以看到ResetReason()返回的是SLEEPSTA的RST属性值，进入MT_BuildAndSendZToolResponse()发送复位响应信息,粗略的看了一下该函数，貌似也有好几层并且涉及到了os层了，啊~快看不下去了，真蛋疼！分成两节写吧还是