wuart_c.c

Zigbee无线网络节点的串口控制LED灯

/****************************************************************************
 *
 * NAME: vProcessIncomingData
 *
 * DESCRIPTION:
 * Process incoming data events from the stack.
 *
 * PARAMETERS:      Name            RW  Usage
 *                  psMcpsInd
 *
 * RETURNS:
 * None.
 *
 * NOTES:
 * None.
 ****************************************************************************/
PRIVATE void vProcessIncomingData(MAC_McpsDcfmInd_s *psMcpsInd)
{
    MAC_RxFrameData_s *psFrame;
    MAC_Addr_s *psAddr;
    uint16 u16NodeAddr;
    uint8 i;
	// rmm
    char acBlankLine[] = "                                ";

    psFrame = &psMcpsInd->uParam.sIndData.sFrame;
    psAddr = &psFrame->sSrcAddr;

    /* Check that this is a data frame */
    if (psMcpsInd->u8Type == MAC_MCPS_IND_DATA)
    {
        /* Check that data is from UART node */
        u16NodeAddr = psAddr->uAddr.u16Short;

        if (u16NodeAddr == sCoordData.sNode.asAssocNodes[0].u16ShortAddr)
        {
            if (psFrame->au8Sdu[0] == u8RxFrameHandle)
            {
                u8RxFrameHandle++;

                /* Copy frame data to serial buffer for output on UART */
                for (i = 1; i < psFrame->u8SduLength; i++)
                {
                    vSerial_TxChar(psFrame->au8Sdu[i]);
                }
                psFrame->au8Sdu[psFrame->u8SduLength] = 0;                  // Add a 'null' to the end of the data payload (required by the LcdWriteText function).
                vLcdWriteText((char*)&psFrame->au8Sdu[1], 6, 0);
                vLcdRefreshAll();
                vLcdScrollUp(1);
                vLcdWriteText(acBlankLine, 6, 0);
            }
            /* Must have missed a frame */
            else if (psFrame->au8Sdu[0] > u8RxFrameHandle)
            {
                u8RxFrameHandle = psFrame->au8Sdu[0] + 1;

                /* Copy frame data to serial buffer for output on UART */
                for (i = 1; i < psFrame->u8SduLength; i++)
                {
                    vSerial_TxChar(psFrame->au8Sdu[i]);
                }
                psFrame->au8Sdu[psFrame->u8SduLength] = 0;                  // Add a 'null' to the end of the data payload (required by the LcdWriteText function).
                vLcdWriteText((char*)&psFrame->au8Sdu[1], 6, 0);
                vLcdRefreshAll();
                vLcdScrollUp(1);
                vLcdWriteText(acBlankLine, 6, 0);
            }
            /* Must be the same frame as last time */
            else if (psFrame->au8Sdu[0] < u8RxFrameHandle)
            {
                /* Dont do anything as we already have the data */
            }
        }
    }
}

/****************************************************************************
 *
 * NAME: vProcessIncomingHwEvent
 *
 * DESCRIPTION:
 * Process any hardware events.
 *
 * PARAMETERS:      Name            RW  Usage
 *                  psAHI_Ind
 *
 * RETURNS:
 * None.
 *
 * NOTES:
 * None.
 ****************************************************************************/
PRIVATE void vProcessIncomingHwEvent(AppQApiHwInd_s *psAHI_Ind)
{
    /* If this is an event from UART0 */
    if (psAHI_Ind->u32DeviceId == E_AHI_DEVICE_UART0)
    {
        /* If data has been received */
        if ((psAHI_Ind->u32ItemBitmap & 0x000000FF) == E_AHI_UART_INT_RXDATA)
        {
            /* Process UART0 RX interrupt */
            if (((psAHI_Ind->u32ItemBitmap & 0x0000FF00) >> 8) == 0x0D)
            {
                vWUART_TxData();
            }
            else
            {
                vUART_RxCharISR((psAHI_Ind->u32ItemBitmap & 0x0000FF00) >> 8);
            }
        }
        else if (psAHI_Ind->u32ItemBitmap == E_AHI_UART_INT_TX)
        {
            /* Process UART0 TX interrupt */
            vUART_TxCharISR();
        }
    }
}

/****************************************************************************
 *
 * NAME: vTickTimerISR
 *
 * DESCRIPTION:
 *
 *
 * PARAMETERS:      Name            RW  Usage
 * None.
 *
 * RETURNS:
 * None.
 *
 * NOTES:
 * None.
 ****************************************************************************/
PRIVATE void vTickTimerISR(uint32 u32Device, uint32 u32ItemBitmap)
{
    static uint8 u8ToggleCount;

    /* Flash LED 1 to show we are alive */
    if (u8ToggleCount++ & 0x40)
    {
	    vLedControl(0, TRUE);
    }
    else
    {
	    vLedControl(0, FALSE);
    }
	/* rmm
	Commented out. Data now transmittd on the receipt of a CR

    // Do this every 10ms to tx data received on hardware UART //
    if (sCoordData.sSystem.eState == E_STATE_RUNNING_UART_APP)
    {
        vWUART_TxData();
    }
	*/
}

/****************************************************************************
 *
 * NAME: vHandleNodeAssociation
 *
 * DESCRIPTION:
 * Handle request by node to join the network. If the nodes address matches
 * the address of a light switch then it is assumed to be a light switch and
 * is allowed to join the network.
 *
 * PARAMETERS:      Name            RW  Usage
 *                  psMlmeInd
 *
 * RETURNS:
 * None.
 *
 * NOTES:
 * None.
 ****************************************************************************/
PRIVATE void vHandleNodeAssociation(MAC_MlmeDcfmInd_s *psMlmeInd)
{
    MAC_MlmeReqRsp_s   sMlmeReqRsp;
    MAC_MlmeSyncCfm_s  sMlmeSyncCfm;

    uint16 u16ShortAddress;

    /* Default to PAN access denied */
    uint8 u8AssocStatus = 2;

    /* Default short address */
    u16ShortAddress = 0xffff;

    /* Check that the device only wants to use a short address */
    if (psMlmeInd->uParam.sIndAssociate.u8Capability & 0x80)
    {
        if (sCoordData.sNode.u8AssociatedNodes < MAX_UART_NODES)
        {
            /* Allocate short address as next in list */
            u16ShortAddress = UART_NODE_ADDR_BASE + sCoordData.sNode.u8AssociatedNodes;

            /* Store details for future use */
            sCoordData.sNode.asAssocNodes[sCoordData.sNode.u8AssociatedNodes].u16ShortAddr = u16ShortAddress;
            sCoordData.sNode.u8AssociatedNodes++;

            /* Assume association succeeded */
            u8AssocStatus = 0;

            /* Turn on LED to show node has assocaited */
		    vLedControl(1, TRUE);

        }
    }

    /* Create association response */
    sMlmeReqRsp.u8Type = MAC_MLME_RSP_ASSOCIATE;
    sMlmeReqRsp.u8ParamLength = sizeof(MAC_MlmeRspAssociate_s);
    sMlmeReqRsp.uParam.sRspAssociate.sDeviceAddr.u32H = psMlmeInd->uParam.sIndAssociate.sDeviceAddr.u32H;
    sMlmeReqRsp.uParam.sRspAssociate.sDeviceAddr.u32L = psMlmeInd->uParam.sIndAssociate.sDeviceAddr.u32L;
    sMlmeReqRsp.uParam.sRspAssociate.u16AssocShortAddr = u16ShortAddress;
    sMlmeReqRsp.uParam.sRspAssociate.u8Status = u8AssocStatus;
    sMlmeReqRsp.uParam.sRspAssociate.u8SecurityEnable = FALSE;

    /* Send association response. There is no confirmation for an association
       response, hence no need to check */
    vAppApiMlmeRequest(&sMlmeReqRsp, &sMlmeSyncCfm);
}

/****************************************************************************
 *
 * NAME: bStartCoordinator
 *
 * DESCRIPTION:
 * Starts the network by configuring the controller board to act as the PAN
 * coordinator.
 *
 * PARAMETERS:      Name            RW  Usage
 * None.
 *
 * RETURNS:
 * TRUE if network was started successfully otherwise FALSE
 *
 * NOTES:
 * None.
 ****************************************************************************/
PRIVATE void vStartCoordinator(void)
{
    /* Structures used to hold data for MLME request and response */
    MAC_MlmeReqRsp_s   sMlmeReqRsp;
    MAC_MlmeSyncCfm_s  sMlmeSyncCfm;

    /* Start Pan */
    sMlmeReqRsp.u8Type = MAC_MLME_REQ_START;
    sMlmeReqRsp.u8ParamLength = sizeof(MAC_MlmeReqStart_s);
    sMlmeReqRsp.uParam.sReqStart.u16PanId = PAN_ID;
    sMlmeReqRsp.uParam.sReqStart.u8Channel = sCoordData.sSystem.u8Channel;
    sMlmeReqRsp.uParam.sReqStart.u8BeaconOrder = 0x0f; /* No beacons */
    sMlmeReqRsp.uParam.sReqStart.u8SuperframeOrder = 0x0f;
    sMlmeReqRsp.uParam.sReqStart.u8PanCoordinator = TRUE;
    sMlmeReqRsp.uParam.sReqStart.u8BatteryLifeExt = FALSE;
    sMlmeReqRsp.uParam.sReqStart.u8Realignment = FALSE;
    sMlmeReqRsp.uParam.sReqStart.u8SecurityEnable = FALSE;

    vAppApiMlmeRequest(&sMlmeReqRsp, &sMlmeSyncCfm);
}

 /****************************************************************************
 *
 * NAME: vTxUARTData
 *
 * DESCRIPTION:
 *
 * PARAMETERS:      Name            RW  Usage
 * None.
 *
 * RETURNS:
 * None.
 *
 * NOTES:
 * None.
 ****************************************************************************/
PRIVATE void vWUART_TxData(void)
{
    MAC_McpsReqRsp_s  sMcpsReqRsp;
    MAC_McpsSyncCfm_s sMcpsSyncCfm;
    uint8 *pu8Payload, i = 0;
    int16 i16RxChar;

    i16RxChar = i16Serial_RxChar();

    if (i16RxChar >= 0)
    {
        /* Create frame transmission request */
        sMcpsReqRsp.u8Type = MAC_MCPS_REQ_DATA;
        sMcpsReqRsp.u8ParamLength = sizeof(MAC_McpsReqData_s);
        /* Set handle so we can match confirmation to request */
        sMcpsReqRsp.uParam.sReqData.u8Handle = 1;
        /* Use short address for source */
        sMcpsReqRsp.uParam.sReqData.sFrame.sSrcAddr.u8AddrMode = 2;
        sMcpsReqRsp.uParam.sReqData.sFrame.sSrcAddr.u16PanId = PAN_ID;
        sMcpsReqRsp.uParam.sReqData.sFrame.sSrcAddr.uAddr.u16Short = COORD_ADDR;
        /* Use short address for destination */
        sMcpsReqRsp.uParam.sReqData.sFrame.sDstAddr.u8AddrMode = 2;
        sMcpsReqRsp.uParam.sReqData.sFrame.sDstAddr.u16PanId = PAN_ID;
        sMcpsReqRsp.uParam.sReqData.sFrame.sDstAddr.uAddr.u16Short = sCoordData.sNode.asAssocNodes[0].u16ShortAddr;
        /* Frame requires ack but not security, indirect transmit or GTS */
        sMcpsReqRsp.uParam.sReqData.sFrame.u8TxOptions = MAC_TX_OPTION_ACK;

        pu8Payload = sMcpsReqRsp.uParam.sReqData.sFrame.au8Sdu;

        pu8Payload[i++] = u8TxFrameHandle++;
        pu8Payload[i++] = (uint8)i16RxChar;

        while ((i16RxChar >= 0) && (i < MAX_DATA_PER_FRAME))
        {
            i16RxChar = i16Serial_RxChar();

            if (i16RxChar >= 0)
            {
            	/* Set payload data */
	            pu8Payload[i++] = (uint8)i16RxChar;
	        }
        }

        /* Set frame length */
        sMcpsReqRsp.uParam.sReqData.sFrame.u8SduLength = i;

        /* Request transmit */
        vAppApiMcpsRequest(&sMcpsReqRsp, &sMcpsSyncCfm);
    }
}

/****************************************************************************
 *
 * NAME: vStartEnergyScan
 *
 * DESCRIPTION:
 * Starts an enery sacn on the channels specified.
 *
 * PARAMETERS:      Name            RW  Usage
 * None.
 *
 * RETURNS:
 * None.
 *
 * NOTES:
 * None.
 ****************************************************************************/
PRIVATE void vStartEnergyScan(void)
{
    /* Structures used to hold data for MLME request and response */
    MAC_MlmeReqRsp_s   sMlmeReqRsp;
    MAC_MlmeSyncCfm_s  sMlmeSyncCfm;

    /* Start energy detect scan */
    sMlmeReqRsp.u8Type = MAC_MLME_REQ_SCAN;
    sMlmeReqRsp.u8ParamLength = sizeof(MAC_MlmeReqStart_s);
    sMlmeReqRsp.uParam.sReqScan.u8ScanType = MAC_MLME_SCAN_TYPE_ENERGY_DETECT;
    sMlmeReqRsp.uParam.sReqScan.u32ScanChannels = SCAN_CHANNELS;
    sMlmeReqRsp.uParam.sReqScan.u8ScanDuration = ENERGY_SCAN_DURATION;

    vAppApiMlmeRequest(&sMlmeReqRsp, &sMlmeSyncCfm);
}

/****************************************************************************
 *
 * NAME: vHandleEnergyScanResponse
 *
 * DESCRIPTION:
 * Selects a channel with low enery content for use by the wireless UART.
 *
 * PARAMETERS:      Name            RW  Usage
 * None.
 *
 * RETURNS:
 * None.
 *
 * NOTES:
 * None.
 ****************************************************************************/
PRIVATE void vHandleEnergyScanResponse(MAC_MlmeDcfmInd_s *psMlmeInd)
{
    uint8 i = 0;
    uint8 u8MinEnergy;

	u8MinEnergy = (psMlmeInd->uParam.sDcfmScan.uList.au8EnergyDetect[0]) ;

	/* Search list to find quietest channel */
    while (i < psMlmeInd->uParam.sDcfmScan.u8ResultListSize)
    {
        if ((psMlmeInd->uParam.sDcfmScan.uList.au8EnergyDetect[i]) < u8MinEnergy)
        {
			u8MinEnergy = (psMlmeInd->uParam.sDcfmScan.uList.au8EnergyDetect[i]);
			sCoordData.sSystem.u8Channel = i + CHANNEL_MIN;
		}
		i++;
    }
}

/****************************************************************************/
/***        END OF FILE                                                   ***/
/****************************************************************************/