homedemorouter.c

wireless jennic application note

    while (sDemoData.sQueue.u8WritePtr != sDemoData.sQueue.u8ReadPtr)
    {
        psHwIntData = &sDemoData.sQueue.asHwIntData[sDemoData.sQueue.u8ReadPtr];

        switch (psHwIntData->u32Device)
        {
        case E_AHI_DEVICE_SYSCTRL:
            /* Check for DIO pin used by humidity/temperature sensor */
            if (psHwIntData->u32ItemBitmap & HTS_DATA_DIO_BIT_MASK)
            {
                switch (sDemoData.sSystem.eState)
                {
                case E_STATE_READING_S1:
                    vReadSensor2();
                    break;

                case E_STATE_READING_S2:
                    vReadSensor3();
                    break;

                default:
                    break;
                }
            }

#if 0 /* Now uses BOS timer */
            /* Check for wake timer */
            if (psHwIntData->u32ItemBitmap & (1 << E_AHI_SYSCTRL_WK1))
            {
                vStartReadSensors();
            }
#endif

            /* Check for buttons */
            if (psHwIntData->u32ItemBitmap & (BUTTON_ALL_MASK_RFD << BUTTON_BASE_BIT))
            {
                uint8 u8KeysDown = (uint8)(psHwIntData->u32ItemBitmap >> BUTTON_BASE_BIT);

                switch (u8KeysDown)
                {
                case BUTTON_0_MASK:
                    sDemoData.sControls.u8Switch = 0;
//                    nlmePermitJoiningRequest(0);
                    break;

                case BUTTON_1_MASK:
                    sDemoData.sControls.u8Switch = 1;
//                    nlmePermitJoiningRequest(0xff);
                    break;
                }
            }
            break;

        default:
            break;
        }

        sDemoData.sQueue.u8ReadPtr = (sDemoData.sQueue.u8ReadPtr + 1) & HW_INT_Q_PTR_MASK;
    }
}

/****************************************************************************
 *
 * NAME: JZA_vPeripheralEvent
 *
 * DESCRIPTION:
 * Called when a hardware event causes an interrupt. This function is called
 * from within the interrupt context so should be brief. In this case, the
 * information is placed on a simple FIFO queue to be processed later.
 *
 * PARAMETERS: Name          RW  Usage
 *             u32Device     R   Peripheral generating interrupt
 *             u32ItemBitmap R   Bitmap of interrupt sources within peripheral
 *
 ****************************************************************************/
PUBLIC void JZA_vPeripheralEvent(uint32 u32Device, uint32 u32ItemBitmap)
{
    tsHwIntData *psHwIntData;
    uint8        u8WriteNextPtr;

    /* Queue event for processing during appKeyOperationKey call */

    u8WriteNextPtr = (sDemoData.sQueue.u8WritePtr + 1) & HW_INT_Q_PTR_MASK;

    if (u8WriteNextPtr != sDemoData.sQueue.u8ReadPtr)
    {
        /* There is space on queue */
        psHwIntData = &sDemoData.sQueue.asHwIntData[sDemoData.sQueue.u8WritePtr];
        psHwIntData->u32Device = u32Device;
        psHwIntData->u32ItemBitmap = u32ItemBitmap;

        sDemoData.sQueue.u8WritePtr = u8WriteNextPtr;
    }

    /* If no space on queue, interrupt is silently discarded */
}

/****************************************************************************
 *
 * NAME: JZA_vStackEvent
 *
 * DESCRIPTION:
 * Called when a miscellaneous stack event occurs.
 *
 * PARAMETERS:      Name          RW  Usage
 *                  eEventId      R   Event enumeration
 *                  puStackEvent  R   Event information
 *
 * RETURNS:
 * NULL
 *
 ****************************************************************************/
PUBLIC void JZA_vStackEvent(teJZS_EventIdentifier eEventId,
                            tuJZS_StackEvent *puStackEvent)
{
    switch (eEventId)
    {
    case JZS_EVENT_NWK_JOINED_AS_ROUTER:
        vAddDesc();
        sDemoData.bJoined = TRUE;
        break;

    default:
        break;
    }
}

/****************************************************************************/
/***        Local Functions                                               ***/
/****************************************************************************/
/****************************************************************************
 *
 * NAME: vInitDemoSystem
 *
 * DESCRIPTION:
 * Initialises Zigbee stack and hardware. Final action is to start BOS, from
 * which there is no return. Subsequent application actions occur in the
 * functions defined above.
 *
 * RETURNS:
 * No return from this function
 *
 ****************************************************************************/
PRIVATE void vInitDemoSystem(void)
{
    /* Initialise Zigbee stack */
    (void)JZS_u32InitSystem(TRUE);

    /* Set DIO for buttons and LEDs */
    vLedControl(0, TRUE);
    vLedControl(1, TRUE);
    vLedInitRfd();
    vButtonInitRfd();

    /* Enable interrupts for DIO buttons */
    vAHI_DioWakeEdge(0, BUTTON_ALL_MASK_RFD << BUTTON_BASE_BIT);
    vAHI_DioWakeEnable(BUTTON_ALL_MASK_RFD << BUTTON_BASE_BIT, 0);

    /* Set up interrupt for humidity/temp sensor (don't enable yet) */
    vAHI_DioWakeEdge(0, HTS_DATA_DIO_BIT_MASK);

    /* Set up peripheral hardware */
    vALSreset();
    vHTSreset();

    /* Start ALS now: it automatically keeps re-sampling after this */
    vALSstartReadChannel(0);

#if 0
    /* Calibrate wake timer */
    sDemoData.sSystem.u32CalibratedTimeout = ONE_SEC_IN_32K_PERIODS * 10000 / u32AHI_WakeTimerCalibrate();

    /* Enable timer to use for sequencing */
    vAHI_WakeTimerEnable(E_AHI_WAKE_TIMER_1, TRUE);
#endif

#if 1
    vAHI_UartEnable(E_AHI_UART_0);
    vAHI_UartReset(E_AHI_UART_0, TRUE, TRUE);
    vAHI_UartSetClockDivisor(E_AHI_UART_0, E_AHI_UART_RATE_115200);
    vAHI_UartReset(E_AHI_UART_0, FALSE, FALSE);
#endif

    /* Initialise software elements */
    vInitEndpoint();

    /* Start BOS */
    bBosRun(TRUE);
}

/****************************************************************************
 *
 * NAME: vAddDesc
 *
 * DESCRIPTION:
 * Initialises software structures and variables.
 *
 * RETURNS:
 * void
 *
 ****************************************************************************/
PRIVATE void vAddDesc(void)
{
    /* Sensor has 1 endpoint, only expects data from coordinator */
    uint8  u8DeviceVer = 0x00;
    uint8  u8Flags = 0x00;
    uint8  u8EndPoint = 0x40;
    uint16 u16DeviceId = 0x0000;

    uint8 u8InputClusterCnt = 1;
    uint8 au8InputClusterList[] = {DAP_CID_SWITCH};
    uint8 u8OutputClusterCnt = 0;
    uint8 au8OutputClusterList[] = {};

    (void)afmeSimpleDescAdd(u8EndPoint, DAP_PROFILE_ID, u16DeviceId,
                            u8DeviceVer, u8Flags, u8InputClusterCnt,
                            au8InputClusterList, u8OutputClusterCnt,
                            au8OutputClusterList);
}

/****************************************************************************
 *
 * NAME: vSendData
 *
 * DESCRIPTION:
 * Generates and sends a frame consisting of 4 KVP transactions, for the four
 * values that are passed to the controller. The destination address is fixed
 * as 0x0000 (coordinator) and the endpoint is also fixed.
 *
 * PARAMETERS: Name             RW  Usage
 *             u8LightValue     R   Value from light sensor
 *             u8TempValue      R   Value from temperature sensor
 *             u8HumidityValue  R   Value from humidity sensor
 *             u8Switch         R   Switch value (0 or 1)
 *
 ****************************************************************************/
PRIVATE void vSendData(uint8 u8LightValue, uint8 u8TempValue,
                       uint8 u8HumidityValue, uint8 u8Switch)
{
    uint8               u8SrcEP = 0x30;
    AF_Transaction_s    Transaction;
    APS_Addrmode_e      eAddrMode;
    uint16              u16DestAddr;
    uint8               u8DestEndpoint;
    uint8              *pu8Afdu;
    uint8               transCount = 1;
    uint8               *pu8ExtAdr;
    uint8               i;
#if 0
    uint8               u8TimerID;
#endif

    /* Set pointer to point to location in internal RAM where extended address
       is stored */
    pu8ExtAdr = (uint8 *)pvAppApiGetMacAddrLocation();

    eAddrMode = APS_ADDRMODE_SHORT;
    u16DestAddr = 0x0000;
    u8DestEndpoint = 0x40;

    Transaction.u8SequenceNum = u8AfGetTransactionSequence(TRUE);
    Transaction.uFrame.sKvp.eErrorCode = KVP_SUCCESS;
    Transaction.uFrame.sKvp.eCommandTypeID = SET;
    Transaction.uFrame.sKvp.eAttributeDataType = KVP_CHARACTER_STRING;
    Transaction.uFrame.sKvp.u16AttributeID = DAP_ATTR_SENSOR_DATA;
    Transaction.uFrame.sKvp.uAttributeData.CharacterString.u8CharacterCount = 13;

    pu8Afdu = Transaction.uFrame.sKvp.uAttributeData.CharacterString.au8CharacterData;

    /* Set length field */
    pu8Afdu[0] = 12;

    /* Load extended address into frame payload */
    for (i = 0; i < 8; i++)
    {
        pu8Afdu[i + 1] = *(pu8ExtAdr + i);
    }

    /* Load sensor data into frame payload */
    pu8Afdu[9]  = u8LightValue;
    pu8Afdu[10] = u8TempValue;
    pu8Afdu[11] = u8HumidityValue;
    pu8Afdu[12] = u8Switch;

    afdeDataRequest(eAddrMode,
                    u16DestAddr,
                    u8DestEndpoint,
                    u8SrcEP,
                    DAP_PROFILE_ID,
                    DAP_CID_SENSOR_READINGS,
                    AF_KVP,
                    transCount,
                    &Transaction,
                    APS_TXOPTION_NONE,
                    ENABLE_ROUTE_DISCOVERY,
                    0);
}

/****************************************************************************
 *
 * NAME: vStartReadSensors/vReadSensor2/vReadSensor3
 *
 * DESCRIPTION:
 * Gets the current readings from each sensor. Uses the DIO line for the HTS
 * sensor to signal when a value is ready to be read, as this allows the CPU
 * to doze during the reading calculation.
 *
 * RETURNS:
 * void
 *
 ****************************************************************************/
PRIVATE void vStartReadSensors(void *pvMessage, uint8 u8Len)
{
    sDemoData.sSystem.eState = E_STATE_READING_S1;

    /* Set wake timer for the next time that we want to read the sensors */
#if 1
    if (bBosCreateTimer(vStartReadSensors, NULL, 0, 50, NULL) == FALSE)
    {
        vSendData(eBosGetLastError(), 0xff, 0xff, 0xff);
    }
#else
    vAHI_WakeTimerStart(E_AHI_WAKE_TIMER_1, sDemoData.sSystem.u32CalibratedTimeout);
#endif

    /* Start to read temperature */
    vHTSstartReadTemp();

    /* Enable interrupt on DIO to tell when read has completed */
    vAHI_DioWakeEnable(HTS_DATA_DIO_BIT_MASK, 0);
}

PRIVATE void vReadSensor2(void)
{
    sDemoData.sSystem.eState = E_STATE_READING_S2;

    /* Clear interrupt on DIO */
    vAHI_DioWakeEnable(0, HTS_DATA_DIO_BIT_MASK);

    /* Read temperature, 0-52 are acceptable */
    sDemoData.sSensors.u8TempResult = u8FindMin((uint8)u16HTSreadTempResult(), 52);

    /* Start to read humidity */
    vHTSstartReadHumidity();

    /* Enable interrupt on DIO to tell when read has completed */
    vAHI_DioWakeEnable(HTS_DATA_DIO_BIT_MASK, 0);
}

PRIVATE void vReadSensor3(void)
{
    /* Clear interrupt on DIO */
    vAHI_DioWakeEnable(0, HTS_DATA_DIO_BIT_MASK);

    /* Read humidity, 0-104 are acceptable */
    sDemoData.sSensors.u8HtsResult = u8FindMin((uint8)u16HTSreadHumidityResult(), 104);

    /* Read light level, adjust to range 0-6 in a slightly non-linear way */
    sDemoData.sSensors.u8AlsResult = u8FindMin((uint8)(u16ALSreadChannelResult() >> 6), 6);

    /* Send the frame */
    vSendData(sDemoData.sSensors.u8AlsResult,
              sDemoData.sSensors.u8TempResult,
              sDemoData.sSensors.u8HtsResult,
              sDemoData.sControls.u8Switch);
}

/****************************************************************************
 *
 * NAME: vInitEndpoint
 *
 * DESCRIPTION:
 * Initialises software structures and variables.
 *
 * RETURNS:
 * void
 *
 ****************************************************************************/
PRIVATE void vInitEndpoint(void)
{
    /* Set defaults for software */
    sDemoData.sTransceiver.u8CurrentTxHandle = 0;
    sDemoData.sControls.u8Switch = 0;
    sDemoData.sControls.u8LightAlarmLevel = 0;
    sDemoData.sSensors.u8TempResult = 0;
    sDemoData.sSensors.u8HtsResult = 0;
    sDemoData.sSensors.u8AlsResult = 0;
    sDemoData.sSystem.eState = E_STATE_READY_TO_READ_SENSORS;
    sDemoData.sSystem.u16ShortAddr = 0xffff;
    sDemoData.sSystem.u8ThisNode = 0;
    sDemoData.sQueue.u8ReadPtr = 0;
    sDemoData.sQueue.u8WritePtr = 0;
    sDemoData.bJoined = FALSE;
}

/****************************************************************************
 *
 * NAME: u8FindMin
 *
 * DESCRIPTION:
 * Returns the smallest of two values.
 *
 * PARAMETERS:      Name    RW  Usage
 *                  u8Val1  R   First value to compare
 *                  u8Val2  R   Second value to compare
 *
 * RETURNS:
 * uint8, lowest of two input values
 *
 ****************************************************************************/
PRIVATE uint8 u8FindMin(uint8 u8Val1, uint8 u8Val2)
{
    if (u8Val1 < u8Val2)
    {
        return u8Val1;
    }
    return u8Val2;
}

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