AMiRo-OS

/*! ----------------------------------------------------------------------------

 *  @file    instance_tag.c

 *  @brief   Decawave tag application state machine for TREK demo

 *

 * @attention

 *

 * Copyright 2016 (c) Decawave Ltd, Dublin, Ireland.

 *

 * All rights reserved.

 *

 * @author Decawave

 */

#include <deca_instance.h>

#if defined(AMIROLLD_CFG_USE_DW1000) || defined(__DOXYGEN__)

#include <alld_dw1000.h>

#include <alld_dw1000_regs.h>

#include <string.h>

// -------------------------------------------------------------------------------------------------------------------

//      Data Definitions

// -------------------------------------------------------------------------------------------------------------------

// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

// NOTE: the maximum RX timeout is ~ 65ms

// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

// -------------------------------------------------------------------------------------------------------------------

// Functions

// -------------------------------------------------------------------------------------------------------------------

/**

 * @brief this function either enables the receiver (delayed)

 *

 **/

void tag_enable_rx(uint32_t dlyTime)

{

        instance_data_t* inst = instance_get_local_structure_ptr(0);

        //subtract preamble duration (because when instructing delayed TX the time is the time of SFD,

        //however when doing delayed RX the time is RX on time)

        dwt_setdelayedtrxtime(dlyTime - inst->preambleDuration32h) ;

        if(dwt_rxenable(DWT_START_RX_DELAYED|DWT_IDLE_ON_DLY_ERR)) //delayed rx

        {

                //if the delayed RX failed - time has passed - do immediate enable

                //led_on(LED_PC9);

                dwt_setpreambledetecttimeout(0); //clear preamble timeout as RX is turned on early/late

        dwt_setrxtimeout((uint16_t)inst->fwto4RespFrame_sy*2); //reconfigure the timeout before enable

                //longer timeout as we cannot do delayed receive... so receiver needs to stay on for longer

                dwt_rxenable(DWT_START_RX_IMMEDIATE);

                dwt_setpreambledetecttimeout(PTO_PACS); //configure preamble timeout

        dwt_setrxtimeout((uint16_t)inst->fwto4RespFrame_sy); //restore the timeout for next RX enable

                //inst->lateRX++;

                //led_off(LED_PC9);

        }

}

/* @fn           instanceProcessRXTimeoutTag

 * @brief function to process RX timeout event

 * */

void tag_process_rx_timeout(instance_data_t *inst)

{

    //inst->rxTimeouts ++ ;

#if(DISCOVERY == 1)

    if(inst->twrMode == GREETER)

    {

            inst->instToSleep = TRUE ;

                // initiate the re-transmission of the poll that was not responded to

                inst->testAppState = TA_TXE_WAIT ;

                inst->nextState = TA_TXBLINK_WAIT_SEND ;

    }

    else

#endif

    {

#if (TAG_HASTO_RANGETO_A0 == 0)

        if(inst->rxResponseMask == 0) //if any response have been received send a Final else go to SLEEP

        {

                  inst->instToSleep = TRUE ; //set sleep to TRUE so that tag will go to DEEP SLEEP before next ranging attempt

                inst->testAppState = TA_TXE_WAIT ;

                inst->nextState = TA_TXPOLL_WAIT_SEND ;

        }

#else

        //if tag times out - no response (check if we are to send a final)

        //send the final only if it has received response from anchor 0

        if((inst->previousState == TA_TXPOLL_WAIT_SEND)

                        && ((inst->rxResponseMask & 0x1) == 0)

                        )

        {

                inst->instToSleep = TRUE ; //set sleep to TRUE so that tag will go to DEEP SLEEP before next ranging attempt

                inst->testAppState = TA_TXE_WAIT ;

                inst->nextState = TA_TXPOLL_WAIT_SEND ;

        }

#endif

        else if (inst->previousState == TA_TXFINAL_WAIT_SEND) //got here from main (error sending final - handle as timeout)

        {

                dwt_forcetrxoff();        //this will clear all events

                inst->instToSleep = TRUE ;

                // initiate the re-transmission of the poll that was not responded to

                inst->testAppState = TA_TXE_WAIT ;

                inst->nextState = TA_TXPOLL_WAIT_SEND ;

        }

        else //send the final

        {

                // initiate the transmission of the final

                inst->testAppState = TA_TXE_WAIT ;

                inst->nextState = TA_TXFINAL_WAIT_SEND ;

        }

    }

}

/**

 * @brief function to re-enable the receiver and also adjust the timeout before sending the final message

 * if it is time so send the final message, the callback will notify the application, else the receiver is

 * automatically re-enabled

 *

 * this function is only used for tag when ranging to other anchors

 */

uint8_t tag_rx_reenable(uint16_t sourceAddress, uint8_t error)

{

    uint8_t type_pend = DWT_SIG_DW_IDLE;

    uint8_t anc = sourceAddress & 0x3;

        instance_data_t* inst = instance_get_local_structure_ptr(0);

        switch(anc)

        {

                //if we got Response from anchor 3 - this is the last expected response - send the final

                case 3:

                        type_pend = DWT_SIG_DW_IDLE;

                        break;

                //if we got response from anchor 0, 1, or 2 - go back to wait for next anchor's response

                //if we got response from 0, then still expecting 3, so remainingRespToRx set to 3

                case 0:

                case 1:

                case 2:

                default:

                        if(inst->remainingRespToRx > 0) //can get here as result of error frame so need to check

                        {

                                //can't use anc address as this is an error frame, so just re-enable TO based on remainingRespToRx count

                                if(error == 0)

                                {

                                        switch (anc)

                                        {

                                                case 0:

                                                        inst->remainingRespToRx = 3; //expecting 3 more responses

                                                        break;

                                                case 1:

                                                        inst->remainingRespToRx = 2; //expecting 2 more responses

                                                        break;

                                                case 2:

                                                        inst->remainingRespToRx = 1; //expecting 1 more response

                                                        break;

                                        }

                                }

                                //Poll sent at tagPollTxTime_32bit

                                //1st response is delayTime + fixedReplyDelayAnc32h - preambleDuration_32MSBs

                                //2nd is delayTime + fixedReplyDelayAnc32h - preambleDuration_32MSBs + fixedReplyDelayAnc32h

                                tag_enable_rx(inst->tagPollTxTime32h +

                                                (MAX_ANCHOR_LIST_SIZE-inst->remainingRespToRx+1)*(inst->fixedReplyDelayAnc32h));

                                type_pend = DWT_SIG_RX_PENDING ;

                        }

                        else //finished waiting for responses - no responses left to receive... send a final

                        {

                                type_pend = DWT_SIG_DW_IDLE; //report timeout - send the final if due to be sent

                        }

                        break;

        }

        return type_pend;

}

/**

 * @brief this function handles frame error event, it will either signal TO or re-enable the receiver

 */

void tag_handle_error_unknownframe(event_data_t dw_event)

{

        instance_data_t* inst = instance_get_local_structure_ptr(0);

        if(inst->twrMode != GREETER)

        {

                //re-enable the receiver (after error frames as we are not using auto re-enable

                //for ranging application rx error frame is same as TO - as we are not going to get the expected frame

                inst->remainingRespToRx--; //got something (need to reduce timeout (for remaining responses))

                dw_event.typePend = tag_rx_reenable(0, 1); //check if receiver will be re-enabled or it's time to send the final

        }

        else

        {

                dw_event.typePend = DWT_SIG_DW_IDLE; //in GREETER mode only waiting for 1 frame

        }

        dw_event.type = 0;

        //dw_event.typeSave = 0x40 | DWT_SIG_RX_TIMEOUT;

        dw_event.rxLength = 0;

        instance_putevent(dw_event, DWT_SIG_RX_TIMEOUT);

}

/**

 * @brief this is the receive timeout event callback handler

 */

void rx_to_cb_tag(const dwt_cb_data_t *rxd)

{

    (void) rxd;

        event_data_t dw_event;

        //microcontroller time at which we received the frame

    dw_event.uTimeStamp = portGetTickCnt();

    tag_handle_error_unknownframe(dw_event);

}

/**

 * @brief this is the receive error event callback handler

 */

void rx_err_cb_tag(const dwt_cb_data_t *rxd)

{

    (void) rxd;

        event_data_t dw_event;

        //microcontroller time at which we received the frame

    dw_event.uTimeStamp = portGetTickCnt();

    tag_handle_error_unknownframe(dw_event);

}

/**

 * @brief this is the receive event callback handler, the received event is processed and the instance either

 * responds by sending a response frame or re-enables the receiver to await the next frame

 * once the immediate action is taken care of the event is queued up for application to process

 */

void rx_ok_cb_tag(const dwt_cb_data_t *rxd)

{

        instance_data_t* inst = instance_get_local_structure_ptr(0);

    uint8_t rxTimeStamp[5]  = {0, 0, 0, 0, 0};

    uint8_t rxd_event = 0;

    uint8_t fcode_index  = 0;

    uint8_t srcAddr_index = 0;

        event_data_t dw_event;