修改注册标签记录容量

zhyinch

2021-12-03 9c28e7574073507108daa81009443bd4963ca380

 源码/核心板/Src/decadriver/deca_device_api.h

@@ -13,51 +13,10 @@
#ifndef _DECA_DEVICE_API_H_
#define _DECA_DEVICE_API_H_

#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif


#ifndef uint8
#ifndef _DECA_UINT8_
#define _DECA_UINT8_
typedef unsigned char uint8;
#endif
#endif

#ifndef uint16
#ifndef _DECA_UINT16_
#define _DECA_UINT16_
typedef unsigned short uint16;
#endif
#endif

#ifndef uint32
#ifndef _DECA_UINT32_
#define _DECA_UINT32_
typedef unsigned long uint32;
#endif
#endif

#ifndef int8
#ifndef _DECA_INT8_
#define _DECA_INT8_
typedef signed char int8;
#endif
#endif

#ifndef int16
#ifndef _DECA_INT16_
#define _DECA_INT16_
typedef signed short int16;
#endif
#endif

#ifndef int32
#ifndef _DECA_INT32_
#define _DECA_INT32_
typedef signed long int32;
#endif
#endif

#define DWT_SUCCESS (0)
@@ -170,12 +129,12 @@
typedef struct
{

    uint32 status;      //initial value of register as ISR is entered
    uint8  event;      //event type
    uint8  aatset;      //auto ACK TX bit is set
    uint16 datalength;   //length of frame
    uint8  fctrl[2];   //frame control bytes
    uint8  dblbuff ;   //set if double buffer is enabled
    uint32_t status;      //initial value of register as ISR is entered
    uint8_t  event;      //event type
    uint8_t  aatset;      //auto ACK TX bit is set
    uint16_t datalength;   //length of frame
    uint8_t  fctrl[2];   //frame control bytes
    uint8_t  dblbuff ;   //set if double buffer is enabled

} dwt_callback_data_t;

@@ -201,29 +160,29 @@
#pragma pack(1)
typedef struct
{
    uint8 chan ;           //!< channel number {1, 2, 3, 4, 5, 7 }
    uint8 prf ;            //!< Pulse Repetition Frequency {DWT_PRF_16M or DWT_PRF_64M}
    uint8 txPreambLength ; //!< DWT_PLEN_64..DWT_PLEN_4096
    uint8 rxPAC ;          //!< Acquisition Chunk Size (Relates to RX preamble length)
    uint8 txCode ;         //!< TX preamble code
    uint8 rxCode ;         //!< RX preamble code
    uint8 nsSFD ;          //!< Boolean should we use non-standard SFD for better performance
    uint8 dataRate ;       //!< Data Rate {DWT_BR_110K, DWT_BR_850K or DWT_BR_6M8}
    uint8 phrMode ;        //!< PHR mode {0x0 - standard DWT_PHRMODE_STD, 0x3 - extended frames DWT_PHRMODE_EXT}
    uint16 sfdTO ;         //!< SFD timeout value (in symbols)
    uint8_t chan ;           //!< channel number {1, 2, 3, 4, 5, 7 }
    uint8_t prf ;            //!< Pulse Repetition Frequency {DWT_PRF_16M or DWT_PRF_64M}
    uint8_t txPreambLength ; //!< DWT_PLEN_64..DWT_PLEN_4096
    uint8_t rxPAC ;          //!< Acquisition Chunk Size (Relates to RX preamble length)
    uint8_t txCode ;         //!< TX preamble code
    uint8_t rxCode ;         //!< RX preamble code
    uint8_t nsSFD ;          //!< Boolean should we use non-standard SFD for better performance
    uint8_t dataRate ;       //!< Data Rate {DWT_BR_110K, DWT_BR_850K or DWT_BR_6M8}
    uint8_t phrMode ;        //!< PHR mode {0x0 - standard DWT_PHRMODE_STD, 0x3 - extended frames DWT_PHRMODE_EXT}
    uint16_t sfdTO ;         //!< SFD timeout value (in symbols)
} __attribute__ ((packed))  dwt_config_t ;
#pragma pack()


typedef struct
{
    uint8   PGdly;
    uint8_t   PGdly;
    //TX POWER
    //31:24      BOOST_0.125ms_PWR
    //23:16      BOOST_0.25ms_PWR-TX_SHR_PWR
    //15:8      BOOST_0.5ms_PWR-TX_PHR_PWR
    //7:0      DEFAULT_PWR-TX_DATA_PWR
    uint32   power;
    uint32_t   power;
}
dwt_txconfig_t ;

@@ -231,34 +190,34 @@
typedef struct
{

    uint16      maxNoise ;         // LDE max value of noise
    uint16      firstPathAmp1 ;       // Amplitude at floor(index FP) + 1
    uint16      stdNoise ;         // Standard deviation of noise
    uint16      firstPathAmp2 ;      // Amplitude at floor(index FP) + 2
    uint16      firstPathAmp3 ;      // Amplitude at floor(index FP) + 3
    uint16      maxGrowthCIR ;      // Channel Impulse Response max growth CIR
    uint16      rxPreamCount ;      // Count of preamble symbols accumulated
    //uint32        debug1;
    //uint32        debug2;
    uint16      firstPath ;         // First path index (10.6 bits fixed point integer)
    uint16_t      maxNoise ;         // LDE max value of noise
    uint16_t      firstPathAmp1 ;       // Amplitude at floor(index FP) + 1
    uint16_t      stdNoise ;         // Standard deviation of noise
    uint16_t      firstPathAmp2 ;      // Amplitude at floor(index FP) + 2
    uint16_t      firstPathAmp3 ;      // Amplitude at floor(index FP) + 3
    uint16_t      maxGrowthCIR ;      // Channel Impulse Response max growth CIR
    uint16_t      rxPreamCount ;      // Count of preamble symbols accumulated
    //uint32_t        debug1;
    //uint32_t        debug2;
    uint16_t      firstPath ;         // First path index (10.6 bits fixed point integer)
} dwt_rxdiag_t ;


typedef struct
{
    //all of the below are mapped to a 12-bit register in DW1000
    uint16 PHE ;               //number of received header errors
    uint16 RSL ;               //number of received frame sync loss events
    uint16 CRCG ;               //number of good CRC received frames
    uint16 CRCB ;               //number of bad CRC (CRC error) received frames
    uint16 ARFE ;               //number of address filter errors
    uint16 OVER ;               //number of receiver overflows (used in double buffer mode)
    uint16 SFDTO ;               //SFD timeouts
    uint16 PTO ;               //Preamble timeouts
    uint16 RTO ;               //RX frame wait timeouts
    uint16 TXF ;               //number of transmitted frames
    uint16 HPW ;               //half period warn
    uint16 TXW ;               //power up warn
    uint16_t PHE ;               //number of received header errors
    uint16_t RSL ;               //number of received frame sync loss events
    uint16_t CRCG ;               //number of good CRC received frames
    uint16_t CRCB ;               //number of bad CRC (CRC error) received frames
    uint16_t ARFE ;               //number of address filter errors
    uint16_t OVER ;               //number of receiver overflows (used in double buffer mode)
    uint16_t SFDTO ;               //SFD timeouts
    uint16_t PTO ;               //Preamble timeouts
    uint16_t RTO ;               //RX frame wait timeouts
    uint16_t TXF ;               //number of transmitted frames
    uint16_t HPW ;               //half period warn
    uint16_t TXW ;               //power up warn

} dwt_deviceentcnts_t ;

@@ -274,7 +233,7 @@
 *
 * returns the 32 bit part ID value as programmed in the factory
 */
uint32 dwt_getpartid(void);
uint32_t dwt_getpartid(void);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_getlotid()
@@ -287,7 +246,7 @@
 *
 * returns the 32 bit lot ID value as programmed in the factory
 */
uint32 dwt_getlotid(void);
uint32_t dwt_getlotid(void);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readdevid()
@@ -300,7 +259,7 @@
 *
 * returns the read value which for DW1000 is 0xDECA0130
 */
uint32 dwt_readdevid(void);
uint32_t dwt_readdevid(void);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_otprevision()
@@ -313,7 +272,7 @@
 *
 * returns the read OTP revision value
 */
uint8 dwt_otprevision(void);
uint8_t dwt_otprevision(void);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_setGPIOforEXTTRX()
@@ -341,7 +300,7 @@
 *
 * no return value
 */
void dwt_setGPIOdirection(uint32 gpioNum, uint32 direction);
void dwt_setGPIOdirection(uint32_t gpioNum, uint32_t direction);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_setGPIOvalue()
@@ -356,7 +315,7 @@
 *
 * no return value
 */
void dwt_setGPIOvalue(uint32 gpioNum, uint32 value);
void dwt_setGPIOvalue(uint32_t gpioNum, uint32_t value);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_initialise()
@@ -380,7 +339,7 @@
 *
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
 */
int dwt_initialise(uint16 config) ;
int dwt_initialise(uint16_t config) ;

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_configure()
@@ -428,7 +387,7 @@
 *
 * no return value
 */
void dwt_setrxantennadelay(uint16 antennaDly);
void dwt_setrxantennadelay(uint16_t antennaDly);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_settxantennadelay()
@@ -443,7 +402,7 @@
 *
 * no return value
 */
void dwt_settxantennadelay(uint16 antennaDly);
void dwt_settxantennadelay(uint16_t antennaDly);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_setsmarttxpower()
@@ -479,7 +438,7 @@
 *
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
 */
int dwt_writetxdata(uint16 txFrameLength, uint8 *txFrameBytes, uint16 txBufferOffset) ;
int dwt_writetxdata(uint16_t txFrameLength, uint8_t *txFrameBytes, uint16_t txBufferOffset) ;

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_writetxfctrl()
@@ -497,7 +456,7 @@
 *
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
 */
int dwt_writetxfctrl(uint16 txFrameLength, uint16 txBufferOffset) ;
int dwt_writetxfctrl(uint16_t txFrameLength, uint16_t txBufferOffset) ;

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_starttx()
@@ -514,7 +473,7 @@
 *
 * returns DWT_SUCCESS for success, or DWT_ERROR for error (e.g. a delayed transmission will fail if the delayed time has passed)
 */
int dwt_starttx(uint8 mode) ;
int dwt_starttx(uint8_t mode) ;

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_setdelayedtrxtime()
@@ -529,7 +488,7 @@
 *
 * no return value
 */
void dwt_setdelayedtrxtime(uint32 starttime) ;
void dwt_setdelayedtrxtime(uint32_t starttime) ;

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readtxtimestamp()
@@ -543,7 +502,7 @@
 *
 * no return value
 */
void dwt_readtxtimestamp(uint8 *timestamp);
void dwt_readtxtimestamp(uint8_t *timestamp);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readtxtimestamphi32()
@@ -556,7 +515,7 @@
 *
 * returns high 32-bits of TX timestamp
 */
uint32 dwt_readtxtimestamphi32(void);
uint32_t dwt_readtxtimestamphi32(void);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readtxtimestamplo32()
@@ -569,7 +528,7 @@
 *
 * returns low 32-bits of TX timestamp
 */
uint32 dwt_readtxtimestamplo32(void);
uint32_t dwt_readtxtimestamplo32(void);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readrxtimestamp()
@@ -583,7 +542,7 @@
 *
 * no return value
 */
void dwt_readrxtimestamp(uint8 *timestamp);
void dwt_readrxtimestamp(uint8_t *timestamp);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readrxtimestamphi32()
@@ -596,7 +555,7 @@
 *
 * returns high 32-bits of RX timestamp
 */
uint32 dwt_readrxtimestamphi32(void);
uint32_t dwt_readrxtimestamphi32(void);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readrxtimestamplo32()
@@ -609,7 +568,7 @@
 *
 * returns low 32-bits of RX timestamp
 */
uint32 dwt_readrxtimestamplo32(void);
uint32_t dwt_readrxtimestamplo32(void);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readsystimestamphi32()
@@ -622,7 +581,7 @@
 *
 * returns high 32-bits of system time timestamp
 */
uint32 dwt_readsystimestamphi32(void);
uint32_t dwt_readsystimestamphi32(void);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readsystime()
@@ -637,7 +596,7 @@
 *
 * no return value
 */
void dwt_readsystime(uint8 *timestamp);
void dwt_readsystime(uint8_t *timestamp);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_checkoverrun()
@@ -714,7 +673,7 @@
#define DWT_RX_NORMAL (0x0)
#define DWT_RX_SNIFF  (0x1)

void dwt_setrxmode(int mode, uint8 rxON, uint8 rxOFF);
void dwt_setrxmode(int mode, uint8_t rxON, uint8_t rxOFF);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_setautorxreenable()
@@ -758,7 +717,7 @@
 *
 * no return value
 */
void dwt_setrxtimeout(uint16 time);
void dwt_setrxtimeout(uint16_t time);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_setpreambledetecttimeout()
@@ -772,7 +731,7 @@
 *
 * no return value
 */
void dwt_setpreambledetecttimeout(uint16 timeout);
void dwt_setpreambledetecttimeout(uint16_t timeout);


/*! ------------------------------------------------------------------------------------------------------------------
@@ -788,7 +747,7 @@
 *
 * returns the number of XTAL/2 cycles per low-power oscillator cycle. LP OSC frequency = 19.2 MHz/return value
 */
uint16 dwt_calibratesleepcnt(void);
uint16_t dwt_calibratesleepcnt(void);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_configuresleepcnt()
@@ -804,7 +763,7 @@
 *
 * no return value
 */
void dwt_configuresleepcnt(uint16 sleepcnt);
void dwt_configuresleepcnt(uint16_t sleepcnt);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_configuresleep()
@@ -839,7 +798,7 @@
 *
 * no return value
 */
void dwt_configuresleep(uint16 mode, uint8 wake);
void dwt_configuresleep(uint16_t mode, uint8_t wake);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_entersleep()
@@ -896,7 +855,7 @@
 *
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
 */
int dwt_spicswakeup(uint8 *buff, uint16 length);
int dwt_spicswakeup(uint8_t *buff, uint16_t length);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_setcallbacks()
@@ -924,7 +883,7 @@
 *
 * return value is 1 if the IRQS bit is set and 0 otherwise
 */
uint8 dwt_checkIRQ(void);
uint8_t dwt_checkIRQ(void);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_isr()
@@ -968,7 +927,7 @@
 *
 * no return value
 */
void dwt_setinterrupt( uint32 bitmask, uint8 enable);
void dwt_setinterrupt( uint32_t bitmask, uint8_t enable);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_setpanid()
@@ -982,7 +941,7 @@
 *
 * no return value
 */
void dwt_setpanid(uint16 panID);
void dwt_setpanid(uint16_t panID);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_setaddress16()
@@ -996,7 +955,7 @@
 *
 * no return value
 */
void dwt_setaddress16(uint16 shortAddress);
void dwt_setaddress16(uint16_t shortAddress);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_seteui()
@@ -1010,7 +969,7 @@
 *
 * no return value
 */
void dwt_seteui(uint8 *eui64);
void dwt_seteui(uint8_t *eui64);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_geteui()
@@ -1024,7 +983,7 @@
 *
 * no return value
 */
void dwt_geteui(uint8 *eui64);
void dwt_geteui(uint8_t *eui64);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_otpread()
@@ -1040,7 +999,7 @@
 *
 * no return value
 */
void dwt_otpread(uint32 address, uint32 *array, uint8 length);
void dwt_otpread(uint32_t address, uint32_t *array, uint8_t length);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_enableframefilter()
@@ -1062,7 +1021,7 @@
 *
 * no return value
 */
void dwt_enableframefilter(uint16 bitmask);
void dwt_enableframefilter(uint16_t bitmask);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_enableautoack()
@@ -1078,7 +1037,7 @@
 *
 * no return value
 */
void dwt_enableautoack(uint8 responseDelayTime);
void dwt_enableautoack(uint8_t responseDelayTime);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_setrxaftertxdelay()
@@ -1092,7 +1051,7 @@
 *
 * no return value
 */
void dwt_setrxaftertxdelay(uint32 rxDelayTime);
void dwt_setrxaftertxdelay(uint32_t rxDelayTime);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_rxreset()
@@ -1134,7 +1093,7 @@
 *
 * no return value
 */
void dwt_readrxdata(uint8 *buffer, uint16 length, uint16 rxBufferOffset);
void dwt_readrxdata(uint8_t *buffer, uint16_t length, uint16_t rxBufferOffset);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readaccdata()
@@ -1150,7 +1109,7 @@
 *
 * no return value
 */
void dwt_readaccdata(uint8 *buffer, uint16 length, uint16 rxBufferOffset);
void dwt_readaccdata(uint8_t *buffer, uint16_t length, uint16_t rxBufferOffset);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readdiagnostics()
@@ -1181,7 +1140,7 @@
 *
 * no return value
 */
void  dwt_loadopsettabfromotp(uint8 gtab_sel);
void  dwt_loadopsettabfromotp(uint8_t gtab_sel);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_configeventcounters()
@@ -1223,7 +1182,7 @@
 *
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
 */
uint32 dwt_otpwriteandverify(uint32 value, uint16 address);
uint32_t dwt_otpwriteandverify(uint32_t value, uint16_t address);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_setleds()
@@ -1240,7 +1199,7 @@
 *
 * no return value
 */
void dwt_setleds(uint8 test);
void dwt_setleds(uint8_t test);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_xtaltrim()
@@ -1254,7 +1213,7 @@
 *
 * no return value
 */
void dwt_xtaltrim(uint8 value);
void dwt_xtaltrim(uint8_t value);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_configcwmode()
@@ -1268,7 +1227,7 @@
 *
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
 */
int dwt_configcwmode(uint8 chan);
int dwt_configcwmode(uint8_t chan);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_configcontinuousframemode()
@@ -1283,7 +1242,7 @@
 *
 * no return value
 */
void dwt_configcontinuousframemode(uint32 framerepetitionrate);
void dwt_configcontinuousframemode(uint32_t framerepetitionrate);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readtempvbat()
@@ -1306,7 +1265,7 @@
 *
 * returns  (temp_raw<<8)|(vbat_raw)
 */
uint16 dwt_readtempvbat(uint8 fastSPI);
uint16_t dwt_readtempvbat(uint8_t fastSPI);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readwakeuptemp()
@@ -1321,7 +1280,7 @@
 *
 * returns: 8-bit raw temperature sensor value
 */
uint8 dwt_readwakeuptemp(void) ;
uint8_t dwt_readwakeuptemp(void) ;

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_readwakeupvbat()
@@ -1336,7 +1295,7 @@
 *
 * returns: 8-bit raw battery voltage sensor value
 */
uint8 dwt_readwakeupvbat(void) ;
uint8_t dwt_readwakeupvbat(void) ;

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_writetodevice()
@@ -1363,10 +1322,10 @@
 */
int dwt_writetodevice             // returns 0 for success, or, -1 for error.
(
    uint16      recordNumber,   // input parameter - ID of register file or buffer being accessed
    uint16      index,          // input parameter - byte index into register file or buffer being accessed
    uint32      length,         // input parameter - number of bytes being written
    const uint8 *buffer         // input parameter - pointer to buffer containing the 'length' bytes to be written
    uint16_t      recordNumber,   // input parameter - ID of register file or buffer being accessed
    uint16_t      index,          // input parameter - byte index into register file or buffer being accessed
    uint32_t      length,         // input parameter - number of bytes being written
    const uint8_t *buffer         // input parameter - pointer to buffer containing the 'length' bytes to be written
) ;

/*! ------------------------------------------------------------------------------------------------------------------
@@ -1394,10 +1353,10 @@
 */
int dwt_readfromdevice            // returns offset where requested data begins in supplied buffer, or, -1 for error.
(
    uint16  recordNumber,       // input parameter - ID of register file or buffer being accessed
    uint16  index,              // input parameter - byte index into register file or buffer being accessed
    uint32  length,             // input parameter - number of bytes being read
    uint8   *buffer             // input parameter - pointer to buffer in which to return the read data.
    uint16_t  recordNumber,       // input parameter - ID of register file or buffer being accessed
    uint16_t  index,              // input parameter - byte index into register file or buffer being accessed
    uint32_t  length,             // input parameter - number of bytes being read
    uint8_t   *buffer             // input parameter - pointer to buffer in which to return the read data.
) ;

/*! ------------------------------------------------------------------------------------------------------------------
@@ -1413,7 +1372,7 @@
 *
 * returns 32 bit register value (success), or DWT_ERROR for error
 */
uint32 dwt_read32bitoffsetreg(int regFileID, int regOffset) ;
uint32_t dwt_read32bitoffsetreg(int regFileID, int regOffset) ;

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_write32bitoffsetreg()
@@ -1429,7 +1388,7 @@
 *
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
 */
int dwt_write32bitoffsetreg(int regFileID, int regOffset, uint32 regval);
int dwt_write32bitoffsetreg(int regFileID, int regOffset, uint32_t regval);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_read16bitoffsetreg()
@@ -1444,7 +1403,7 @@
 *
 * returns 16 bit register value (success), or DWT_ERROR for error
 */
uint16 dwt_read16bitoffsetreg(int regFileID, int regOffset);
uint16_t dwt_read16bitoffsetreg(int regFileID, int regOffset);

/*! ------------------------------------------------------------------------------------------------------------------
 * @fn dwt_write16bitoffsetreg()
@@ -1460,7 +1419,7 @@
 *
 * returns DWT_SUCCESS for success, or DWT_ERROR for error
 */
int dwt_write16bitoffsetreg(int regFileID, int regOffset, uint16 regval) ;
int dwt_write16bitoffsetreg(int regFileID, int regOffset, uint16_t regval) ;

#define dwt_write32bitreg(x,y)   dwt_write32bitoffsetreg(x,0,y)
#define dwt_read32bitreg(x)      dwt_read32bitoffsetreg(x,0)
@@ -1489,10 +1448,10 @@
 */
extern int writetospi                          // returns 0 for success, or, -1 for error.
(
    uint16       headerLength,          // input parameter - number of bytes header being written
    const uint8 *headerBuffer,          // input parameter - pointer to buffer containing the 'headerLength' bytes of header to be written
    uint32       bodylength,            // input parameter - number of bytes data being written
    const uint8 *bodyBuffer             // input parameter - pointer to buffer containing the 'bodylength' bytes od data to be written
    uint16_t       headerLength,          // input parameter - number of bytes header being written
    const uint8_t *headerBuffer,          // input parameter - pointer to buffer containing the 'headerLength' bytes of header to be written
    uint32_t       bodylength,            // input parameter - number of bytes data being written
    const uint8_t *bodyBuffer             // input parameter - pointer to buffer containing the 'bodylength' bytes od data to be written
) ;

/*! ------------------------------------------------------------------------------------------------------------------
@@ -1519,10 +1478,10 @@
 */
extern int readfromspi                         // returns offset where requested data begins in supplied buffer, or, -1 for error.
(
    uint16       headerLength,          // input parameter - number of bytes header to write
    const uint8 *headerBuffer,          // input parameter - pointer to buffer containing the 'headerLength' bytes of header to write
    uint32       readlength,            // input parameter - number of bytes data being read
    uint8       *readBuffer             // input parameter - pointer to buffer containing to return the data (NB: size required = headerLength + readlength)
    uint16_t       headerLength,          // input parameter - number of bytes header to write
    const uint8_t *headerBuffer,          // input parameter - pointer to buffer containing the 'headerLength' bytes of header to write
    uint32_t       readlength,            // input parameter - number of bytes data being read
    uint8_t       *readBuffer             // input parameter - pointer to buffer containing to return the data (NB: size required = headerLength + readlength)
) ;

/*! ------------------------------------------------------------------------------------------------------------------
@@ -1539,7 +1498,7 @@
 *
 * returns correction needed in meters
 */
double dwt_getrangebias(uint8 chan, float range, uint8 prf);
double dwt_getrangebias(uint8_t chan, float range, uint8_t prf);


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