Statistics
| Branch: | Tag: | Revision:

amiro-lld / include / alld_dw1000.h @ f125ae07

History | View | Annotate | Download (75.6 KB)

1
/*
2
AMiRo-LLD is a compilation of low-level hardware drivers for the Autonomous Mini Robot (AMiRo) platform.
3
Copyright (C) 2016..2019  Thomas Schöpping et al.
4

5
This program is free software: you can redistribute it and/or modify
6
it under the terms of the GNU Lesser General Public License as published by
7
the Free Software Foundation, either version 3 of the License, or
8
(at your option) any later version.
9

10
This program is distributed in the hope that it will be useful,
11
but WITHOUT ANY WARRANTY; without even the implied warranty of
12
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
GNU Lesser General Public License for more details.
14

15
You should have received a copy of the GNU Lesser General Public License
16
along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
*/
18

    
19
/*! ----------------------------------------------------------------------------
20
 * @file    deca_device_api.h
21
 * @brief   DW1000 API Functions
22
 *
23
 * @attention
24
 *
25
 * Copyright 2013 (c) Decawave Ltd, Dublin, Ireland.
26
 *
27
 * All rights reserved.
28
 *
29
 */
30

    
31
#ifndef __AMIROLLD_DW1000_H__
32
#define __AMIROLLD_DW1000_H__
33

    
34
#include <amiro-lld.h>
35
#if defined(AMIROLLD_CFG_USE_DW1000) || defined(__DOXYGEN__)
36

    
37

    
38

    
39
#include <stddef.h>
40
#include <stdint.h>
41
#include <stdbool.h>
42

    
43
#define DW1000_DRIVER_VERSION               0x040005
44
#define DW1000_DEVICE_DRIVER_VER_STRING     "DW1000 Device Driver Version 04.00.05"
45

    
46
#ifndef DWT_NUM_DW_DEV
47
#define DWT_NUM_DW_DEV (1)
48
#endif
49

    
50
#define DWT_SUCCESS (0)
51
#define DWT_ERROR   (-1)
52

    
53

    
54
/**
55
 * @brief The DW1000 driver struct.
56
 */
57
typedef struct {
58
  apalSPIDriver_t* spid;    /**< @brief The SPI Driver */
59
  apalGpio_t* gpio_exti;    /**< @brief The GPIO indicating external interrupt */
60
  apalGpio_t* gpio_reset;  /**< @brief The GPIO indicating reset sig*/
61
  /* TODO: better apalControlGpio_t instead of apalGpio_t ? */
62
  /* TODO: EXTI, GPIO (RESET) */
63
} DW1000Driver;
64

    
65

    
66
#define DWT_TIME_UNITS  (1.0/499.2e6/128.0) //!< = 15.65e-12 s
67

    
68
#define DWT_DEVICE_ID   (0xDECA0130)        //!< DW1000 MP device ID
69

    
70
#define BUFFLEN         (4096+128)
71

    
72
//! constants for selecting the bit rate for data TX (and RX)
73
//! These are defined for write (with just a shift) the TX_FCTRL register
74
#define DWT_BR_110K     0   //!< UWB bit rate 110 kbits/s
75
#define DWT_BR_850K     1   //!< UWB bit rate 850 kbits/s
76
#define DWT_BR_6M8      2   //!< UWB bit rate 6.8 Mbits/s
77

    
78
//! constants for specifying the (Nominal) mean Pulse Repetition Frequency
79
//! These are defined for direct write (with a shift if necessary) to CHAN_CTRL and TX_FCTRL regs
80
#define DWT_PRF_16M     1   //!< UWB PRF 16 MHz
81
#define DWT_PRF_64M     2   //!< UWB PRF 64 MHz
82

    
83
//! constants for specifying Preamble Acquisition Chunk (PAC) Size in symbols
84
#define DWT_PAC8        0   //!< PAC  8 (recommended for RX of preamble length  128 and below
85
#define DWT_PAC16       1   //!< PAC 16 (recommended for RX of preamble length  256
86
#define DWT_PAC32       2   //!< PAC 32 (recommended for RX of preamble length  512
87
#define DWT_PAC64       3   //!< PAC 64 (recommended for RX of preamble length 1024 and up
88

    
89
//! constants for specifying TX Preamble length in symbols
90
//! These are defined to allow them be directly written into byte 2 of the TX_FCTRL register
91
//! (i.e. a four bit value destined for bits 20..18 but shifted left by 2 for byte alignment)
92
#define DWT_PLEN_4096   0x0C    //! Standard preamble length 4096 symbols
93
#define DWT_PLEN_2048   0x28    //! Non-standard preamble length 2048 symbols
94
#define DWT_PLEN_1536   0x18    //! Non-standard preamble length 1536 symbols
95
#define DWT_PLEN_1024   0x08    //! Standard preamble length 1024 symbols
96
#define DWT_PLEN_512    0x34    //! Non-standard preamble length 512 symbols
97
#define DWT_PLEN_256    0x24    //! Non-standard preamble length 256 symbols
98
#define DWT_PLEN_128    0x14    //! Non-standard preamble length 128 symbols
99
#define DWT_PLEN_64     0x04    //! Standard preamble length 64 symbols
100

    
101
#define DWT_SFDTOC_DEF              0x1041  // default SFD timeout value
102

    
103
#define DWT_PHRMODE_STD             0x0     // standard PHR mode
104
#define DWT_PHRMODE_EXT             0x3     // DW proprietary extended frames PHR mode
105

    
106
// Defined constants for "mode" bitmask parameter passed into dwt_starttx() function.
107
#define DWT_START_TX_IMMEDIATE      0
108
#define DWT_START_TX_DELAYED        1
109
#define DWT_RESPONSE_EXPECTED       2
110

    
111
#define DWT_START_RX_IMMEDIATE  0
112
#define DWT_START_RX_DELAYED    1    // Set up delayed RX, if "late" error triggers, then the RX will be enabled immediately
113
#define DWT_IDLE_ON_DLY_ERR     2    // If delayed RX failed due to "late" error then if this
114
                                     // flag is set the RX will not be re-enabled immediately, and device will be in IDLE when function exits
115
#define DWT_NO_SYNC_PTRS        4    // Do not try to sync IC side and Host side buffer pointers when enabling RX. This is used to perform manual RX
116
                                     // re-enabling when receiving a frame in double buffer mode.
117

    
118
// Defined constants for "mode" bit field parameter passed to dwt_setleds() function.
119
#define DWT_LEDS_DISABLE     0x00
120
#define DWT_LEDS_ENABLE      0x01
121
#define DWT_LEDS_INIT_BLINK  0x02
122

    
123
//frame filtering configuration options
124
#define DWT_FF_NOTYPE_EN            0x000           // no frame types allowed (FF disabled)
125
#define DWT_FF_COORD_EN             0x002           // behave as coordinator (can receive frames with no dest address (PAN ID has to match))
126
#define DWT_FF_BEACON_EN            0x004           // beacon frames allowed
127
#define DWT_FF_DATA_EN              0x008           // data frames allowed
128
#define DWT_FF_ACK_EN               0x010           // ack frames allowed
129
#define DWT_FF_MAC_EN               0x020           // mac control frames allowed
130
#define DWT_FF_RSVD_EN              0x040           // reserved frame types allowed
131

    
132
//DW1000 interrupt events
133
#define DWT_INT_TFRS            0x00000080          // frame sent
134
#define DWT_INT_LDED            0x00000400          // micro-code has finished execution
135
#define DWT_INT_RFCG            0x00004000          // frame received with good CRC
136
#define DWT_INT_RPHE            0x00001000          // receiver PHY header error
137
#define DWT_INT_RFCE            0x00008000          // receiver CRC error
138
#define DWT_INT_RFSL            0x00010000          // receiver sync loss error
139
#define DWT_INT_RFTO            0x00020000          // frame wait timeout
140
#define DWT_INT_RXOVRR          0x00100000          // receiver overrun
141
#define DWT_INT_RXPTO           0x00200000          // preamble detect timeout
142
#define DWT_INT_SFDT            0x04000000          // SFD timeout
143
#define DWT_INT_ARFE            0x20000000          // frame rejected (due to frame filtering configuration)
144

    
145

    
146
//DW1000 SLEEP and WAKEUP configuration parameters
147
#define DWT_PRESRV_SLEEP 0x0100                      // PRES_SLEEP - on wakeup preserve sleep bit
148
#define DWT_LOADOPSET    0x0080                      // ONW_L64P - on wakeup load operating parameter set for 64 PSR
149
#define DWT_CONFIG       0x0040                      // ONW_LDC - on wakeup restore (load) the saved configurations (from AON array into HIF)
150
#define DWT_LOADEUI      0x0008                      // ONW_LEUI - on wakeup load EUI
151
#define DWT_RX_EN        0x0002                      // ONW_RX - on wakeup activate reception
152
#define DWT_TANDV        0x0001                      // ONW_RADC - on wakeup run ADC to sample temperature and voltage sensor values
153

    
154
#define DWT_XTAL_EN      0x10                       // keep XTAL running during sleep
155
#define DWT_WAKE_SLPCNT  0x8                        // wake up after sleep count
156
#define DWT_WAKE_CS      0x4                        // wake up on chip select
157
#define DWT_WAKE_WK      0x2                        // wake up on WAKEUP PIN
158
#define DWT_SLP_EN       0x1                        // enable sleep/deep sleep functionality
159

    
160
//DW1000 INIT configuration parameters
161
#define DWT_LOADUCODE     0x1
162
#define DWT_LOADNONE      0x0
163

    
164
//DW1000 OTP operating parameter set selection
165
#define DWT_OPSET_64LEN   0x0
166
#define DWT_OPSET_TIGHT   0x1
167
#define DWT_OPSET_DEFLT   0x2
168

    
169
// Call-back data RX frames flags
170
#define DWT_CB_DATA_RX_FLAG_RNG 0x1 // Ranging bit
171

    
172

    
173
// TX/RX call-back data
174
typedef struct
175
{
176
    uint32_t status;      //initial value of register as ISR is entered
177
    uint16_t datalength;  //length of frame
178
    uint8_t  fctrl[2];    //frame control bytes
179
    uint8_t  rx_flags;    //RX frame flags, see above
180
} dwt_cb_data_t;
181

    
182
// Call-back type for all events
183
typedef void (*dwt_cb_t)(const dwt_cb_data_t *);
184

    
185

    
186
// -------------------------------------------------------------------------------------------------------------------
187
// Structure to hold device data
188
typedef struct
189
{
190
    uint32_t      partID ;            // IC Part ID - read during initialisation
191
    uint32_t      lotID ;             // IC Lot ID - read during initialisation
192
    uint8_t       longFrames ;        // Flag in non-standard long frame mode
193
    uint8_t       otprev ;            // OTP revision number (read during initialisation)
194
    uint32_t      txFCTRL ;           // Keep TX_FCTRL register config
195
    uint8_t       init_xtrim;         // initial XTAL trim value read from OTP (or defaulted to mid-range if OTP not programmed)
196
    uint8_t       dblbuffon;          // Double RX buffer mode flag
197
    uint32_t      sysCFGreg ;         // Local copy of system config register
198
    uint16_t      sleep_mode;         // Used for automatic reloading of LDO tune and microcode at wake-up
199
    uint8_t       wait4resp ;         // wait4response was set with last TX start command
200
    dwt_cb_data_t cbData;             // Callback data structure
201
    dwt_cb_t      cbTxDone;           // Callback for TX confirmation event
202
    dwt_cb_t      cbRxOk;             // Callback for RX good frame event
203
    dwt_cb_t      cbRxTo;             // Callback for RX timeout events
204
    dwt_cb_t      cbRxErr;            // Callback for RX error events
205
    DW1000Driver  *driver;      // Reference to local hardware SPI, GPIO, ...
206
} dwt_local_data_t ;
207

    
208
/*! ------------------------------------------------------------------------------------------------------------------
209
 * Structure typedef: dwt_config_t
210
 *
211
 * Structure for setting device configuration via dwt_configure() function
212
 *
213
 */
214
typedef struct
215
{
216
    uint8_t chan ;           //!< channel number {1, 2, 3, 4, 5, 7 }
217
    uint8_t prf ;            //!< Pulse Repetition Frequency {DWT_PRF_16M or DWT_PRF_64M}
218
    uint8_t txPreambLength ; //!< DWT_PLEN_64..DWT_PLEN_4096
219
    uint8_t rxPAC ;          //!< Acquisition Chunk Size (Relates to RX preamble length)
220
    uint8_t txCode ;         //!< TX preamble code
221
    uint8_t rxCode ;         //!< RX preamble code
222
    uint8_t nsSFD ;          //!< Boolean should we use non-standard SFD for better performance
223
    uint8_t dataRate ;       //!< Data Rate {DWT_BR_110K, DWT_BR_850K or DWT_BR_6M8}
224
    uint8_t phrMode ;        //!< PHR mode {0x0 - standard DWT_PHRMODE_STD, 0x3 - extended frames DWT_PHRMODE_EXT}
225
    uint16_t sfdTO ;         //!< SFD timeout value (in symbols)
226
} dwt_config_t ;
227

    
228

    
229
typedef struct
230
{
231
    uint8_t   PGdly;
232
    //TX POWER
233
    //31:24     BOOST_0.125ms_PWR
234
    //23:16     BOOST_0.25ms_PWR-TX_SHR_PWR
235
    //15:8      BOOST_0.5ms_PWR-TX_PHR_PWR
236
    //7:0       DEFAULT_PWR-TX_DATA_PWR
237
    uint32_t  power;
238
} dwt_txconfig_t ;
239

    
240

    
241
typedef struct
242
{
243

    
244
    uint16_t      maxNoise ;          // LDE max value of noise
245
    uint16_t      firstPathAmp1 ;     // Amplitude at floor(index FP) + 1
246
    uint16_t      stdNoise ;          // Standard deviation of noise
247
    uint16_t      firstPathAmp2 ;     // Amplitude at floor(index FP) + 2
248
    uint16_t      firstPathAmp3 ;     // Amplitude at floor(index FP) + 3
249
    uint16_t      maxGrowthCIR ;      // Channel Impulse Response max growth CIR
250
    uint16_t      rxPreamCount ;      // Count of preamble symbols accumulated
251
    uint16_t      firstPath ;         // First path index (10.6 bits fixed point integer)
252
}dwt_rxdiag_t ;
253

    
254

    
255
typedef struct
256
{
257
    //all of the below are mapped to a 12-bit register in DW1000
258
    uint16_t PHE ;                    //number of received header errors
259
    uint16_t RSL ;                    //number of received frame sync loss events
260
    uint16_t CRCG ;                   //number of good CRC received frames
261
    uint16_t CRCB ;                   //number of bad CRC (CRC error) received frames
262
    uint16_t ARFE ;                   //number of address filter errors
263
    uint16_t OVER ;                   //number of receiver overflows (used in double buffer mode)
264
    uint16_t SFDTO ;                  //SFD timeouts
265
    uint16_t PTO ;                    //Preamble timeouts
266
    uint16_t RTO ;                    //RX frame wait timeouts
267
    uint16_t TXF ;                    //number of transmitted frames
268
    uint16_t HPW ;                    //half period warn
269
    uint16_t TXW ;                    //power up warn
270

    
271
} dwt_deviceentcnts_t ;
272

    
273

    
274
/********************************************************************************************************************/
275
/*                                                 REMOVED API LIST                                                 */
276
/********************************************************************************************************************/
277
/*
278
 * From version 4.0.0:
279
 *  - dwt_setGPIOforEXTTRX: Replaced by dwt_setlnapamode to get equivalent functionality.
280
 *  - dwt_setGPIOdirection: Renamed to dwt_setgpiodirection.
281
 *  - dwt_setGPIOvalue: Renamed to dwt_setgpiovalue.
282
 *  - dwt_setrxmode: Replaced by dwt_setsniffmode and dwt_setlowpowerlistening depending on the RX mode the user
283
 *    wants to set up.
284
 *  - dwt_checkoverrun: As automatic RX re-enabling is not supported anymore, this functions has become useless.
285
 *  - dwt_setautorxreenable: As automatic RX re-enabling is not supported anymore, this functions has become
286
 *    useless.
287
 *  - dwt_getrangebias: Range bias correction values are platform dependent and should therefore be managed at user
288
 *    application level.
289
 *  - dwt_xtaltrim: Renamed to dwt_setxtaltrim.
290
 *  - dwt_checkIRQ: Renamed to dwt_checkirq.
291
 *
292
 * From version 3.0.0:
293
 *  - dwt_getldotune: As LDO loading is now automatically managed by the driver, this function has become useless.
294
 *  - dwt_getotptxpower: TX power values and location in OTP memory are platform dependent and should therefore be
295
 *    managed at user application level.
296
 *  - dwt_readantennadelay: Antenna delay values and location in OTP memory are platform dependent and should
297
 *    therefore be managed at user application level.
298
 *  - dwt_readdignostics: Renamed to dwt_readdiagnostics.
299
 */
300

    
301
/********************************************************************************************************************/
302
/*                                                     API LIST                                                     */
303
/********************************************************************************************************************/
304

    
305
/*! ------------------------------------------------------------------------------------------------------------------
306
 * @fn dwt_setdevicedataptr()
307
 *
308
 * @brief This function sets the local data structure pointer to point to the structure in the local array as given by the index.
309
 *
310
 * input parameters
311
 * @param index    - selects the array object to point to. Must be within the array bounds, i.e. < DWT_NUM_DW_DEV
312
 *
313
 * output parameters
314
 *
315
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
316
 */
317
int dwt_setdevicedataptr(unsigned int index);
318

    
319
/*! ------------------------------------------------------------------------------------------------------------------
320
 * @fn dwt_getpartid()
321
 *
322
 * @brief This is used to return the read part ID of the device
323
 *
324
 * NOTE: dwt_initialise() must be called prior to this function so that it can return a relevant value.
325
 *
326
 * input parameters
327
 *
328
 * output parameters
329
 *
330
 * returns the 32 bit part ID value as programmed in the factory
331
 */
332
uint32_t dwt_getpartid(void);
333

    
334
/*! ------------------------------------------------------------------------------------------------------------------
335
 * @fn dwt_getlotid()
336
 *
337
 * @brief This is used to return the read lot ID of the device
338
 *
339
 * NOTE: dwt_initialise() must be called prior to this function so that it can return a relevant value.
340
 *
341
 * input parameters
342
 *
343
 * output parameters
344
 *
345
 * returns the 32 bit lot ID value as programmed in the factory
346
 */
347
uint32_t dwt_getlotid(void);
348

    
349
/*! ------------------------------------------------------------------------------------------------------------------
350
 * @fn dwt_readdevid()
351
 *
352
 * @brief This is used to return the read device type and revision information of the DW1000 device (MP part is 0xDECA0130)
353
 *
354
 * input parameters
355
 *
356
 * output parameters
357
 *
358
 * returns the read value which for DW1000 is 0xDECA0130
359
 */
360
uint32_t dwt_readdevid(void);
361

    
362
/*! ------------------------------------------------------------------------------------------------------------------
363
 * @fn dwt_otprevision()
364
 *
365
 * @brief This is used to return the read OTP revision
366
 *
367
 * NOTE: dwt_initialise() must be called prior to this function so that it can return a relevant value.
368
 *
369
 * input parameters
370
 *
371
 * output parameters
372
 *
373
 * returns the read OTP revision value
374
 */
375
uint8_t dwt_otprevision(void);
376

    
377
/*! ------------------------------------------------------------------------------------------------------------------
378
 * @fn dwt_setfinegraintxseq()
379
 *
380
 * @brief This function enables/disables the fine grain TX sequencing (enabled by default).
381
 *
382
 * input parameters
383
 * @param enable - 1 to enable fine grain TX sequencing, 0 to disable it.
384
 *
385
 * output parameters none
386
 *
387
 * no return value
388
 */
389
void dwt_setfinegraintxseq(int enable);
390

    
391
/*! ------------------------------------------------------------------------------------------------------------------
392
 * @fn dwt_setlnapamode()
393
 *
394
 * @brief This is used to enable GPIO for external LNA or PA functionality - HW dependent, consult the DW1000 User Manual.
395
 *        This can also be used for debug as enabling TX and RX GPIOs is quite handy to monitor DW1000's activity.
396
 *
397
 * NOTE: Enabling PA functionality requires that fine grain TX sequencing is deactivated. This can be done using
398
 *       dwt_setfinegraintxseq().
399
 *
400
 * input parameters
401
 * @param lna - 1 to enable LNA functionality, 0 to disable it
402
 * @param pa - 1 to enable PA functionality, 0 to disable it
403
 *
404
 * output parameters
405
 *
406
 * no return value
407
 */
408
void dwt_setlnapamode(int lna, int pa);
409

    
410
/*! ------------------------------------------------------------------------------------------------------------------
411
 * @fn dwt_setgpiodirection()
412
 *
413
 * @brief This is used to set GPIO direction as an input (1) or output (0)
414
 *
415
 * input parameters
416
 * @param gpioNum    -   this is the GPIO to configure - see GxM0... GxM8 in the deca_regs.h file
417
 * @param direction  -   this sets the GPIO direction - see GxP0... GxP8 in the deca_regs.h file
418
 *
419
 * output parameters
420
 *
421
 * no return value
422
 */
423
void dwt_setgpiodirection(uint32_t gpioNum, uint32_t direction);
424

    
425
/*! ------------------------------------------------------------------------------------------------------------------
426
 * @fn dwt_setgpiovalue()
427
 *
428
 * @brief This is used to set GPIO value as (1) or (0) only applies if the GPIO is configured as output
429
 *
430
 * input parameters
431
 * @param gpioNum    -   this is the GPIO to configure - see GxM0... GxM8 in the deca_regs.h file
432
 * @param value  -   this sets the GPIO value - see GDP0... GDP8 in the deca_regs.h file
433
 *
434
 * output parameters
435
 *
436
 * no return value
437
 */
438
void dwt_setgpiovalue(uint32_t gpioNum, uint32_t value);
439

    
440
/*! ------------------------------------------------------------------------------------------------------------------
441
 * @fn dwt_initialise()
442
 *
443
 * @brief This function initiates communications with the DW1000 transceiver
444
 * and reads its DEV_ID register (address 0x00) to verify the IC is one supported
445
 * by this software (e.g. DW1000 32-bit device ID value is 0xDECA0130).  Then it
446
 * does any initial once only device configurations needed for use and initialises
447
 * as necessary any static data items belonging to this low-level driver.
448
 *
449
 * NOTES:
450
 * 1.this function needs to be run before dwt_configuresleep, also the SPI frequency has to be < 3MHz
451
 * 2.it also reads and applies LDO tune and crystal trim values from OTP memory
452
 *
453
 * input parameters
454
 * @param config    -   specifies what configuration to load
455
 *                  DWT_LOADUCODE     0x1 - load the LDE microcode from ROM - enabled accurate RX timestamp
456
 *                  DWT_LOADNONE      0x0 - do not load any values from OTP memory
457
 * @param drv       -   hardware specifc struct containg refernce to SPI, GPIO etc.
458
 *
459
 * output parameters
460
 *
461
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
462
 */
463
int dwt_initialise(uint16_t config, DW1000Driver* drv) ;
464

    
465
/*! ------------------------------------------------------------------------------------------------------------------
466
 * @fn dwt_configure()
467
 *
468
 * @brief This function provides the main API for the configuration of the
469
 * DW1000 and this low-level driver.  The input is a pointer to the data structure
470
 * of type dwt_config_t that holds all the configurable items.
471
 * The dwt_config_t structure shows which ones are supported
472
 *
473
 * input parameters
474
 * @param config    -   pointer to the configuration structure, which contains the device configuration data.
475
 *
476
 * output parameters
477
 *
478
 * no return value
479
 */
480
void dwt_configure(dwt_config_t* config) ;
481

    
482
/*! ------------------------------------------------------------------------------------------------------------------
483
 * @fn dwt_configuretxrf()
484
 *
485
 * @brief This function provides the API for the configuration of the TX spectrum
486
 * including the power and pulse generator delay. The input is a pointer to the data structure
487
 * of type dwt_txconfig_t that holds all the configurable items.
488
 *
489
 * input parameters
490
 * @param config    -   pointer to the txrf configuration structure, which contains the tx rf config data
491
 *
492
 * output parameters
493
 *
494
 * no return value
495
 */
496
void dwt_configuretxrf(dwt_txconfig_t *config) ;
497

    
498
/*! ------------------------------------------------------------------------------------------------------------------
499
 * @fn dwt_setrxantennadelay()
500
 *
501
 * @brief This API function writes the antenna delay (in time units) to RX registers
502
 *
503
 * input parameters:
504
 * @param rxDelay - this is the total (RX) antenna delay value, which
505
 *                          will be programmed into the RX register
506
 *
507
 * output parameters
508
 *
509
 * no return value
510
 */
511
void dwt_setrxantennadelay(uint16_t antennaDly);
512

    
513
/*! ------------------------------------------------------------------------------------------------------------------
514
 * @fn dwt_settxantennadelay()
515
 *
516
 * @brief This API function writes the antenna delay (in time units) to TX registers
517
 *
518
 * input parameters:
519
 * @param txDelay - this is the total (TX) antenna delay value, which
520
 *                          will be programmed into the TX delay register
521
 *
522
 * output parameters
523
 *
524
 * no return value
525
 */
526
void dwt_settxantennadelay(uint16_t antennaDly);
527

    
528
/*! ------------------------------------------------------------------------------------------------------------------
529
 * @fn dwt_setsmarttxpower()
530
 *
531
 * @brief This call enables or disables the smart TX power feature.
532
 *
533
 * input parameters
534
 * @param enable - this enables or disables the TX smart power (1 = enable, 0 = disable)
535
 *
536
 * output parameters
537
 *
538
 * no return value
539
 */
540
void dwt_setsmarttxpower(int enable);
541

    
542
/*! ------------------------------------------------------------------------------------------------------------------
543
 * @fn dwt_writetxdata()
544
 *
545
 * @brief This API function writes the supplied TX data into the DW1000's
546
 * TX buffer.  The input parameters are the data length in bytes and a pointer
547
 * to those data bytes.
548
 *
549
 * input parameters
550
 * @param txFrameLength  - This is the total frame length, including the two byte CRC.
551
 *                         Note: this is the length of TX message (including the 2 byte CRC) - max is 1023
552
 *                         standard PHR mode allows up to 127 bytes
553
 *                         if > 127 is programmed, DWT_PHRMODE_EXT needs to be set in the phrMode configuration
554
 *                         see dwt_configure function
555
 * @param txFrameBytes   - Pointer to the user’s buffer containing the data to send.
556
 * @param txBufferOffset - This specifies an offset in the DW1000’s TX Buffer at which to start writing data.
557
 *
558
 * output parameters
559
 *
560
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
561
 */
562
int dwt_writetxdata(uint16_t txFrameLength, uint8_t *txFrameBytes, uint16_t txBufferOffset) ;
563

    
564
/*! ------------------------------------------------------------------------------------------------------------------
565
 * @fn dwt_writetxfctrl()
566
 *
567
 * @brief This API function configures the TX frame control register before the transmission of a frame
568
 *
569
 * input parameters:
570
 * @param txFrameLength - this is the length of TX message (including the 2 byte CRC) - max is 1023
571
 *                              NOTE: standard PHR mode allows up to 127 bytes
572
 *                              if > 127 is programmed, DWT_PHRMODE_EXT needs to be set in the phrMode configuration
573
 *                              see dwt_configure function
574
 * @param txBufferOffset - the offset in the tx buffer to start writing the data
575
 * @param ranging - 1 if this is a ranging frame, else 0
576
 *
577
 * output parameters
578
 *
579
 * no return value
580
 */
581
void dwt_writetxfctrl(uint16_t txFrameLength, uint16_t txBufferOffset, int ranging);
582

    
583
/*! ------------------------------------------------------------------------------------------------------------------
584
 * @fn dwt_starttx()
585
 *
586
 * @brief This call initiates the transmission, input parameter indicates which TX mode is used see below
587
 *
588
 * input parameters:
589
 * @param mode - is a bitmask for which the following values can be combined to define the operation
590
 *               DWT_START_TX_IMMEDIATE (0)            - to begin transmission immediatelty.
591
 *               DWT_START_TX_DELAYED   (to set bit 0) - to begin TX at pre-configured delay time
592
 *               DWT_RESPONSE_EXPECTED  (to set bit 1) - to turn the receiver on automatically (after the TX) after a pre-programmed delay
593
 * output parameters
594
 *
595
 * returns DWT_SUCCESS for success, or DWT_ERROR for error (e.g. a delayed transmission will fail if the delayed time has passed)
596
 */
597
int dwt_starttx(uint8_t mode) ;
598

    
599
/*! ------------------------------------------------------------------------------------------------------------------
600
 * @fn dwt_setdelayedtrxtime()
601
 *
602
 * @brief This API function configures the delayed transmit time or the delayed RX on time
603
 *
604
 * input parameters
605
 * @param starttime - the TX/RX start time (the 32 bits should be the high 32 bits of the system time at which to send the message,
606
 * or at which to turn on the receiver)
607
 *
608
 * output parameters none
609
 *
610
 * no return value
611
 */
612
void dwt_setdelayedtrxtime(uint32_t starttime) ;
613

    
614
/*! ------------------------------------------------------------------------------------------------------------------
615
 * @fn dwt_readtxtimestamp()
616
 *
617
 * @brief This is used to read the TX timestamp (adjusted with the programmed antenna delay)
618
 *
619
 * input parameters
620
 * @param timestamp - a pointer to a 5-byte buffer which will store the read TX timestamp time
621
 *
622
 * output parameters - the timestamp buffer will contain the value after the function call
623
 *
624
 * no return value
625
 */
626
void dwt_readtxtimestamp(uint8_t * timestamp);
627

    
628
/*! ------------------------------------------------------------------------------------------------------------------
629
 * @fn dwt_readtxtimestamphi32()
630
 *
631
 * @brief This is used to read the high 32-bits of the TX timestamp (adjusted with the programmed antenna delay)
632
 *
633
 * input parameters
634
 *
635
 * output parameters
636
 *
637
 * returns high 32-bits of TX timestamp
638
 */
639
uint32_t dwt_readtxtimestamphi32(void);
640

    
641
/*! ------------------------------------------------------------------------------------------------------------------
642
 * @fn dwt_readtxtimestamplo32()
643
 *
644
 * @brief This is used to read the low 32-bits of the TX timestamp (adjusted with the programmed antenna delay)
645
 *
646
 * input parameters
647
 *
648
 * output parameters
649
 *
650
 * returns low 32-bits of TX timestamp
651
 */
652
uint32_t dwt_readtxtimestamplo32(void);
653

    
654
/*! ------------------------------------------------------------------------------------------------------------------
655
 * @fn dwt_readrxtimestamp()
656
 *
657
 * @brief This is used to read the RX timestamp (adjusted time of arrival)
658
 *
659
 * input parameters
660
 * @param timestamp - a pointer to a 5-byte buffer which will store the read RX timestamp time
661
 *
662
 * output parameters - the timestamp buffer will contain the value after the function call
663
 *
664
 * no return value
665
 */
666
void dwt_readrxtimestamp(uint8_t * timestamp);
667

    
668
/*! ------------------------------------------------------------------------------------------------------------------
669
 * @fn dwt_readrxtimestamphi32()
670
 *
671
 * @brief This is used to read the high 32-bits of the RX timestamp (adjusted with the programmed antenna delay)
672
 *
673
 * input parameters
674
 *
675
 * output parameters
676
 *
677
 * returns high 32-bits of RX timestamp
678
 */
679
uint32_t dwt_readrxtimestamphi32(void);
680

    
681
/*! ------------------------------------------------------------------------------------------------------------------
682
 * @fn dwt_readrxtimestamplo32()
683
 *
684
 * @brief This is used to read the low 32-bits of the RX timestamp (adjusted with the programmed antenna delay)
685
 *
686
 * input parameters
687
 *
688
 * output parameters
689
 *
690
 * returns low 32-bits of RX timestamp
691
 */
692
uint32_t dwt_readrxtimestamplo32(void);
693

    
694
/*! ------------------------------------------------------------------------------------------------------------------
695
 * @fn dwt_readsystimestamphi32()
696
 *
697
 * @brief This is used to read the high 32-bits of the system time
698
 *
699
 * input parameters
700
 *
701
 * output parameters
702
 *
703
 * returns high 32-bits of system time timestamp
704
 */
705
uint32_t dwt_readsystimestamphi32(void);
706

    
707
/*! ------------------------------------------------------------------------------------------------------------------
708
 * @fn dwt_readsystime()
709
 *
710
 * @brief This is used to read the system time
711
 *
712
 * input parameters
713
 * @param timestamp - a pointer to a 5-byte buffer which will store the read system time
714
 *
715
 * output parameters
716
 * @param timestamp - the timestamp buffer will contain the value after the function call
717
 *
718
 * no return value
719
 */
720
void dwt_readsystime(uint8_t * timestamp);
721

    
722
/*! ------------------------------------------------------------------------------------------------------------------
723
 * @fn dwt_forcetrxoff()
724
 *
725
 * @brief This is used to turn off the transceiver
726
 *
727
 * input parameters
728
 *
729
 * output parameters
730
 *
731
 * no return value
732
 */
733
void dwt_forcetrxoff(void);
734

    
735
/*! ------------------------------------------------------------------------------------------------------------------
736
 * @fn dwt_syncrxbufptrs()
737
 *
738
 * @brief this function synchronizes rx buffer pointers
739
 * need to make sure that the host/IC buffer pointers are aligned before starting RX
740
 *
741
 * input parameters:
742
 *
743
 * output parameters
744
 *
745
 * no return value
746
 */
747
void dwt_syncrxbufptrs(void);
748

    
749
/*! ------------------------------------------------------------------------------------------------------------------
750
 * @fn dwt_rxenable()
751
 *
752
 * @brief This call turns on the receiver, can be immediate or delayed (depending on the mode parameter). In the case of a
753
 * "late" error the receiver will only be turned on if the DWT_IDLE_ON_DLY_ERR is not set.
754
 * The receiver will stay turned on, listening to any messages until
755
 * it either receives a good frame, an error (CRC, PHY header, Reed Solomon) or  it times out (SFD, Preamble or Frame).
756
 *
757
 * input parameters
758
 * @param mode - this can be one of the following allowed values:
759
 *
760
 * DWT_START_RX_IMMEDIATE      0 used to enbale receiver immediately
761
 * DWT_START_RX_DELAYED        1 used to set up delayed RX, if "late" error triggers, then the RX will be enabled immediately
762
 * (DWT_START_RX_DELAYED | DWT_IDLE_ON_DLY_ERR) 3 used to disable re-enabling of receiver if delayed RX failed due to "late" error
763
 * (DWT_START_RX_IMMEDIATE | DWT_NO_SYNC_PTRS) 4 used to re-enable RX without trying to sync IC and host side buffer pointers, typically when
764
 *                                               performing manual RX re-enabling in double buffering mode
765
 *
766
 * returns DWT_SUCCESS for success, or DWT_ERROR for error (e.g. a delayed receive enable will be too far in the future if delayed time has passed)
767
 */
768
int dwt_rxenable(int mode);
769

    
770
/*! ------------------------------------------------------------------------------------------------------------------
771
 * @fn dwt_setsniffmode()
772
 *
773
 * @brief enable/disable and configure SNIFF mode.
774
 *
775
 * SNIFF mode is a low-power reception mode where the receiver is sequenced on and off instead of being on all the time.
776
 * The time spent in each state (on/off) is specified through the parameters below.
777
 * See DW1000 User Manual section 4.5 "Low-Power SNIFF mode" for more details.
778
 *
779
 * input parameters:
780
 * @param enable - 1 to enable SNIFF mode, 0 to disable. When 0, all other parameters are not taken into account.
781
 * @param timeOn - duration of receiver ON phase, expressed in multiples of PAC size. The counter automatically adds 1 PAC
782
 *                 size to the value set. Min value that can be set is 1 (i.e. an ON time of 2 PAC size), max value is 15.
783
 * @param timeOff - duration of receiver OFF phase, expressed in multiples of 128/125 µs (~1 µs). Max value is 255.
784
 *
785
 * output parameters
786
 *
787
 * no return value
788
 */
789
void dwt_setsniffmode(int enable, uint8_t timeOn, uint8_t timeOff);
790

    
791
/*! ------------------------------------------------------------------------------------------------------------------
792
 * @fn dwt_setlowpowerlistening()
793
 *
794
 * @brief enable/disable low-power listening mode.
795
 *
796
 * Low-power listening is a feature whereby the DW1000 is predominantly in the SLEEP state but wakes periodically, (after
797
 * this "long sleep"), for a very short time to sample the air for a preamble sequence. This preamble sampling "listening"
798
 * phase is actually two reception phases separated by a "short sleep" time. See DW1000 User Manual section "Low-Power
799
 * Listening" for more details.
800
 *
801
 * NOTE: Before enabling low-power listening, the following functions have to be called to fully configure it:
802
 *           - dwt_configuresleep() to configure long sleep phase. "mode" parameter should at least have DWT_PRESRV_SLEEP,
803
 *             DWT_CONFIG and DWT_RX_EN set and "wake" parameter should at least have both DWT_WAKE_SLPCNT and DWT_SLP_EN set.
804
 *           - dwt_calibratesleepcnt() and dwt_configuresleepcnt() to define the "long sleep" phase duration.
805
 *           - dwt_setsnoozetime() to define the "short sleep" phase duration.
806
 *           - dwt_setpreambledetecttimeout() to define the reception phases duration.
807
 *           - dwt_setinterrupt() to activate RX good frame interrupt (DWT_INT_RFCG) only.
808
 *       When configured, low-power listening mode can be triggered either by putting the DW1000 to sleep (using
809
 *       dwt_entersleep()) or by activating reception (using dwt_rxenable()).
810
 *
811
 *       Please refer to the low-power listening examples (examples 8a/8b accompanying the API distribution on Decawave's
812
 *       website). They form a working example code that shows how to use low-power listening correctly.
813
 *
814
 * input parameters:
815
 * @param enable - 1 to enable low-power listening, 0 to disable.
816
 *
817
 * output parameters
818
 *
819
 * no return value
820
 */
821
void dwt_setlowpowerlistening(int enable);
822

    
823
/*! ------------------------------------------------------------------------------------------------------------------
824
 * @fn dwt_setsnoozetime()
825
 *
826
 * @brief Set duration of "short sleep" phase when in low-power listening mode.
827
 *
828
 * input parameters:
829
 * @param snooze_time - "short sleep" phase duration, expressed in multiples of 512/19.2 µs (~26.7 µs). The counter
830
 *                      automatically adds 1 to the value set. The smallest working value that should be set is 1,
831
 *                      i.e. giving a snooze time of 2 units (or ~53 µs).
832
 *
833
 * output parameters
834
 *
835
 * no return value
836
 */
837
void dwt_setsnoozetime(uint8_t snooze_time);
838

    
839
/*! ------------------------------------------------------------------------------------------------------------------
840
 * @fn dwt_setdblrxbuffmode()
841
 *
842
 * @brief This call enables the double receive buffer mode
843
 *
844
 * input parameters
845
 * @param enable - 1 to enable, 0 to disable the double buffer mode
846
 *
847
 * output parameters
848
 *
849
 * no return value
850
 */
851
void dwt_setdblrxbuffmode(int enable);
852

    
853
/*! ------------------------------------------------------------------------------------------------------------------
854
 * @fn dwt_setrxtimeout()
855
 *
856
 * @brief This call enables RX timeout (SY_STAT_RFTO event)
857
 *
858
 * input parameters
859
 * @param time - how long the receiver remains on from the RX enable command
860
 *               The time parameter used here is in 1.0256 us (512/499.2MHz) units
861
 *               If set to 0 the timeout is disabled.
862
 *
863
 * output parameters
864
 *
865
 * no return value
866
 */
867
void dwt_setrxtimeout(uint16_t time);
868

    
869
/*! ------------------------------------------------------------------------------------------------------------------
870
 * @fn dwt_setpreambledetecttimeout()
871
 *
872
 * @brief This call enables preamble timeout (SY_STAT_RXPTO event)
873
 *
874
 * input parameters
875
 * @param  timeout - Preamble detection timeout, expressed in multiples of PAC size. The counter automatically adds 1 PAC
876
 *                   size to the value set. Min value that can be set is 1 (i.e. a timeout of 2 PAC size).
877
 *
878
 * output parameters
879
 *
880
 * no return value
881
 */
882
void dwt_setpreambledetecttimeout(uint16_t timeout);
883

    
884

    
885
/*! ------------------------------------------------------------------------------------------------------------------
886
 * @fn dwt_calibratesleepcnt()
887
 *
888
 * @brief calibrates the local oscillator as its frequency can vary between 7 and 13kHz depending on temp and voltage
889
 *
890
 * NOTE: this function needs to be run before dwt_configuresleepcnt, so that we know what the counter units are
891
 *
892
 * input parameters
893
 *
894
 * output parameters
895
 *
896
 * returns the number of XTAL/2 cycles per low-power oscillator cycle. LP OSC frequency = 19.2 MHz/return value
897
 */
898
uint16_t dwt_calibratesleepcnt(void);
899

    
900
/*! ------------------------------------------------------------------------------------------------------------------
901
 * @fn dwt_configuresleepcnt()
902
 *
903
 * @brief sets the sleep counter to new value, this function programs the high 16-bits of the 28-bit counter
904
 *
905
 * NOTE: this function needs to be run before dwt_configuresleep, also the SPI frequency has to be < 3MHz
906
 *
907
 * input parameters
908
 * @param sleepcnt - this it value of the sleep counter to program
909
 *
910
 * output parameters
911
 *
912
 * no return value
913
 */
914
 void dwt_configuresleepcnt(uint16_t sleepcnt);
915

    
916
 /*! ------------------------------------------------------------------------------------------------------------------
917
  * @fn dwt_configuresleep()
918
  *
919
  * @brief configures the device for both DEEP_SLEEP and SLEEP modes, and on-wake mode
920
  * i.e. before entering the sleep, the device should be programmed for TX or RX, then upon "waking up" the TX/RX settings
921
  * will be preserved and the device can immediately perform the desired action TX/RX
922
  *
923
  * NOTE: e.g. Tag operation - after deep sleep, the device needs to just load the TX buffer and send the frame
924
  *
925
  *
926
  *      mode: the array and LDE code (OTP/ROM) and LDO tune, and set sleep persist
927
  *      DWT_PRESRV_SLEEP 0x0100 - preserve sleep
928
  *      DWT_LOADOPSET    0x0080 - load operating parameter set on wakeup
929
  *      DWT_CONFIG       0x0040 - download the AON array into the HIF (configuration download)
930
  *      DWT_LOADEUI      0x0008
931
  *      DWT_GOTORX       0x0002
932
  *      DWT_TANDV        0x0001
933
  *
934
  *      wake: wake up parameters
935
  *      DWT_XTAL_EN      0x10 - keep XTAL running during sleep
936
  *      DWT_WAKE_SLPCNT  0x8 - wake up after sleep count
937
  *      DWT_WAKE_CS      0x4 - wake up on chip select
938
  *      DWT_WAKE_WK      0x2 - wake up on WAKEUP PIN
939
  *      DWT_SLP_EN       0x1 - enable sleep/deep sleep functionality
940
  *
941
  * input parameters
942
  * @param mode - config on-wake parameters
943
  * @param wake - config wake up parameters
944
  *
945
  * output parameters
946
  *
947
  * no return value
948
  */
949
void dwt_configuresleep(uint16_t mode, uint8_t wake);
950

    
951
/*! ------------------------------------------------------------------------------------------------------------------
952
 * @fn dwt_entersleep()
953
 *
954
 * @brief This function puts the device into deep sleep or sleep. dwt_configuresleep() should be called first
955
 * to configure the sleep and on-wake/wake-up parameters
956
 *
957
 * input parameters
958
 *
959
 * output parameters
960
 *
961
 * no return value
962
 */
963
void dwt_entersleep(void);
964

    
965
/*! ------------------------------------------------------------------------------------------------------------------
966
 * @fn dwt_entersleepaftertx(int enable)
967
 *
968
 * @brief sets the auto TX to sleep bit. This means that after a frame
969
 * transmission the device will enter deep sleep mode. The dwt_configuresleep() function
970
 * needs to be called before this to configure the on-wake settings
971
 *
972
 * NOTE: the IRQ line has to be low/inactive (i.e. no pending events)
973
 *
974
 * input parameters
975
 * @param enable - 1 to configure the device to enter deep sleep after TX, 0 - disables the configuration
976
 *
977
 * output parameters
978
 *
979
 * no return value
980
 */
981
void dwt_entersleepaftertx(int enable);
982

    
983
/*! ------------------------------------------------------------------------------------------------------------------
984
 * @fn dwt_spicswakeup()
985
 *
986
 * @brief wake up the device from sleep mode using the SPI read,
987
 * the device will wake up on chip select line going low if the line is held low for at least 500us.
988
 * To define the length depending on the time one wants to hold
989
 * the chip select line low, use the following formula:
990
 *
991
 *      length (bytes) = time (s) * byte_rate (Hz)
992
 *
993
 * where fastest byte_rate is spi_rate (Hz) / 8 if the SPI is sending the bytes back-to-back.
994
 * To save time and power, a system designer could determine byte_rate value more precisely.
995
 *
996
 * NOTE: Alternatively the device can be waken up with WAKE_UP pin if configured for that operation
997
 *
998
 * input parameters
999
 * @param buff   - this is a pointer to the dummy buffer which will be used in the SPI read transaction used for the WAKE UP of the device
1000
 * @param length - this is the length of the dummy buffer
1001
 *
1002
 * output parameters
1003
 *
1004
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
1005
 */
1006
int dwt_spicswakeup(uint8_t *buff, uint16_t length);
1007

    
1008
/*! ------------------------------------------------------------------------------------------------------------------
1009
 * @fn dwt_setcallbacks()
1010
 *
1011
 * @brief This function is used to register the different callbacks called when one of the corresponding event occurs.
1012
 *
1013
 * NOTE: Callbacks can be undefined (set to NULL). In this case, dwt_isr() will process the event as usual but the 'null'
1014
 * callback will not be called.
1015
 *
1016
 * input parameters
1017
 * @param cbTxDone - the pointer to the TX confirmation event callback function
1018
 * @param cbRxOk - the pointer to the RX good frame event callback function
1019
 * @param cbRxTo - the pointer to the RX timeout events callback function
1020
 * @param cbRxErr - the pointer to the RX error events callback function
1021
 *
1022
 * output parameters
1023
 *
1024
 * no return value
1025
 */
1026
void dwt_setcallbacks(dwt_cb_t cbTxDone, dwt_cb_t cbRxOk, dwt_cb_t cbRxTo, dwt_cb_t cbRxErr);
1027

    
1028
/*! ------------------------------------------------------------------------------------------------------------------
1029
 * @fn dwt_checkirq()
1030
 *
1031
 * @brief This function checks if the IRQ line is active - this is used instead of interrupt handler
1032
 *
1033
 * input parameters
1034
 *
1035
 * output parameters
1036
 *
1037
 * return value is 1 if the IRQS bit is set and 0 otherwise
1038
 */
1039
uint8_t dwt_checkirq(void);
1040

    
1041
/*! ------------------------------------------------------------------------------------------------------------------
1042
 * @fn dwt_isr()
1043
 *
1044
 * @brief This is the DW1000's general Interrupt Service Routine. It will process/report the following events:
1045
 *          - RXFCG (through cbRxOk callback)
1046
 *          - TXFRS (through cbTxDone callback)
1047
 *          - RXRFTO/RXPTO (through cbRxTo callback)
1048
 *          - RXPHE/RXFCE/RXRFSL/RXSFDTO/AFFREJ/LDEERR (through cbRxTo cbRxErr)
1049
 *        For all events, corresponding interrupts are cleared and necessary resets are performed. In addition, in the RXFCG case,
1050
 *        received frame information and frame control are read before calling the callback. If double buffering is activated, it
1051
 *        will also toggle between reception buffers once the reception callback processing has ended.
1052
 *
1053
 *        /!\ This version of the ISR supports double buffering but does not support automatic RX re-enabling!
1054
 *
1055
 * NOTE:  In PC based system using (Cheetah or ARM) USB to SPI converter there can be no interrupts, however we still need something
1056
 *        to take the place of it and operate in a polled way. In an embedded system this function should be configured to be triggered
1057
 *        on any of the interrupts described above.
1058

1059
 * input parameters
1060
 *
1061
 * output parameters
1062
 *
1063
 * no return value
1064
 */
1065
void dwt_isr(void);
1066

    
1067
/*! ------------------------------------------------------------------------------------------------------------------
1068
 * @fn dwt_isr_lplisten()
1069
 *
1070
 * @brief This is the DW1000's Interrupt Service Routine to use when low-power listening scheme is implemented. It will
1071
 *        only process/report the RXFCG event (through cbRxOk callback).
1072
 *        It clears RXFCG interrupt and reads received frame information and frame control before calling the callback.
1073
 *
1074
 *        /!\ This version of the ISR is designed for single buffering case only!
1075
 *
1076
 * input parameters
1077
 *
1078
 * output parameters
1079
 *
1080
 * no return value
1081
 */
1082
void dwt_lowpowerlistenisr(void);
1083

    
1084
/*! ------------------------------------------------------------------------------------------------------------------
1085
 * @fn void dwt_setinterrupt()
1086
 *
1087
 * @brief This function enables the specified events to trigger an interrupt.
1088
 * The following events can be enabled:
1089
 * DWT_INT_TFRS         0x00000080          // frame sent
1090
 * DWT_INT_RFCG         0x00004000          // frame received with good CRC
1091
 * DWT_INT_RPHE         0x00001000          // receiver PHY header error
1092
 * DWT_INT_RFCE         0x00008000          // receiver CRC error
1093
 * DWT_INT_RFSL         0x00010000          // receiver sync loss error
1094
 * DWT_INT_RFTO         0x00020000          // frame wait timeout
1095
 * DWT_INT_RXPTO        0x00200000          // preamble detect timeout
1096
 * DWT_INT_SFDT         0x04000000          // SFD timeout
1097
 * DWT_INT_ARFE         0x20000000          // frame rejected (due to frame filtering configuration)
1098
 *
1099
 *
1100
 * input parameters:
1101
 * @param bitmask - sets the events which will generate interrupt
1102
 * @param enable - if set the interrupts are enabled else they are cleared
1103
 *
1104
 * output parameters
1105
 *
1106
 * no return value
1107
 */
1108
void dwt_setinterrupt( uint32_t bitmask, uint8_t enable);
1109

    
1110
/*! ------------------------------------------------------------------------------------------------------------------
1111
 * @fn dwt_setpanid()
1112
 *
1113
 * @brief This is used to set the PAN ID
1114
 *
1115
 * input parameters
1116
 * @param panID - this is the PAN ID
1117
 *
1118
 * output parameters
1119
 *
1120
 * no return value
1121
 */
1122
void dwt_setpanid(uint16_t panID);
1123

    
1124
/*! ------------------------------------------------------------------------------------------------------------------
1125
 * @fn dwt_setaddress16()
1126
 *
1127
 * @brief This is used to set 16-bit (short) address
1128
 *
1129
 * input parameters
1130
 * @param shortAddress - this sets the 16 bit short address
1131
 *
1132
 * output parameters
1133
 *
1134
 * no return value
1135
 */
1136
void dwt_setaddress16(uint16_t shortAddress);
1137

    
1138
/*! ------------------------------------------------------------------------------------------------------------------
1139
 * @fn dwt_seteui()
1140
 *
1141
 * @brief This is used to set the EUI 64-bit (long) address
1142
 *
1143
 * input parameters
1144
 * @param eui64 - this is the pointer to a buffer that contains the 64bit address
1145
 *
1146
 * output parameters
1147
 *
1148
 * no return value
1149
 */
1150
void dwt_seteui(uint8_t *eui64);
1151

    
1152
/*! ------------------------------------------------------------------------------------------------------------------
1153
 * @fn dwt_geteui()
1154
 *
1155
 * @brief This is used to get the EUI 64-bit from the DW1000
1156
 *
1157
 * input parameters
1158
 * @param eui64 - this is the pointer to a buffer that will contain the read 64-bit EUI value
1159
 *
1160
 * output parameters
1161
 *
1162
 * no return value
1163
 */
1164
void dwt_geteui(uint8_t *eui64);
1165

    
1166
/*! ------------------------------------------------------------------------------------------------------------------
1167
 * @fn dwt_otpread()
1168
 *
1169
 * @brief This is used to read the OTP data from given address into provided array
1170
 *
1171
 * input parameters
1172
 * @param address - this is the OTP address to read from
1173
 * @param array - this is the pointer to the array into which to read the data
1174
 * @param length - this is the number of 32 bit words to read (array needs to be at least this length)
1175
 *
1176
 * output parameters
1177
 *
1178
 * no return value
1179
 */
1180
void dwt_otpread(uint32_t address, uint32_t *array, uint8_t length);
1181

    
1182
/*! ------------------------------------------------------------------------------------------------------------------
1183
 * @fn dwt_enableframefilter()
1184
 *
1185
 * @brief This is used to enable the frame filtering - (the default option is to
1186
 * accept any data and ACK frames with correct destination address
1187
 *
1188
 * input parameters
1189
 * @param - bitmask - enables/disables the frame filtering options according to
1190
 *      DWT_FF_NOTYPE_EN        0x000   no frame types allowed
1191
 *      DWT_FF_COORD_EN         0x002   behave as coordinator (can receive frames with no destination address (PAN ID has to match))
1192
 *      DWT_FF_BEACON_EN        0x004   beacon frames allowed
1193
 *      DWT_FF_DATA_EN          0x008   data frames allowed
1194
 *      DWT_FF_ACK_EN           0x010   ack frames allowed
1195
 *      DWT_FF_MAC_EN           0x020   mac control frames allowed
1196
 *      DWT_FF_RSVD_EN          0x040   reserved frame types allowed
1197
 *
1198
 * output parameters
1199
 *
1200
 * no return value
1201
 */
1202
void dwt_enableframefilter(uint16_t bitmask);
1203

    
1204
/*! ------------------------------------------------------------------------------------------------------------------
1205
 * @fn dwt_enableautoack()
1206
 *
1207
 * @brief This call enables the auto-ACK feature. If the responseDelayTime (parameter) is 0, the ACK will be sent a.s.a.p.
1208
 * otherwise it will be sent with a programmed delay (in symbols), max is 255.
1209
 * NOTE: needs to have frame filtering enabled as well
1210
 *
1211
 * input parameters
1212
 * @param responseDelayTime - if non-zero the ACK is sent after this delay, max is 255.
1213
 *
1214
 * output parameters
1215
 *
1216
 * no return value
1217
 */
1218
void dwt_enableautoack(uint8_t responseDelayTime);
1219

    
1220
/*! ------------------------------------------------------------------------------------------------------------------
1221
 * @fn dwt_setrxaftertxdelay()
1222
 *
1223
 * @brief This sets the receiver turn on delay time after a transmission of a frame
1224
 *
1225
 * input parameters
1226
 * @param rxDelayTime - (20 bits) - the delay is in UWB microseconds
1227
 *
1228
 * output parameters
1229
 *
1230
 * no return value
1231
 */
1232
void dwt_setrxaftertxdelay(uint32_t rxDelayTime);
1233

    
1234
/*! ------------------------------------------------------------------------------------------------------------------
1235
 * @fn dwt_rxreset()
1236
 *
1237
 * @brief this function resets the receiver of the DW1000
1238
 *
1239
 * input parameters:
1240
 *
1241
 * output parameters
1242
 *
1243
 * no return value
1244
 */
1245
void dwt_rxreset(void);
1246

    
1247
/*! ------------------------------------------------------------------------------------------------------------------
1248
 * @fn dwt_softreset()
1249
 *
1250
 * @brief this function resets the DW1000
1251
 *
1252
 * input parameters:
1253
 *
1254
 * output parameters
1255
 *
1256
 * no return value
1257
 */
1258
void dwt_softreset(void) ;
1259

    
1260
/*! ------------------------------------------------------------------------------------------------------------------
1261
 * @fn dwt_readrxdata()
1262
 *
1263
 * @brief This is used to read the data from the RX buffer, from an offset location give by offset parameter
1264
 *
1265
 * input parameters
1266
 * @param buffer - the buffer into which the data will be read
1267
 * @param length - the length of data to read (in bytes)
1268
 * @param rxBufferOffset - the offset in the rx buffer from which to read the data
1269
 *
1270
 * output parameters
1271
 *
1272
 * no return value
1273
 */
1274
void dwt_readrxdata(uint8_t *buffer, uint16_t length, uint16_t rxBufferOffset);
1275

    
1276
/*! ------------------------------------------------------------------------------------------------------------------
1277
 * @fn dwt_readaccdata()
1278
 *
1279
 * @brief This is used to read the data from the Accumulator buffer, from an offset location give by offset parameter
1280
 *
1281
 * NOTE: Because of an internal memory access delay when reading the accumulator the first octet output is a dummy octet
1282
 *       that should be discarded. This is true no matter what sub-index the read begins at.
1283
 *
1284
 * input parameters
1285
 * @param buffer - the buffer into which the data will be read
1286
 * @param length - the length of data to read (in bytes)
1287
 * @param accOffset - the offset in the acc buffer from which to read the data
1288
 *
1289
 * output parameters
1290
 *
1291
 * no return value
1292
 */
1293
void dwt_readaccdata(uint8_t *buffer, uint16_t length, uint16_t rxBufferOffset);
1294

    
1295
/*! ------------------------------------------------------------------------------------------------------------------
1296
 * @fn dwt_readdiagnostics()
1297
 *
1298
 * @brief this function reads the RX signal quality diagnostic data
1299
 *
1300
 * input parameters
1301
 * @param diagnostics - diagnostic structure pointer, this will contain the diagnostic data read from the DW1000
1302
 *
1303
 * output parameters
1304
 *
1305
 * no return value
1306
 */
1307
void dwt_readdiagnostics(dwt_rxdiag_t * diagnostics);
1308

    
1309
/*! ------------------------------------------------------------------------------------------------------------------
1310
 * @fn dwt_loadopsettabfromotp()
1311
 *
1312
 * @brief This is used to select which Operational Parameter Set table to load from OTP memory
1313
 *
1314
 * input parameters
1315
 * @param ops_sel - Operational Parameter Set table to load:
1316
 *                  DWT_OPSET_64LEN = 0x0 - load the operational parameter set table for 64 length preamble configuration
1317
 *                  DWT_OPSET_TIGHT = 0x1 - load the operational parameter set table for tight xtal offsets (<1ppm)
1318
 *                  DWT_OPSET_DEFLT = 0x2 - load the default operational parameter set table (this is loaded from reset)
1319
 *
1320
 * output parameters
1321
 *
1322
 * no return value
1323
 */
1324
void dwt_loadopsettabfromotp(uint8_t ops_sel);
1325

    
1326
/*! ------------------------------------------------------------------------------------------------------------------
1327
 * @fn dwt_configeventcounters()
1328
 *
1329
 * @brief This is used to enable/disable the event counter in the IC
1330
 *
1331
 * input parameters
1332
 * @param - enable - 1 enables (and reset), 0 disables the event counters
1333
 * output parameters
1334
 *
1335
 * no return value
1336
 */
1337
void dwt_configeventcounters(int enable);
1338

    
1339
/*! ------------------------------------------------------------------------------------------------------------------
1340
 * @fn dwt_readeventcounters()
1341
 *
1342
 * @brief This is used to read the event counters in the IC
1343
 *
1344
 * input parameters
1345
 * @param counters - pointer to the dwt_deviceentcnts_t structure which will hold the read data
1346
 *
1347
 * output parameters
1348
 *
1349
 * no return value
1350
 */
1351
void dwt_readeventcounters(dwt_deviceentcnts_t *counters);
1352

    
1353
/*! ------------------------------------------------------------------------------------------------------------------
1354
 * @fn dwt_otpwriteandverify()
1355
 *
1356
 * @brief This is used to program 32-bit value into the DW1000 OTP memory.
1357
 *
1358
 * input parameters
1359
 * @param value - this is the 32-bit value to be programmed into OTP
1360
 * @param address - this is the 16-bit OTP address into which the 32-bit value is programmed
1361
 *
1362
 * output parameters
1363
 *
1364
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
1365
 */
1366
int dwt_otpwriteandverify(uint32_t value, uint16_t address);
1367

    
1368
/*! ------------------------------------------------------------------------------------------------------------------
1369
 * @fn dwt_setleds()
1370
 *
1371
 * @brief This is used to set up Tx/Rx GPIOs which could be used to control LEDs
1372
 * Note: not completely IC dependent, also needs board with LEDS fitted on right I/O lines
1373
 *       this function enables GPIOs 2 and 3 which are connected to LED3 and LED4 on EVB1000
1374
 *
1375
 * input parameters
1376
 * @param mode - this is a bit field interpreted as follows:
1377
 *          - bit 0: 1 to enable LEDs, 0 to disable them
1378
 *          - bit 1: 1 to make LEDs blink once on init. Only valid if bit 0 is set (enable LEDs)
1379
 *          - bit 2 to 7: reserved
1380
 *
1381
 * output parameters none
1382
 *
1383
 * no return value
1384
 */
1385
void dwt_setleds(uint8_t mode);
1386

    
1387
/*! ------------------------------------------------------------------------------------------------------------------
1388
 * @fn dwt_setxtaltrim()
1389
 *
1390
 * @brief This is used to adjust the crystal frequency
1391
 *
1392
 * input parameters:
1393
 * @param   value - crystal trim value (in range 0x0 to 0x1F) 31 steps (~1.5ppm per step)
1394
 *
1395
 * output parameters
1396
 *
1397
 * no return value
1398
 */
1399
void dwt_setxtaltrim(uint8_t value);
1400

    
1401
/*! ------------------------------------------------------------------------------------------------------------------
1402
 * @fn dwt_getinitxtaltrim()
1403
 *
1404
 * @brief This function returns the value of XTAL trim that has been applied during initialisation (dwt_init). This can
1405
 *        be either the value read in OTP memory or a default value.
1406
 *
1407
 * NOTE: The value returned by this function is the initial value only! It is not updated on dwt_setxtaltrim calls.
1408
 *
1409
 * input parameters
1410
 *
1411
 * output parameters
1412
 *
1413
 * returns the XTAL trim value set upon initialisation
1414
 */
1415
uint8_t dwt_getinitxtaltrim(void);
1416

    
1417
/*! ------------------------------------------------------------------------------------------------------------------
1418
 * @fn dwt_configcwmode()
1419
 *
1420
 * @brief this function sets the DW1000 to transmit cw signal at specific channel frequency
1421
 *
1422
 * input parameters:
1423
 * @param chan - specifies the operating channel (e.g. 1, 2, 3, 4, 5, 6 or 7)
1424
 *
1425
 * output parameters
1426
 *
1427
 * no return value
1428
 */
1429
void dwt_configcwmode(uint8_t chan);
1430

    
1431
/*! ------------------------------------------------------------------------------------------------------------------
1432
 * @fn dwt_configcontinuousframemode()
1433
 *
1434
 * @brief this function sets the DW1000 to continuous tx frame mode for regulatory approvals testing.
1435
 *
1436
 * input parameters:
1437
 * @param framerepetitionrate - This is a 32-bit value that is used to set the interval between transmissions.
1438
*  The minimum value is 4. The units are approximately 8 ns. (or more precisely 512/(499.2e6*128) seconds)).
1439
 *
1440
 * output parameters
1441
 *
1442
 * no return value
1443
 */
1444
void dwt_configcontinuousframemode(uint32_t framerepetitionrate);
1445

    
1446
/*! ------------------------------------------------------------------------------------------------------------------
1447
 * @fn dwt_readtempvbat()
1448
 *
1449
 * @brief this function reads the battery voltage and temperature of the MP
1450
 * The values read here will be the current values sampled by DW1000 AtoD converters.
1451
 * Note on Temperature: the temperature value needs to be converted to give the real temperature
1452
 * the formula is: 1.13 * reading - 113.0
1453
 * Note on Voltage: the voltage value needs to be converted to give the real voltage
1454
 * the formula is: 0.0057 * reading + 2.3
1455
 *
1456
 * NB: To correctly read the temperature this read should be done with xtal clock
1457
 * however that means that the receiver will be switched off, if receiver needs to be on then
1458
 * the timer is used to make sure the value is stable before reading
1459
 *
1460
 * input parameters:
1461
 * @param fastSPI - set to 1 if SPI rate > than 3MHz is used
1462
 *
1463
 * output parameters
1464
 *
1465
 * returns  (temp_raw<<8)|(vbat_raw)
1466
 */
1467
uint16_t dwt_readtempvbat(uint8_t fastSPI);
1468

    
1469
/*! ------------------------------------------------------------------------------------------------------------------
1470
 * @fn dwt_readwakeuptemp()
1471
 *
1472
 * @brief this function reads the temperature of the DW1000 that was sampled
1473
 * on waking from Sleep/Deepsleep. They are not current values, but read on last
1474
 * wakeup if DWT_TANDV bit is set in mode parameter of dwt_configuresleep
1475
 *
1476
 * input parameters:
1477
 *
1478
 * output parameters:
1479
 *
1480
 * returns: 8-bit raw temperature sensor value
1481
 */
1482
uint8_t dwt_readwakeuptemp(void) ;
1483

    
1484
/*! ------------------------------------------------------------------------------------------------------------------
1485
 * @fn dwt_readwakeupvbat()
1486
 *
1487
 * @brief this function reads the battery voltage of the DW1000 that was sampled
1488
 * on waking from Sleep/Deepsleep. They are not current values, but read on last
1489
 * wakeup if DWT_TANDV bit is set in mode parameter of dwt_configuresleep
1490
 *
1491
 * input parameters:
1492
 *
1493
 * output parameters:
1494
 *
1495
 * returns: 8-bit raw battery voltage sensor value
1496
 */
1497
uint8_t dwt_readwakeupvbat(void) ;
1498

    
1499
/*! ------------------------------------------------------------------------------------------------------------------
1500
 * @fn dwt_calcbandwidthtempadj()
1501
 *
1502
 * @brief this function determines the corrected bandwidth setting (PG_DELAY register setting)
1503
 * of the DW1000 which changes over temperature.
1504
 *
1505
 * input parameters:
1506
 * @param target_count - uint16_t - the PG count target to reach in order to correct the bandwidth
1507
 *
1508
 * output parameters:
1509
 *
1510
 * returns: (uint32) The setting to be programmed into the PG_DELAY value
1511
 */
1512
uint32_t dwt_calcbandwidthtempadj(uint16_t target_count);
1513

    
1514
/*! ------------------------------------------------------------------------------------------------------------------
1515
 * @fn dwt_calcpowertempadj()
1516
 *
1517
 * @brief this function determines the corrected power setting (TX_POWER setting) for the
1518
 * DW1000 which changes over temperature.
1519
 *
1520
 * input parameters:
1521
 * @param channel - uint8_t - the channel at which compensation of power level will be applied
1522
 * @param ref_powerreg - uint32_t - the TX_POWER register value recorded when reference measurements were made
1523
 * @param current_temperature - double - the current ambient temperature in degrees Celcius
1524
 * @param reference_temperature - double - the temperature at which reference measurements were made
1525
 * output parameters: None
1526
 *
1527
 * returns: (uint32) The corrected TX_POWER register value
1528
 */
1529
uint32_t dwt_calcpowertempadj(uint8_t channel, uint32_t ref_powerreg, double current_temperature, double reference_temperature);
1530

    
1531
/*! ------------------------------------------------------------------------------------------------------------------
1532
 * @fn dwt_calcpgcount()
1533
 *
1534
 * @brief this function calculates the value in the pulse generator counter register (PGC_STATUS) for a given PG_DELAY
1535
 * This is used to take a reference measurement, and the value recorded as the reference is used to adjust the
1536
 * bandwidth of the device when the temperature changes.
1537
 *
1538
 * input parameters:
1539
 * @param pgdly - uint8_t - the PG_DELAY to set (to control bandwidth), and to find the corresponding count value for
1540
 * output parameters: None
1541
 *
1542
 * returns: (uint16) PGC_STATUS count value calculated from the provided PG_DELAY value - used as reference for later
1543
 * bandwidth adjustments
1544
 */
1545
uint16_t dwt_calcpgcount(uint8_t pgdly);
1546

    
1547
/*! ------------------------------------------------------------------------------------------------------------------
1548
 * @fn dwt_writetodevice()
1549
 *
1550
 * @brief  this function is used to write to the DW1000 device registers
1551
 * Notes:
1552
 *        1. Firstly we create a header (the first byte is a header byte)
1553
 *        a. check if sub index is used, if subindexing is used - set bit-6 to 1 to signify that the sub-index address follows the register index byte
1554
 *        b. set bit-7 (or with 0x80) for write operation
1555
 *        c. if extended sub address index is used (i.e. if index > 127) set bit-7 of the first sub-index byte following the first header byte
1556
 *
1557
 *        2. Write the header followed by the data bytes to the DW1000 device
1558
 *
1559
 *
1560
 * input parameters:
1561
 * @param recordNumber  - ID of register file or buffer being accessed
1562
 * @param index         - byte index into register file or buffer being accessed
1563
 * @param length        - number of bytes being written
1564
 * @param buffer        - pointer to buffer containing the 'length' bytes to be written
1565
 *
1566
 * output parameters
1567
 *
1568
 * no return value
1569
 */
1570
void dwt_writetodevice
1571
(
1572
    uint16_t      recordNumber,   // input parameter - ID of register file or buffer being accessed
1573
    uint16_t      index,          // input parameter - byte index into register file or buffer being accessed
1574
    uint32_t      length,         // input parameter - number of bytes being written
1575
    const uint8_t *buffer         // input parameter - pointer to buffer containing the 'length' bytes to be written
1576
) ;
1577

    
1578
/*! ------------------------------------------------------------------------------------------------------------------
1579
 * @fn dwt_readfromdevice()
1580
 *
1581
 * @brief  this function is used to read from the DW1000 device registers
1582
 * Notes:
1583
 *        1. Firstly we create a header (the first byte is a header byte)
1584
 *        a. check if sub index is used, if subindexing is used - set bit-6 to 1 to signify that the sub-index address follows the register index byte
1585
 *        b. set bit-7 (or with 0x80) for write operation
1586
 *        c. if extended sub address index is used (i.e. if index > 127) set bit-7 of the first sub-index byte following the first header byte
1587
 *
1588
 *        2. Write the header followed by the data bytes to the DW1000 device
1589
 *        3. Store the read data in the input buffer
1590
 *
1591
 * input parameters:
1592
 * @param recordNumber  - ID of register file or buffer being accessed
1593
 * @param index         - byte index into register file or buffer being accessed
1594
 * @param length        - number of bytes being read
1595
 * @param buffer        - pointer to buffer in which to return the read data.
1596
 *
1597
 * output parameters
1598
 *
1599
 * no return value
1600
 */
1601
void dwt_readfromdevice
1602
(
1603
    uint16_t  recordNumber,       // input parameter - ID of register file or buffer being accessed
1604
    uint16_t  index,              // input parameter - byte index into register file or buffer being accessed
1605
    uint32_t  length,             // input parameter - number of bytes being read
1606
    uint8_t   *buffer             // input parameter - pointer to buffer in which to return the read data.
1607
) ;
1608

    
1609
/*! ------------------------------------------------------------------------------------------------------------------
1610
 * @fn dwt_read32bitoffsetreg()
1611
 *
1612
 * @brief  this function is used to read 32-bit value from the DW1000 device registers
1613
 *
1614
 * input parameters:
1615
 * @param regFileID - ID of register file or buffer being accessed
1616
 * @param regOffset - the index into register file or buffer being accessed
1617
 *
1618
 * output parameters
1619
 *
1620
 * returns 32 bit register value
1621
 */
1622
uint32_t dwt_read32bitoffsetreg(int regFileID, int regOffset) ;
1623

    
1624
/*! ------------------------------------------------------------------------------------------------------------------
1625
 * @fn dwt_write32bitoffsetreg()
1626
 *
1627
 * @brief  this function is used to write 32-bit value to the DW1000 device registers
1628
 *
1629
 * input parameters:
1630
 * @param regFileID - ID of register file or buffer being accessed
1631
 * @param regOffset - the index into register file or buffer being accessed
1632
 * @param regval    - the value to write
1633
 *
1634
 * output parameters
1635
 *
1636
 * no return value
1637
 */
1638
void dwt_write32bitoffsetreg(int regFileID, int regOffset, uint32_t regval);
1639

    
1640
#define dwt_write32bitreg(x,y)  dwt_write32bitoffsetreg(x,0,y)
1641
#define dwt_read32bitreg(x)     dwt_read32bitoffsetreg(x,0)
1642

    
1643
/*! ------------------------------------------------------------------------------------------------------------------
1644
 * @fn dwt_read16bitoffsetreg()
1645
 *
1646
 * @brief  this function is used to read 16-bit value from the DW1000 device registers
1647
 *
1648
 * input parameters:
1649
 * @param regFileID - ID of register file or buffer being accessed
1650
 * @param regOffset - the index into register file or buffer being accessed
1651
 *
1652
 * output parameters
1653
 *
1654
 * returns 16 bit register value
1655
 */
1656
uint16_t dwt_read16bitoffsetreg(int regFileID, int regOffset);
1657

    
1658
/*! ------------------------------------------------------------------------------------------------------------------
1659
 * @fn dwt_write16bitoffsetreg()
1660
 *
1661
 * @brief  this function is used to write 16-bit value to the DW1000 device registers
1662
 *
1663
 * input parameters:
1664
 * @param regFileID - ID of register file or buffer being accessed
1665
 * @param regOffset - the index into register file or buffer being accessed
1666
 * @param regval    - the value to write
1667
 *
1668
 * output parameters
1669
 *
1670
 * no return value
1671
 */
1672
void dwt_write16bitoffsetreg(int regFileID, int regOffset, uint16_t regval) ;
1673

    
1674
/*! ------------------------------------------------------------------------------------------------------------------
1675
 * @fn dwt_read8bitoffsetreg()
1676
 *
1677
 * @brief  this function is used to read an 8-bit value from the DW1000 device registers
1678
 *
1679
 * input parameters:
1680
 * @param regFileID - ID of register file or buffer being accessed
1681
 * @param regOffset - the index into register file or buffer being accessed
1682
 *
1683
 * output parameters
1684
 *
1685
 * returns 8-bit register value
1686
 */
1687
uint8_t dwt_read8bitoffsetreg(int regFileID, int regOffset);
1688

    
1689
/*! ------------------------------------------------------------------------------------------------------------------
1690
 * @fn dwt_write8bitoffsetreg()
1691
 *
1692
 * @brief  this function is used to write an 8-bit value to the DW1000 device registers
1693
 *
1694
 * input parameters:
1695
 * @param regFileID - ID of register file or buffer being accessed
1696
 * @param regOffset - the index into register file or buffer being accessed
1697
 * @param regval    - the value to write
1698
 *
1699
 * output parameters
1700
 *
1701
 * no return value
1702
 */
1703
void dwt_write8bitoffsetreg(int regFileID, int regOffset, uint8_t regval);
1704

    
1705

    
1706
/****************************************************************************************************************************************************
1707
 *
1708
 * Declaration of platform-dependent lower level functions.
1709
 *
1710
 ****************************************************************************************************************************************************/
1711

    
1712

    
1713
/*! ------------------------------------------------------------------------------------------------------------------
1714
 * @fn writetospi()
1715
 *
1716
 * @brief
1717
 * NB: In porting this to a particular microprocessor, the implementer needs to define the two low
1718
 * level abstract functions to write to and read from the SPI.
1719
 * Low level abstract function to write to the SPI
1720
 * Takes two separate byte buffers for write header and write data
1721
 * returns 0 for success, or -1 for error
1722
 *
1723
 * Note: The body of this function is platform specific
1724
 *
1725
 * input parameters:
1726
 * @param headerLength  - number of bytes header being written
1727
 * @param headerBuffer  - pointer to buffer containing the 'headerLength' bytes of header to be written
1728
 * @param bodylength    - number of bytes data being written
1729
 * @param bodyBuffer    - pointer to buffer containing the 'bodylength' bytes od data to be written
1730
 *
1731
 * output parameters
1732
 *
1733
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
1734
 */
1735
extern int writetospi(uint16_t headerLength, const uint8_t *headerBuffer, uint32_t bodylength, const uint8_t *bodyBuffer);
1736

    
1737
/*! ------------------------------------------------------------------------------------------------------------------
1738
 * @fn readfromspi()
1739
 *
1740
 * @brief
1741
 * NB: In porting this to a particular microprocessor, the implementer needs to define the two low
1742
 * level abstract functions to write to and read from the SPI.
1743
 * Low level abstract function to write to the SPI
1744
 * Takes two separate byte buffers for write header and write data
1745
 * returns 0 for success, or -1 for error
1746
 *
1747
 * Note: The body of this function is platform specific
1748
 *
1749
 * input parameters:
1750
 * @param headerLength  - number of bytes header to write
1751
 * @param headerBuffer  - pointer to buffer containing the 'headerLength' bytes of header to write
1752
 * @param readlength    - number of bytes data being read
1753
 * @param readBuffer    - pointer to buffer containing to return the data (NB: size required = headerLength + readlength)
1754
 *
1755
 * output parameters
1756
 *
1757
 * returns DWT_SUCCESS for success (and the position in the buffer at which data begins), or DWT_ERROR for error
1758
 */
1759
extern int readfromspi(uint16_t headerLength, const uint8_t *headerBuffer, uint32_t readlength, uint8_t *readBuffer);
1760

    
1761
// ---------------------------------------------------------------------------
1762
//
1763
// NB: The purpose of the deca_mutex.c file is to provide for microprocessor interrupt enable/disable, this is used for
1764
//     controlling mutual exclusion from critical sections in the code where interrupts and background
1765
//     processing may interact.  The code using this is kept to a minimum and the disabling time is also
1766
//     kept to a minimum, so blanket interrupt disable may be the easiest way to provide this.  But at a
1767
//     minimum those interrupts coming from the decawave device should be disabled/re-enabled by this activity.
1768
//
1769
//     In porting this to a particular microprocessor, the implementer may choose to use #defines here
1770
//     to map these calls transparently to the target system.  Alternatively the appropriate code may
1771
//     be embedded in the functions provided in the deca_irq.c file.
1772
//
1773
// ---------------------------------------------------------------------------
1774

    
1775
typedef int decaIrqStatus_t ; // Type for remembering IRQ status
1776

    
1777

    
1778
/*! ------------------------------------------------------------------------------------------------------------------
1779
 * @fn decamutexon()
1780
 *
1781
 * @brief This function should disable interrupts. This is called at the start of a critical section
1782
 * It returns the IRQ state before disable, this value is used to re-enable in decamutexoff call
1783
 *
1784
 * Note: The body of this function is platform specific
1785
 *
1786
 * input parameters:
1787
 *
1788
 * output parameters
1789
 *
1790
 * returns the state of the DW1000 interrupt
1791
 */
1792
decaIrqStatus_t decamutexon(void) ;
1793

    
1794
/*! ------------------------------------------------------------------------------------------------------------------
1795
 * @fn decamutexoff()
1796
 *
1797
 * @brief This function should re-enable interrupts, or at least restore their state as returned(&saved) by decamutexon
1798
 * This is called at the end of a critical section
1799
 *
1800
 * Note: The body of this function is platform specific
1801
 *
1802
 * input parameters:
1803
 * @param s - the state of the DW1000 interrupt as returned by decamutexon
1804
 *
1805
 * output parameters
1806
 *
1807
 * returns the state of the DW1000 interrupt
1808
 */
1809
void decamutexoff(decaIrqStatus_t s) ;
1810

    
1811
/*! ------------------------------------------------------------------------------------------------------------------
1812
 * @fn deca_sleep()
1813
 *
1814
 * @brief Wait for a given amount of time.
1815
 * NB: The body of this function is platform specific
1816
 *
1817
 * input parameters:
1818
 * @param time_ms - time to wait in milliseconds
1819
 *
1820
 * output parameters
1821
 *
1822
 * no return value
1823
 */
1824
void deca_sleep(unsigned int time_ms);
1825

    
1826

    
1827
void port_set_dw1000_slowrate(void);
1828
void port_set_dw1000_fastrate(void);
1829
void port_wakeup_dw1000_fast(void);
1830
uint32_t portGetTickCnt(void);
1831

    
1832
#endif /* defined(AMIROLLD_CFG_USE_DW1000) */
1833

    
1834
#endif //__AMIROLLD_DW1000_H__