/****************************************************************************
*
* NAME: MibNwkSecurity_vInit
*
* DESCRIPTION:
* Initialises data
*
****************************************************************************/
PUBLIC void MibNwkSecurity_vInit(thJIP_Mib hMibNwkSecurityInit,
tsMibNwkSecurity *psMibNwkSecurityInit,
bool_t bMibNwkSecuritySecurity)
{
/* Valid data pointer ? */
if (psMibNwkSecurityInit != (tsMibNwkSecurity *) NULL)
{
PDM_teStatus ePdmStatus;
/* Debug */
DBG_vPrintf(CONFIG_DBG_MIB_NWK_SECURITY, "\nMibNwkSecurity_vInit() {%d}", sizeof(tsMibNwkSecurity));
/* Take copy of pointer to data */
psMibNwkSecurity = psMibNwkSecurityInit;
/* Take a copy of the MIB handle */
psMibNwkSecurity->hMib = hMibNwkSecurityInit;
/* Note security setting */
psMibNwkSecurity->bSecurity = bMibNwkSecuritySecurity;
/* Load NodeStatus mib data */
ePdmStatus = PDM_eLoadRecord(&psMibNwkSecurity->sDesc,
#if defined(JENNIC_CHIP_FAMILY_JN514x)
"MibNwkSecurity",
#else
(uint16)(MIB_ID_NWK_SECURITY & 0xFFFF),
#endif
(void *) &psMibNwkSecurity->sPerm,
sizeof(psMibNwkSecurity->sPerm),
FALSE);
/* Debug */
DBG_vPrintf(CONFIG_DBG_MIB_NWK_SECURITY, "\n\tPDM_eLoadRecord(MibNwkSecurity, %d) = %d", sizeof(psMibNwkSecurity->sPerm), ePdmStatus);
}
}
/****************************************************************************
*
* NAME: MibNwkProfile_vInit
*
* DESCRIPTION:
* Initialises data
*
****************************************************************************/
PUBLIC void MibNwkProfile_vInit(thJIP_Mib hMibNwkProfileInit,
tsMibNwkProfile *psMibNwkProfileInit)
{
/* Valid data pointer ? */
if (psMibNwkProfileInit != (tsMibNwkProfile *) NULL)
{
PDM_teStatus ePdmStatus;
/* Debug */
DBG_vPrintf(CONFIG_DBG_MIB_NWK_PROFILE, "\nMibNwkProfile_vInit() {%d}", sizeof(tsMibNwkProfile));
/* Take copy of pointer to data */
psMibNwkProfile = psMibNwkProfileInit;
/* Take a copy of the MIB handle */
psMibNwkProfile->hMib = hMibNwkProfileInit;
/* Load NodeStatus mib data */
ePdmStatus = PDM_eLoadRecord(&psMibNwkProfile->sDesc,
"MibNwkProfile",
(void *) &psMibNwkProfile->sPerm,
sizeof(psMibNwkProfile->sPerm),
FALSE);
}
}
/****************************************************************************
*
* NAME: MibGroup_vInit
*
* DESCRIPTION:
* Initialises data
*
****************************************************************************/
PUBLIC void MibGroup_vInit(tsMibGroup *psMibGroupInit)
{
PDM_teStatus ePdmStatus;
/* Debug */
DBG_vPrintf(CONFIG_DBG_MIB_GROUP, "\nMibGroup_vInit() {%d}", sizeof(tsMibGroup));
/* Take copy of pointer to data */
psMibGroup = psMibGroupInit;
/* Load Node Status mib data */
ePdmStatus = PDM_eLoadRecord(&psMibGroup->sDesc,
#if defined(JENNIC_CHIP_FAMILY_JN514x)
"MibGroup",
#else
(uint16)(MIB_ID_GROUPS & 0xFFFF),
#endif
(void *) &psMibGroup->sPerm,
sizeof(psMibGroup->sPerm),
FALSE);
#if CONFIG_DBG_MIB_GROUP
{
uint8 u8Group;
/* Debug */
DBG_vPrintf(CONFIG_DBG_MIB_GROUP, "\n\tPDM_eLoadRecord(MibGroup, %d) = %d", sizeof(psMibGroup->sPerm), ePdmStatus);
/* Loop through current groups */
for (u8Group = 0; u8Group < MIB_GROUP_MAX; u8Group++)
{
/* Debug */
DBG_vPrintf(CONFIG_DBG_MIB_GROUP, "\n\tasGroupAddr[%d] = %x:%x:%x:%x:%x:%x:%x:%x)",
u8Group,
psMibGroup->sPerm.asGroupAddr[u8Group].s6_addr16[0],
psMibGroup->sPerm.asGroupAddr[u8Group].s6_addr16[1],
psMibGroup->sPerm.asGroupAddr[u8Group].s6_addr16[2],
psMibGroup->sPerm.asGroupAddr[u8Group].s6_addr16[3],
psMibGroup->sPerm.asGroupAddr[u8Group].s6_addr16[4],
psMibGroup->sPerm.asGroupAddr[u8Group].s6_addr16[5],
psMibGroup->sPerm.asGroupAddr[u8Group].s6_addr16[6],
psMibGroup->sPerm.asGroupAddr[u8Group].s6_addr16[7]);
}
}
#endif
/* Tell stack maximum number of groups we want to support */
u8SocketMaxGroupAddrs = MIB_GROUP_MAX;
}
/****************************************************************************
*
* NAME: MibNode_vInit
*
* DESCRIPTION:
* Initialises data
*
****************************************************************************/
PUBLIC void MibNode_vInit(tsMibNode *psMibNodeInit)
{
PDM_teStatus ePdmStatus;
/* Debug */
DBG_vPrintf(CONFIG_DBG_MIB_NODE, "\nMibNode_vInit() {%d}", sizeof(tsMibNode));
/* Take copy of pointer to data */
psMibNode = psMibNodeInit;
/* Load Node Status mib data */
ePdmStatus = PDM_eLoadRecord(&psMibNode->sDesc,
#if defined(JENNIC_CHIP_FAMILY_JN514x)
"MibNode",
#else
(uint16)(MIB_ID_NODE & 0xFFFF),
#endif
(void *) &psMibNode->sPerm,
sizeof(psMibNode->sPerm),
FALSE);
}
/****************************************************************************
*
* NAME: MibNodeStatus_vInit
*
* DESCRIPTION:
* Initialises data
*
****************************************************************************/
PUBLIC void MibNodeStatus_vInit(thJIP_Mib hMibNodeStatusInit,
tsMibNodeStatus *psMibNodeStatusInit)
{
/* Valid data pointer ? */
if (psMibNodeStatusInit != (tsMibNodeStatus *) NULL)
{
PDM_teStatus ePdmStatus;
uint32 u32SystemStatus;
/* Debug */
DBG_vPrintf(CONFIG_DBG_MIB_NODE_STATUS, "\nMibNodeStatus_vInit() {%d}", sizeof(tsMibNodeStatus));
/* Take copy of pointer to data */
psMibNodeStatus = psMibNodeStatusInit;
/* Take a copy of the MIB handle */
psMibNodeStatus->hMib = hMibNodeStatusInit;
/* Load NodeStatus mib data */
ePdmStatus = PDM_eLoadRecord(&psMibNodeStatus->sDesc,
#if defined(JENNIC_CHIP_FAMILY_JN514x)
"MibNodeStatus",
#else
(uint16)(MIB_ID_NODE_STATUS & 0xFFFF),
#endif
(void *) &psMibNodeStatus->sPerm,
sizeof(psMibNodeStatus->sPerm),
FALSE);
/* Read system status */
u32SystemStatus = u32REG_SysRead(REG_SYS_STAT);
/* Copy to mib variable */
psMibNodeStatus->sPerm.u16SystemStatus = (uint16)(u32SystemStatus & 0xffff);
/* Cold start ? */
if (0 == (u32SystemStatus & REG_SYSCTRL_STAT_WUS_MASK))
{
/* Increment cold start counter */
psMibNodeStatus->sPerm.u16ColdStartCount++;
}
/* Watchdog reset ? */
if (u32SystemStatus & REG_SYSCTRL_STAT_WD_RES_MASK)
{
/* Debug */
DBG_vPrintf(CONFIG_DBG_MIB_NODE_STATUS, "\n\tWatchdogReset");
/* Increment watchdog counter */
psMibNodeStatus->sPerm.u16WatchdogCount++;
}
/* Brownout reset ? */
if (u32SystemStatus & REG_SYSCTRL_STAT_VBO_RES_MASK)
{
/* Debug */
DBG_vPrintf(CONFIG_DBG_MIB_NODE_STATUS, "\n\tBrownoutReset");
/* Increment brownout counter */
psMibNodeStatus->sPerm.u16BrownoutCount++;
}
/* Initialise other data */
psMibNodeStatus->bSaveRecord = FALSE;
}
}
/****************************************************************************
*
* NAME: APP_vCoordInitialise
*
* DESCRIPTION:
* Initialises the application
*
* RETURNS:
* void
*
****************************************************************************/
PUBLIC void APP_vInitialiseControllerNode(void)
{
uint32 u32ChannelMask;
uint8 u8Chan;
bool_t bDeleteRecords;
/* Initialise buttons; if a button is held down as the device is reset, delete the device
* context from flash
*/
bDeleteRecords = APP_bButtonInitialise();
if (bDeleteRecords)
{
DBG_vPrintf(TRACE_APP, "APP: Deleting all records from flash\n");
PDM_vDelete();
}
vSerial_Init();
/* Restore any application data previously saved to flash */
s_sDevice.eState = E_STARTUP;
PDM_eLoadRecord(&s_sDevicePDDesc,
"APP_COORD",
&s_sDevice,
sizeof(s_sDevice),
TRUE);
/* Initialise ZBPro stack */
ZPS_eAplAfInit();
/* Initialise logging module */
APP_vLogInitialise();
/* Always initialise any peripherals used by the application */
APP_vDisplayInitialise();
APP_vLedsInitialise();
/* If the device state has been restored from flash, re-start the stack
* and set the app running again */
if (E_NETWORK_SCREEN == s_sDevice.eState
|| E_NODE_SCREEN == s_sDevice.eState)
{
ZPS_teStatus eStatus = ZPS_eAplZdoStartStack();
DBG_vPrintf(TRACE_APP, "APP: Re-starting Stack....\r\n");
if (ZPS_E_SUCCESS == eStatus)
{
DBG_vPrintf(TRACE_APP, "APP: DONE\r\n");
}
else
{
DBG_vPrintf(TRACE_APP, "APP: ZPS_eZdoStartStack() failed error %d", eStatus);
}
/* turn on joining */
s_sDevice.bPermitJoining = TRUE;
ZPS_eAplZdoPermitJoining(0xff);
/* always start with network screen */
s_sDevice.eState = E_NETWORK_SCREEN;
APP_vDisplaySetState(APP_E_DISPLAY_STATE_NETWORK);
APP_vDisplayUpdate();
/* start logging now the network is up */
APP_vLogStart();
}
else
/* else perform any actions require on initial start-up */
{
/* Turn on both LEDs to indicate device is forming network */
APP_vLedSet(0, TRUE);
APP_vLedSet(1, TRUE);
APP_vLedSet(2, TRUE);
APP_vLedSet(3, TRUE);
/* find the radio channel number from the channel bit mask */
s_sDevice.u8CurrentRadioChan = 11;
u32ChannelMask = ZPS_psAplAibGetAib()->apsChannelMask;
for (u8Chan = 11; u8Chan < 27; u8Chan++)
{
if ((1UL << u8Chan) & u32ChannelMask)
{
s_sDevice.u8CurrentRadioChan = u8Chan;
break;
}
}
DBG_vPrintf(TRACE_APP, "APP: Channel mask = 0x%08x, chan = %d\n", u32ChannelMask, u8Chan);
s_sDevice.bPermitJoining = FALSE;
s_sDevice.eState = E_STARTUP;
}
}
