Revision 33f54213

View differences:

include/DW1000/alld_DW1000.h
32 32

  
33 33
#if (AMIROLLD_CFG_DW1000 == 1)
34 34
    #include "v1/alld_dw1000_v1.h"
35
    #include "v1/alld_dw1000_regs_v1.h"
36
    #include "v1/deca_instance_v1.h"
37 35
#elif (AMIROLLD_CFG_DW1000 == 0)
38 36
    #error "DW1000 LLD implementation for v0 is not ready yet."
39 37
#else
include/DW1000/v1/alld_dw1000_v1.h
477 477
 *
478 478
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
479 479
 */
480
int dwt_initialise(uint16_t config) ;   // TODO
481
//int dwt_initialise(uint16_t config, DW1000Driver* drv) ;
480
//int dwt_initialise(uint16_t config) ;   // TODO
481
int dwt_initialise(uint16_t config, DW1000Driver* drv) ;
482 482

  
483 483
/*! ------------------------------------------------------------------------------------------------------------------
484 484
 * @fn dwt_configure()
......
1728 1728
 ****************************************************************************************************************************************************/
1729 1729

  
1730 1730

  
1731
/*! ------------------------------------------------------------------------------------------------------------------
1732
 * @fn writetospi()
1733
 *
1734
 * @brief
1735
 * NB: In porting this to a particular microprocessor, the implementer needs to define the two low
1736
 * level abstract functions to write to and read from the SPI.
1737
 * Low level abstract function to write to the SPI
1738
 * Takes two separate byte buffers for write header and write data
1739
 * returns 0 for success, or -1 for error
1740
 *
1741
 * Note: The body of this function is platform specific
1742
 *
1743
 * input parameters:
1744
 * @param headerLength  - number of bytes header being written
1745
 * @param headerBuffer  - pointer to buffer containing the 'headerLength' bytes of header to be written
1746
 * @param bodylength    - number of bytes data being written
1747
 * @param bodyBuffer    - pointer to buffer containing the 'bodylength' bytes od data to be written
1748
 *
1749
 * output parameters
1750
 *
1751
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
1752
 */
1753
extern int writetospi(uint16_t headerLength, const uint8_t *headerBuffer, uint32_t bodylength, const uint8_t *bodyBuffer);
1754

  
1755
/*! ------------------------------------------------------------------------------------------------------------------
1756
 * @fn readfromspi()
1757
 *
1758
 * @brief
1759
 * NB: In porting this to a particular microprocessor, the implementer needs to define the two low
1760
 * level abstract functions to write to and read from the SPI.
1761
 * Low level abstract function to write to the SPI
1762
 * Takes two separate byte buffers for write header and write data
1763
 * returns 0 for success, or -1 for error
1764
 *
1765
 * Note: The body of this function is platform specific
1766
 *
1767
 * input parameters:
1768
 * @param headerLength  - number of bytes header to write
1769
 * @param headerBuffer  - pointer to buffer containing the 'headerLength' bytes of header to write
1770
 * @param readlength    - number of bytes data being read
1771
 * @param readBuffer    - pointer to buffer containing to return the data (NB: size required = headerLength + readlength)
1772
 *
1773
 * output parameters
1774
 *
1775
 * returns DWT_SUCCESS for success (and the position in the buffer at which data begins), or DWT_ERROR for error
1776
 */
1777
extern int readfromspi(uint16_t headerLength, const uint8_t *headerBuffer, uint32_t readlength, uint8_t *readBuffer);
1778

  
1779 1731
// ---------------------------------------------------------------------------
1780 1732
//
1781 1733
// NB: The purpose of the deca_mutex.c file is to provide for microprocessor interrupt enable/disable, this is used for
......
1845 1797

  
1846 1798
void port_EnableEXT_IRQ(void);
1847 1799
void port_DisableEXT_IRQ(void);
1848
ITStatus port_GetEXT_IRQStatus(void);
1800
decaIrqStatus_t port_GetEXT_IRQStatus(void);
1801
//ITStatus port_GetEXT_IRQStatus(void);
1849 1802

  
1850 1803
void port_set_dw1000_slowrate(void);
1851 1804
void port_set_dw1000_fastrate(void);
......
1859 1812
#define DW1000_EXTI_IRQn    EXTI15_10_IRQn
1860 1813

  
1861 1814

  
1862
/**
1863
 * @brief   Flag to switch between two SPI speeds on the fly
1864
 */
1865
extern bool isHighSpeedSpi;
1866

  
1867

  
1868
/**
1869
 * @brief   Configuration for the Low Speed SPI interface driver to communicate with DW1000
1870
 */
1871
//extern SPIConfig moduleHalSpiUwbLsConfig;
1872

  
1873

  
1874
/**
1875
 * @brief   Configuration for the High Speed SPI interface driver to communicate with DW1000
1876
 */
1877
//extern SPIConfig moduleHalSpiUwbHsConfig;
1878

  
1879 1815
#endif /* defined(AMIROLLD_CFG_DW1000) && (AMIROLLD_CFG_DW1000 == 1) */
1880 1816

  
1881 1817
#endif //AMIROLLD_DW1000_V1_H
include/DW1000/v1/deca_instance_v1.h
470 470
  void instance_close(void);
471 471
  // Call init, then call config, then call run. call close when finished
472 472
  // initialise the instance (application) structures and DW1000 device
473
  int instance_init(void);
473
//  int instance_init(void);
474
  int instance_init(DW1000Driver* drv);     //TODO
475

  
474 476
  // configure the instance and DW1000 device
475 477
  void instance_config(instanceConfig_t *config, sfConfig_t *sfconfig) ;
476 478

  
......
528 530
  uint64_t convertmicrosectodevicetimeu (double microsecu);
529 531
  double convertdevicetimetosec(int32_t dt);
530 532

  
531
#define DWT_PRF_64M_RFDLY   (514.462f)
532
#define DWT_PRF_16M_RFDLY   (513.9067f)
533 533

  
534
  /* Extern declaration while defining the data in .c file */
534
  // -------------------------------------------------------------------------------------------------------------------
535
  // Deca Calibration Values
536
  // -------------------------------------------------------------------------------------------------------------------
537

  
538
  #define DWT_PRF_64M_RFDLY   (514.462f)
539
  #define DWT_PRF_16M_RFDLY   (513.9067f)
540

  
541
  /* Extern declaration while defining them in .c file */
535 542
  extern const uint16_t rfDelays[2];
536 543
  extern const uint16_t rfDelaysTREK[2];
537 544
  extern const tx_struct txSpectrumConfig[8];
538 545
  extern instance_data_t instance_data[NUM_INST] ;
539 546

  
547
  extern sfConfig_t sfConfig[4];
548
  extern instanceConfig_t chConfig[4];
549

  
540 550

  
541 551
  int instance_peekevent(void);
542 552

  
......
579 589

  
580 590
  int instance_starttxtest(int framePeriod);
581 591

  
592

  
593

  
582 594
#endif /* defined(AMIROLLD_CFG_DW1000) && (AMIROLLD_CFG_DW1000 == 1) */
583 595

  
584 596
#ifdef __cplusplus
source/DW1000/v1/alld_dw1000_v1.c
28 28
 *
29 29
 */
30 30

  
31

  
32 31
#include <alld_DW1000.h>
33 32

  
34 33
#if (defined(AMIROLLD_CFG_DW1000) && (AMIROLLD_CFG_DW1000 == 1)) || defined(__DOXYGEN__)
35 34

  
35
#include <v1/alld_dw1000_regs_v1.h>
36

  
36 37
#include <aos_thread.h>
37 38
#include <assert.h>
38 39
#include <string.h>
......
40 41
#include <math.h>
41 42

  
42 43

  
44
// HW dependent implementation (see bottom of file)
45
static int writetospi(uint16_t headerLength,
46
               const	uint8_t *headerBuffer,
47
               uint32_t bodyLength,
48
               const	uint8_t *bodyBuffer);
49

  
50
static int readfromspi(uint16_t headerLength,
51
                const uint8_t *headerBuffer,
52
                uint32_t readlength,
53
                uint8_t *readBuffer);
54

  
55

  
43 56
// Defines for enable_clocks function
44 57
#define FORCE_SYS_XTI  0
45 58
#define ENABLE_ALL_SEQ 1
......
57 70
#define FCTRL_LEN_MAX 2
58 71

  
59 72

  
60
/**
61
 * Move to the header file <alld_dw1000_v1.h>
62
*/
63
//#define NUM_BR 3
64
//#define NUM_PRF 2
65
//#define NUM_PACS 4
66
//#define NUM_BW 2            //2 bandwidths are supported
67
//#define NUM_SFD 2           //supported number of SFDs - standard = 0, non-standard = 1
68
//#define NUM_CH 6            //supported channels are 1, 2, 3, 4, 5, 7
69
//#define NUM_CH_SUPPORTED 8  //supported channels are '0', 1, 2, 3, 4, 5, '6', 7
70
//#define PCODES 25           //supported preamble codes
71

  
72

  
73 73
typedef struct {
74 74
    uint32_t lo32;
75 75
    uint16_t target[NUM_PRF];
......
1013 1013
#define VTEMP_ADDRESS  (0x09)
1014 1014
#define XTRIM_ADDRESS  (0x1E)
1015 1015

  
1016
//int dwt_initialise(const uint16_t config, DW1000Driver* drv)
1017
int dwt_initialise(const uint16_t config)  // TODO:
1016
int dwt_initialise(const uint16_t config, DW1000Driver* drv)
1017
//int dwt_initialise(const uint16_t config)  // TODO:
1018 1018
{
1019 1019
    uint16_t otp_addr = 0;
1020 1020
    uint32_t ldo_tune = 0;
......
1028 1028
    pdw1000local->cbRxTo = NULL;
1029 1029
    pdw1000local->cbRxErr = NULL;
1030 1030

  
1031
//    pdw1000local->driver = drv;  // TODO:
1031
    pdw1000local->driver = drv;  // TODO:
1032 1032

  
1033 1033
    // Read and validate device ID return -1 if not recognised
1034 1034
    if (DWT_DEVICE_ID != dwt_readdevid()) // MP IC ONLY (i.e. DW1000) FOR THIS CODE
......
1813 1813
    }
1814 1814

  
1815 1815
    // Write it to the SPI
1816
//    _alld_dw1000_writespi(cnt,header,length,buffer);
1817
    writetospi(cnt,header,length,buffer);  // TODO
1816
    writetospi(cnt,header,length,buffer);
1818 1817
} // end dwt_writetodevice()
1819 1818

  
1820 1819
/*! ------------------------------------------------------------------------------------------------------------------
......
1878 1877
    }
1879 1878

  
1880 1879
    // Do the read from the SPI
1881
//    _alld_dw1000_readspi(cnt, header, length, buffer);  // result is stored in the buffer
1882
    readfromspi(cnt, header, length, buffer);  // TODO:
1880
    readfromspi(cnt, header, length, buffer);
1883 1881
} // end dwt_readfromdevice()
1884 1882

  
1885 1883

  
......
4419 4417
 *
4420 4418
 ****************************************************************************************************************************************************/
4421 4419

  
4422
/*
4423
 * DW1000 Hardware dependent functions: SPI, EXTI
4424
 */
4420
/****************************************************************************//**
4421
 *
4422
 * 	alld_dw1000.c					SPI Section
4423
 *
4424
 *******************************************************************************/
4425 4425

  
4426 4426
/*! ------------------------------------------------------------------------------------------------------------------
4427 4427
 * Function: writetospi()
......
4431 4431
 * returns 0 for success, or -1 for error
4432 4432
 */
4433 4433
#pragma GCC optimize ("O3")
4434
int writetospi(uint16_t headerLength,
4434
static int writetospi(uint16_t headerLength,
4435 4435
               const	uint8_t *headerBuffer,
4436 4436
               uint32_t bodyLength,
4437 4437
               const	uint8_t *bodyBuffer)
4438 4438
{
4439 4439

  
4440
    port_SPIx_clear_chip_select();
4441

  
4442 4440
    uint8_t buffer[bodyLength + 3];
4443 4441
    memcpy(buffer, headerBuffer, headerLength); //copy data to buffer
4444 4442
    memcpy(&buffer[headerLength], bodyBuffer, bodyLength); //copy data to buffer
......
4447 4445
                    buffer,
4448 4446
                    bodyLength + headerLength); // send header and data
4449 4447

  
4450
    port_SPIx_set_chip_select();
4451

  
4452 4448
    return 0;
4453 4449
} // end writetospi()
4454 4450

  
4455 4451

  
4456

  
4457 4452
/*! ------------------------------------------------------------------------------------------------------------------
4458 4453
 * Function: readfromspi()
4459 4454
 *
......
4463 4458
 * or returns -1 if there was an error
4464 4459
 */
4465 4460
#pragma GCC optimize ("O3")
4466
int readfromspi(uint16_t headerLength,
4461
static int readfromspi(uint16_t headerLength,
4467 4462
                const uint8_t *headerBuffer,
4468 4463
                uint32_t readlength,
4469 4464
                uint8_t *readBuffer)
4470 4465
{
4471 4466

  
4472
    apalSPITransmitAndReceive(&MODULE_HAL_SPI_UWB,
4467
    apalSPITransmitAndReceive(&MODULE_HAL_SPI_UWB, // TODO: "pdw1000local->driver->spid" fails two spi configs
4473 4468
                              headerBuffer,
4474 4469
                              readBuffer,
4475 4470
                              headerLength,
......
4499 4494
 *
4500 4495
 * returns the state of the DW1000 interrupt
4501 4496
 */
4502
decaIrqStatus_t decamutexon(void)           
4497
decaIrqStatus_t decamutexon(void)
4503 4498
{
4504
    decaIrqStatus_t s = port_GetEXT_IRQStatus();
4505 4499

  
4506
    if(s) {
4507
        port_DisableEXT_IRQ(); //disable the external interrupt line
4508
    }
4509
    return s ;   // return state before disable, value is used to re-enable in decamutexoff call
4500
  decaIrqStatus_t s = port_GetEXT_IRQStatus();
4501
  if(s) {
4502
    port_DisableEXT_IRQ(); //disable the external interrupt line
4503
  }
4504
  return s ;   // return state before disable, value is used to re-enable in decamutexoff call
4510 4505
}
4511 4506

  
4512 4507
/*! ------------------------------------------------------------------------------------------------------------------
......
4526 4521
 */
4527 4522
void decamutexoff(decaIrqStatus_t s)
4528 4523
{
4529
//    (void) s;
4530
    if(s) { //need to check the port state as we can't use level sensitive interrupt on the STM ARM
4531
      port_EnableEXT_IRQ();
4532
    }
4533
//    return;
4524
//  (void) s;
4525
  if(s) { //need to check the port state as we can't use level sensitive interrupt on the STM ARM
4526
    port_EnableEXT_IRQ();
4527
  }
4528
  return;
4534 4529
}
4535 4530

  
4536 4531

  
......
4540 4535

  
4541 4536
void deca_sleep(unsigned int time_ms)
4542 4537
{
4543
    aosThdMSleep(time_ms);
4538
  aosThdMSleep(time_ms);
4544 4539
}
4545 4540

  
4546 4541
void Sleep(unsigned int time_ms)
4547 4542
{
4548
    aosThdMSleep(time_ms);
4543
  aosThdMSleep(time_ms);
4549 4544
}
4550 4545

  
4551 4546

  
4552
void port_set_dw1000_slowrate(){ // replaced with setHighSpeed_SPI(bool speedValue) implemented in module.c
4553
    return;
4554
}
4555

  
4556
void port_set_dw1000_fastrate(){ // replaced with setHighSpeed_SPI(bool speedValue) implemented in module.c
4557
    return;
4558
}
4559

  
4560 4547
void port_wakeup_dw1000_fast(){ // NOT SUPPORTED
4561
    return;
4548
  return;
4562 4549
}
4563 4550

  
4564 4551
uint32_t portGetTickCnt(){
4565
    return chVTGetSystemTimeX();
4552
  return chVTGetSystemTimeX();
4566 4553
}
4567 4554

  
4568 4555
//inline uint32_t portGetTickCnt(){
......
4571 4558

  
4572 4559

  
4573 4560
void port_DisableEXT_IRQ(void){   
4574
   nvicDisableVector(DW1000_EXTI_IRQn);
4561
  nvicDisableVector(DW1000_EXTI_IRQn);
4575 4562

  
4576 4563
}
4577 4564

  
4578 4565
void port_EnableEXT_IRQ(void){    
4579
    nvicEnableVector(DW1000_EXTI_IRQn, STM32_IRQ_EXTI10_15_PRIORITY);
4566
  nvicEnableVector(DW1000_EXTI_IRQn, STM32_IRQ_EXTI10_15_PRIORITY);
4580 4567
}
4581 4568

  
4582 4569

  
4583
ITStatus port_GetEXT_IRQStatus(void){
4584
  ITStatus bitstatus = RESET;
4585
  //  uint32_t enablestatus = 0;
4570
decaIrqStatus_t port_GetEXT_IRQStatus(void){
4571
  decaIrqStatus_t bitstatus = RESET;
4586 4572

  
4587 4573
  if(NVIC_GetActive(DW1000_EXTI_IRQn)|| NVIC_GetPendingIRQ(DW1000_EXTI_IRQn)){
4588 4574
    //  if(NVIC_GetPendingIRQ(EXTI15_10_IRQn)){ //if the interrupt is pending (background )
4589 4575
    bitstatus = SET; //Interrupt is active or panding
4590 4576
  }
4591 4577
  else {
4592
    bitstatus = RESET; //Currently there is no interrupt IRQ
4578
    bitstatus = RESET; //No interrupt IRQ at the moment
4593 4579
  }
4594 4580

  
4595 4581
  return bitstatus;
4596 4582
}
4597 4583

  
4598

  
4599

  
4600 4584
#endif /* defined(AMIROLLD_CFG_DW1000) && (AMIROLLD_CFG_DW1000 == 1) */
source/DW1000/v1/deca_instance_common_v1.c
18 18
#include "module.h"
19 19
#include <string.h>
20 20
#include <math.h>
21
#include <v1/deca_instance_v1.h>
22

  
23

  
24
/*! @brief Software defined configuration settings for RTLS applications */
25
/*! Configuration for DecaRangeRTLS TREK Modes (4 default use cases selected by the switch S1 [2,3] on EVB1000, indexed 0 to 3 )*/
26
instanceConfig_t chConfig[4] ={
27
                               //mode 1 - S1: 2 off, 3 off
28
                               {
29
                                .channelNumber = 2,             // channel
30
                                .preambleCode = 4,              // preambleCode
31
                                .pulseRepFreq = DWT_PRF_16M,    // prf
32
                                .dataRate = DWT_BR_110K,        // datarate
33
                                .preambleLen = DWT_PLEN_1024,   // preambleLength
34
                                .pacSize = DWT_PAC32,           // pacSize
35
                                .nsSFD = 1,                     // non-standard SFD
36
                                .sfdTO = (1025 + 64 - 32)       // SFD timeout
37
                               },
38
                               //mode 2 - S1: 2 on, 3 off
39
                               {
40
                                .channelNumber = 2,            // channel
41
                                .preambleCode = 4,             // preambleCode
42
                                .pulseRepFreq = DWT_PRF_16M,   // prf
43
                                .dataRate = DWT_BR_6M8,        // datarate
44
                                .preambleLen = DWT_PLEN_128,   // preambleLength
45
                                .pacSize = DWT_PAC8,           // pacSize
46
                                .nsSFD = 0,                    // non-standard SFD
47
                                .sfdTO = (129 + 8 - 8)        // SFD timeout
48
                               },
49
                               //mode 3 - S1: 2 off, 3 on
50
                               {
51
                                .channelNumber = 5,             // channel
52
                                .preambleCode = 3,              // preambleCode
53
                                .pulseRepFreq = DWT_PRF_16M,    // prf
54
                                .dataRate = DWT_BR_110K,        // datarate
55
                                .preambleLen = DWT_PLEN_1024,   // preambleLength
56
                                .pacSize = DWT_PAC32,           // pacSize
57
                                .nsSFD = 1,                     // non-standard SFD
58
                                .sfdTO = (1025 + 64 - 32)       // SFD timeout
59
                               },
60
                               //mode 4 - S1: 2 on, 3 on
61
                               {
62
                                .channelNumber = 5,            // channel
63
                                .preambleCode = 3,             // preambleCode
64
                                .pulseRepFreq = DWT_PRF_16M,   // prf
65
                                .dataRate = DWT_BR_6M8,        // datarate
66
                                .preambleLen = DWT_PLEN_128,   // preambleLength
67
                                .pacSize = DWT_PAC8,           // pacSize
68
                                .nsSFD = 0,                    // non-standard SFD
69
                                .sfdTO = (129 + 8 - 8)        // SFD timeout
70
                               }
71
};
21 72

  
22 73

  
23
extern double dwt_getrangebias(uint8_t chan, float range, uint8_t prf);
24

  
25
extern const uint16_t rfDelays[2];
26
extern const uint16_t rfDelaysTREK[2];
27
extern const tx_struct txSpectrumConfig[8];
28

  
29

  
30

  
31
// -------------------------------------------------------------------------------------------------------------------
32
// Deca Calibration Values
33
// -------------------------------------------------------------------------------------------------------------------
74
/*! Slot and Superframe Configuration for DecaRangeRTLS TREK Modes (4 default use cases selected by the switch S1 [2,3] on EVB1000, indexed 0 to 3 )*/
75
sfConfig_t sfConfig[4] ={
76
                         //mode 1 - S1: 2 off, 3 off
77
                         {
78
                          .slotPeriod = (28), //slot duration in milliseconds (NOTE: the ranging exchange must be able to complete in this time
79
                          //e.g. tag sends a poll, 4 anchors send responses and tag sends the final + processing time
80
                          .numSlots = (10),        //number of slots in the superframe (8 tag slots and 2 used for anchor to anchor ranging),
81
                          .sfPeriod = (10*28),  //in ms => 280ms frame means 3.57 Hz location rate
82
                          .pollSleepDly = (10*28), //tag period in ms (sleep time + ranging time)
83
                          .replyDly = (25000) //poll to final delay in microseconds (needs to be adjusted according to lengths of ranging frames)
84
                         },
85
#if (DISCOVERY == 1)
86
                         //mode 2 - S1: 2 on, 3 off
87
                         {
88
                          .slotPeriod = (10), //slot duration in milliseconds (NOTE: the ranging exchange must be able to complete in this time
89
                          //e.g. tag sends a poll, 4 anchors send responses and tag sends the final + processing time
90
                          .numSlots = (100),        //number of slots in the superframe (98 tag slots and 2 used for anchor to anchor ranging),
91
                          .sfPeriod = (10*100),  //in ms => 1000 ms frame means 1 Hz location rate
92
                          .pollSleepDly = (10*100), //tag period in ms (sleep time + ranging time)
93
                          .replyDly = (2500) //poll to final delay in microseconds (needs to be adjusted according to lengths of ranging frames)
94

  
95
                         },
96
#else
97
                         //mode 2 - S1: 2 on, 3 off
98
                         {
99
                          .slotPeriod = (10), //slot duration in milliseconds (NOTE: the ranging exchange must be able to complete in this time
100
                          //e.g. tag sends a poll, 4 anchors send responses and tag sends the final + processing time
101
                          .numSlots = (10),        //number of slots in the superframe (8 tag slots and 2 used for anchor to anchor ranging),
102
                          .sfPeriod = (10*10),  //in ms => 100 ms frame means 10 Hz location rate
103
                          .pollSleepDly = (10*10), //tag period in ms (sleep time + ranging time)
104
                          .replyDly = (2500) //poll to final delay in microseconds (needs to be adjusted according to lengths of ranging frames)
105
                         },
106
#endif
107
                         //mode 3 - S1: 2 off, 3 on
108
                         {
109
                          .slotPeriod = (28), //slot duration in milliseconds (NOTE: the ranging exchange must be able to complete in this time
110
                          //e.g. tag sends a poll, 4 anchors send responses and tag sends the final + processing time
111
                          .numSlots = (10),        //number of slots in the superframe (8 tag slots and 2 used for anchor to anchor ranging),
112
                          .sfPeriod = (10*28),  //in ms => 280ms frame means 3.57 Hz location rate
113
                          .pollSleepDly = (10*28), //tag period in ms (sleep time + ranging time)
114
                          .replyDly = (20000) //poll to final delay in microseconds (needs to be adjusted according to lengths of ranging frames)
115

  
116
                         },
117
                         //mode 4 - S1: 2 on, 3 on
118
                         {
119
                          .slotPeriod = (10), //slot duration in milliseconds (NOTE: the ranging exchange must be able to complete in this time
120
                          //e.g. tag sends a poll, 4 anchors send responses and tag sends the final + processing time
121
                          .numSlots = (10),        //number of slots in the superframe (8 tag slots and 2 used for anchor to anchor ranging),
122
                          .sfPeriod = (10*10),  //in ms => 100 ms frame means 10 Hz location rate
123
                          .pollSleepDly = (10*10), //tag period in ms (sleep time + ranging time)
124
                          .replyDly = (2500) //poll to final delay in microseconds (needs to be adjusted according to lengths of ranging frames)
125
                         }
126
};
34 127

  
35
#define DWT_PRF_64M_RFDLY   (514.462f)
36
#define DWT_PRF_16M_RFDLY   (513.9067f)
37 128

  
38 129
// -------------------------------------------------------------------------------------------------------------------
39 130

  
......
341 432
// function to initialise instance structures
342 433
//
343 434
// Returns 0 on success and -1 on error
344
int instance_init(void){
435
//int instance_init(void){   // TODO
436
int instance_init(DW1000Driver* drv){
345 437
  int instance = 0 ;
346 438
  int i;
347 439
  int result;
......
356 448
  //dwt_softreset();
357 449

  
358 450
  //this initialises DW1000 and uses specified configurations from OTP/ROM
359
  result = dwt_initialise(DWT_LOADUCODE) ;
451
  result = dwt_initialise(DWT_LOADUCODE, drv) ;    // TODO
452
//  result = dwt_initialise(DWT_LOADUCODE) ;
360 453

  
361 454
  //this is platform dependent - only program if DW EVK/EVB
362 455
  dwt_setleds(3) ; //configure the GPIOs which control the leds on EVBs
source/DW1000/v1/deca_instance_tag_anchor_v1.c
15 15

  
16 16
#if (defined(AMIROLLD_CFG_DW1000) && (AMIROLLD_CFG_DW1000 == 1)) || defined(__DOXYGEN__)
17 17

  
18
#include <v1/deca_instance_v1.h>
18 19
#include <string.h>
19 20
#include<math.h>
20 21
#include "module.h"

Also available in: Unified diff