AMiRo-OS

#include <v1/deca_instance_v1.h>

#include <string.h>

#include "module.h"

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

//

// function to construct the message/frame header bytes

//

  }

  //begin delayed TX of frame

    result = 1; //late/error

    inst->lateTX++;

  }

  return result;                                              // state changes

}

int instance_calcranges(uint32_t *array, uint16_t size, int reportRange, uint8_t* mask){

  int i;

  int newRange = TOF_REPORT_NUL;

      sleep_mode = (DWT_LOADUCODE|DWT_PRESRV_SLEEP|DWT_CONFIG|DWT_TANDV);

      if(inst->configData.txPreambLength == DWT_PLEN_64)  //if using 64 length preamble then use the corresponding OPSet

        sleep_mode |= DWT_LOADOPSET;

        dwt_seteui(inst->eui64);

      }

#else

#endif

      instancesetantennadelays(); //this will update the antenna delay if it has changed

          else {  //for anchor make the final half the delay ..... (this is ok, as A0 awaits 2 responses)

            tagCalculatedFinalTxTime =  (inst->txu.txTimeStamp + inst->pollTx2FinalTxDelayAnc) & MASK_TXDTS;

          }

          // Calculate Time Final message will be sent and write this field of Final message

          // Sending time will be delayedReplyTime, snapped to ~125MHz or ~250MHz boundary by

          // zeroing its low 9 bits, and then having the TX antenna delay added

        message = 0;

        //fall into the next case (turn on the RX)

      }

    }

    break ; // end case TA_TX_WAIT_CONF

      // end case TA_RXE_WAIT, don't break, but fall through into the TA_RX_WAIT_DATA state to process it immediately.

      if(message == 0) break;

    }

    break;

      //printf("TA_RX_WAIT_DATA %d", message) ;

      switch (message){

        //int srclen = 0;

        //int fctrladdr_len;

        uint8_t tof_idx  = 0;

        inst->stopTimer = 0; //clear the flag, as we have received a message

                }

              }

            }

            if(fcode == RTLS_DEMO_MSG_ANCH_RESP) { //tag to anchor mode

              if(currentRangeNum == inst->rangeNum) { //these are the previous ranges...

            uint64_t tagFinalRxTime  = 0;

            uint64_t tagPollTxTime  = 0;

            uint64_t anchorRespRxTime  = 0;

            double RaRbxDaDb = 0;

            double RbyDb = 0;

              RayDa = ((double)Ra + (double)Da);

            }

            //tag to anchor ranging

            if(RTLS_DEMO_MSG_TAG_FINAL == fcode) {

              inst->newRangeTagAddress = srcAddr[0] + ((uint16_t) srcAddr[1] << 8);

              //time-of-flight

              //calculate all tag - anchor ranges... and report

              inst->newRange = instance_calcranges(&inst->tofArray[0], MAX_ANCHOR_LIST_SIZE, TOF_REPORT_T2A, &inst->rxResponseMask);

              inst->rxResponseMaskReport = inst->rxResponseMask; //copy the valid mask to report

              inst->rxResponseMask = 0;

              //we have our range - update the own mask entry...

                setTagDist(srcAddr[0], inst->shortAdd_idx); //copy distance from this anchor to the tag into array

              }

              inst->newRangeTime = dw_event->uTimeStamp ;

            }

            else { //anchor to anchor ranging

              inst->newRangeTagAddress = srcAddr[0] + ((uint16_t) srcAddr[1] << 8);

              //time-of-flight

            }

            //reset the response count

  float msgdatalen = 0;

  float preamblelen = 0;

  int sfdlen = 0;

  //Set the RX timeouts based on the longest expected message - the Final message

  //Poll = 13, Response = 20, Final = 44 bytes

  //msgdatalen = TAG_FINAL_MSG_LEN + FRAME_CRTL_AND_ADDRESS_S + FRAME_CRC;

  msgdatalen = ANCH_RESPONSE_MSG_LEN + FRAME_CRTL_AND_ADDRESS_S + FRAME_CRC;

  msgdatalen = msgdatalen*8 + x*48;

  //add some margin so we don't timeout too soon

  margin = 0; //(TAG_FINAL_MSG_LEN - TAG_POLL_MSG_LEN);

  //assume PHR length is 172308ns for 110k and 21539ns for 850k/6.81M

  if(instance_data[instance].configData.dataRate == DWT_BR_110K) {

    preamblelen = (sfdlen + preamblelen) * 1.01763f;

  }

  //this is the delay used for the delayed transmit (when sending the response, and final messages)

  instance_data[instance].pollTx2FinalTxDelay = convertmicrosectodevicetimeu (delayus);

  //andhor 3 will have the delay set to 3 * fixedReplyDelayAnc and so on...

  //this delay depends on how quickly the tag can receive and process the message from previous anchor

  //(and also the frame length of course)

  if(instance_data[instance].configData.dataRate == DWT_BR_110K) {

    //set the frame wait timeout time - total time the frame takes in symbols

    instance_data[instance].fwtoTimeAnc_sy = respframe_sy; //add some margin so we don't timeout too soon

    instance_data[instance].fixedReplyDelayAnc = convertmicrosectodevicetimeu (respframe + RX_RESPONSE1_TURNAROUND_110K);

    instance_data[instance].ancRespRxDelay = RX_RESPONSE1_TURNAROUND_110K ;

  }

    instance_data[instance].fwtoTimeAnc_sy =  respframe_sy;

    instance_data[instance].fixedReplyDelayAnc = convertmicrosectodevicetimeu (respframe + RX_RESPONSE1_TURNAROUND_6M81);

    instance_data[instance].ancRespRxDelay = RX_RESPONSE1_TURNAROUND_6M81 ;

  }

}

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