homedemoenddevice.c

wireless jennic application note

        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);

    /* Enable timer to use for sequencing */
    if (bColdStart == TRUE)
    {
        /* Calibrate wake timer */
        sDemoData.sSystem.u32CalibratedTimeout
            = ONE_SEC_IN_32K_PERIODS * 10000 / u32AHI_WakeTimerCalibrate();
        vAHI_WakeTimerEnable(E_AHI_WAKE_TIMER_1, TRUE);
    }

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

/****************************************************************************
 *
 * 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);

    vSleep();

}

/****************************************************************************
 *
 * 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)
{
    sDemoData.sSystem.eState = E_STATE_READING_S1;

    /* Set wake timer for the next time that we want to read the sensors */
    vAHI_WakeTimerStart(E_AHI_WAKE_TIMER_1,
                        sDemoData.sSystem.u32CalibratedTimeout * 1);

    /* 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.sSensors.u8TempResult = 0;
    sDemoData.sSensors.u8HtsResult = 0;
    sDemoData.sSensors.u8AlsResult = 0;
    sDemoData.sSystem.eState = E_STATE_READY_TO_READ_SENSORS;
    sDemoData.sQueue.u8ReadPtr = 0;
    sDemoData.sQueue.u8WritePtr = 0;
    sDemoData.bJoined = FALSE;
    sDemoData.bRejoining = FALSE;
}

/****************************************************************************
 *
 * 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: 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;
}

/****************************************************************************
 *
 * NAME: vSleep
 *
 * DESCRIPTION: Sends device to light sleep.
 *
 * RETURNS:
 * void
 *
 ****************************************************************************/
PRIVATE void vSleep(void)
{
#if 0 /* Enable sleep operation: if #if 0, everything still works but never
         sleeps */

    /* Turn off LEDs to save power */
    vLedControl(0, FALSE);
    vLedControl(1, FALSE);

    /* Power down: device will wake up from wake timer 1, which was set
       in vStartReadSensors */
    vBosRequestSleep(TRUE);
#endif
}



#ifdef TEST_BOS_TIMER
PRIVATE void vTimerFired0(void *pvMessage, uint8 u8Len)
{
    uint8 u8Dummy;

    u8LedFlash0 = 1 - u8LedFlash0;
    vLedControl(0, u8LedFlash0);

    bBosCreateTimer(vTimerFired0, NULL, 0, 10, &u8Dummy);
}

PRIVATE void vTimerFired1(void *pvMessage, uint8 u8Len)
{
    uint8 u8Dummy;

    u8LedFlash1 = 1 - u8LedFlash1;
    vLedControl(1, u8LedFlash1);

    bBosCreateTimer(vTimerFired1, NULL, 0, 15, &u8Dummy);
}
#endif

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