DW1000Utils.h

00001 #pragma once
00002 
00003 #include <mbed.h>
00004 #include "DW1000.h"
00005 
00006 class DW1000Utils
00007 {
00008 public:
00009     // Recommended settings:
00010     // Data rate 110 kbps - Preamble length 2048 or 4096.
00011     // Data rate 850 kbps - Preamble length 256, 512 or 1024.
00012     // Data rate 6.8 Mbps - Preamble length 64.
00013 
00014     const static uint32_t PREAMBLE_LENGTH_64 = (1 << 18);
00015     const static uint32_t PREAMBLE_LENGTH_128 = (1 << 18) | (1 << 20);
00016     const static uint32_t PREAMBLE_LENGTH_256 = (1 << 18) | (1 << 21);
00017     const static uint32_t PREAMBLE_LENGTH_512 = (1 << 18) | (1 << 20) | (1 << 21);
00018     const static uint32_t PREAMBLE_LENGTH_1024 = (1 << 19);
00019     const static uint32_t PREAMBLE_LENGTH_2048 = (1 << 19) | (1 << 21);
00020     const static uint32_t PREAMBLE_LENGTH_4096 = (1 << 18) | (1 << 19);
00021 
00022     enum PrfSetting
00023     {
00024         PRF_16_MHz = 1,
00025         PRF_64_MHz,
00026     };
00027 
00028     enum DataRateSetting
00029     {
00030         RATE_110_kbps = 1,
00031         RATE_850_kbps,
00032         RATE_6_8_Mbps,
00033     };
00034 
00035     // Set pulse repetition frequency
00036     static void setPulseRepetitionFrequency(DW1000* dw_ptr, PrfSetting prf_setting)
00037     {
00038         // Transmit PRF setting (see page 75 of user manual)
00039         uint32_t prf_value;
00040         if (prf_setting == PRF_16_MHz)
00041         {
00042             prf_value = (1 << 16);
00043         }
00044         else
00045         {
00046             prf_value = (1 << 17);
00047         }
00048         uint32_t prf_mask = (1 << 16) | (1 << 17);
00049         uint32_t tx_ctrl = dw_ptr->readRegister32(DW1000_TX_FCTRL, 0x00);
00050         tx_ctrl &= ~prf_mask;
00051         tx_ctrl |= (prf_value & prf_mask);
00052         dw_ptr->writeRegister32(DW1000_TX_FCTRL, 0x00, tx_ctrl);
00053 
00054         // Receive PRF setting (see page 109 and of user manual)
00055         if (prf_setting == PRF_16_MHz)
00056         {
00057             prf_value = (1 << 18);
00058         }
00059         else
00060         {
00061             prf_value = (1 << 19);
00062         }
00063         prf_mask = (1 << 18) | (1 << 19);
00064         uint32_t chan_ctrl = dw_ptr->readRegister32(DW1000_CHAN_CTRL, 0x00);
00065         chan_ctrl &= ~prf_mask;
00066         chan_ctrl |= (prf_value & prf_mask);
00067         dw_ptr->writeRegister32(DW1000_CHAN_CTRL, 0x00, chan_ctrl);
00068     }
00069 
00070     // Set preamble length (see page 76 of user manual)
00071     static void setPreambleLength(DW1000* dw_ptr, uint32_t preamble_setting)
00072     {
00073         uint32_t preamble_mask = (1 << 18) | (1 << 19) | (1 << 20) | (1 << 21);
00074         uint32_t tx_ctrl = dw_ptr->readRegister32(DW1000_TX_FCTRL, 0x00);
00075         tx_ctrl &= ~preamble_mask;
00076         tx_ctrl |= (preamble_setting & preamble_mask);
00077         dw_ptr->writeRegister32(DW1000_TX_FCTRL, 0x00, tx_ctrl);
00078     }
00079 
00080     // Set data rate
00081     static void setDataRate(DW1000* dw_ptr, DataRateSetting rate_setting)
00082     {
00083         // Transmit data rate (see page 73 of user manual)
00084         uint32_t rate_value;
00085         if (rate_setting == RATE_110_kbps)
00086         {
00087             rate_value = 0;
00088         }
00089         else if (rate_setting == RATE_850_kbps)
00090         {
00091             rate_value = (1 << 13);
00092         }
00093         else
00094         {
00095             rate_value = (1 << 14);
00096         }
00097         uint32_t rate_mask = (1 << 13) | (1 << 14);
00098         uint32_t tx_ctrl = dw_ptr->readRegister32(DW1000_TX_FCTRL, 0x00);
00099         tx_ctrl &= ~rate_mask;
00100         tx_ctrl |= (rate_value & rate_mask);
00101         dw_ptr->writeRegister32(DW1000_TX_FCTRL, 0x00, tx_ctrl);
00102 
00103         // Receive data rate (see page 72 of user manual)
00104         if (rate_setting == RATE_110_kbps)
00105         {
00106             rate_value = (1 << 18);
00107             rate_value = (1 << 22);
00108         }
00109         else if (rate_setting == RATE_850_kbps)
00110         {
00111             rate_value = (1 << 18);
00112         }
00113         else
00114         {
00115             rate_value = 0;
00116         }
00117         rate_mask = (1 << 18) | (1 << 22);
00118         uint32_t sys_cfg = dw_ptr->readRegister32(DW1000_SYS_CFG, 0x00);
00119         sys_cfg &= ~rate_mask;
00120         sys_cfg |= (rate_value & rate_mask);
00121         dw_ptr->writeRegister32(DW1000_SYS_CFG, 0x00, sys_cfg);
00122 
00123         if (rate_setting == RATE_110_kbps)
00124         {
00125             dw_ptr->writeRegister16(DW1000_DRX_CONF, 0x02, 0x000A);     // DRX_TUNE0b for 110 kbps
00126             dw_ptr->writeRegister16(DW1000_DRX_CONF, 0x06, 0x0064);     // DRX_TUNE1b for 110 kbps & > 1024 symbols
00127         }
00128         else if (rate_setting == RATE_850_kbps)
00129         {
00130             dw_ptr->writeRegister16(DW1000_DRX_CONF, 0x02, 0x0001);     // DRX_TUNE0b for 850 kbps
00131             dw_ptr->writeRegister16(DW1000_DRX_CONF, 0x06, 0x0020);     // DRX_TUNE1b for 850 kbps & 128 - 1024 symbols
00132         }
00133         else
00134         {
00135             dw_ptr->writeRegister16(DW1000_DRX_CONF, 0x02, 0x0001);     // DRX_TUNE0b for 6.8 Mbps
00136             dw_ptr->writeRegister16(DW1000_DRX_CONF, 0x06, 0x0010);     // DRX_TUNE1b for 6.8 Mbps & 64 symbols
00137         }
00138     }
00139 
00140     // Improved settings for direct path detection in non-line-of-sight environments.
00141     // See DecaWave Application Note APS006.
00142     static void setNLOSSettings(DW1000* dw_ptr, DataRateSetting rate_setting = RATE_850_kbps, PrfSetting prf_setting = PRF_16_MHz, uint32_t preamble_setting = PREAMBLE_LENGTH_1024)
00143     {
00144         setDataRate(dw_ptr, rate_setting);
00145         setPulseRepetitionFrequency(dw_ptr, prf_setting);
00146         setPreambleLength(dw_ptr, preamble_setting);
00147 
00148         // Setting for Noise Threshold Multiplier 1
00149         dw_ptr->writeRegister8(DW1000_LDE_CTRL, 0x0806, 0x07);                  // LDE_CFG1
00150         // Setting for Noise Threshold Multiplier 2
00151         if (prf_setting == PRF_16_MHz)
00152         {
00153             dw_ptr->writeRegister16(DW1000_LDE_CTRL, 0x1806, 0x0003);           // LDE_CFG2 for 16 MHz PRF
00154         }
00155         else
00156         {
00157             dw_ptr->writeRegister16(DW1000_LDE_CTRL, 0x1806, 0x1603);           // LDE_CFG2 for 64 MHz PRF
00158         }
00159     }
00160 
00161     // Default settings for line-of-sight environments
00162     static void setLOSSettings(DW1000* dw_ptr, DataRateSetting rate_setting = RATE_850_kbps, PrfSetting prf_setting = PRF_16_MHz, uint32_t preamble_setting = PREAMBLE_LENGTH_1024)
00163     {
00164         setDataRate(dw_ptr, rate_setting);
00165         setPulseRepetitionFrequency(dw_ptr, prf_setting);
00166         setPreambleLength(dw_ptr, preamble_setting);
00167 
00168         // Setting for Noise Threshold Multiplier 1
00169             dw_ptr->writeRegister8(DW1000_LDE_CTRL, 0x0806, 0x0c);              // LDE_CFG1
00170 //        dw_ptr->writeRegister8(DW1000_LDE_CTRL, 0x0806, 0x0d);                // LDE_CFG1
00171         // Setting for Noise Threshold Multiplier 2
00172         if (prf_setting == PRF_16_MHz)
00173         {
00174             dw_ptr->writeRegister16(DW1000_LDE_CTRL, 0x1806, 0x1607);           // LDE_CFG2 for 16 MHz PRF
00175         }
00176         else
00177         {
00178             dw_ptr->writeRegister16(DW1000_LDE_CTRL, 0x1806, 0x0607);           // LDE_CFG2 for 64 MHz PRF
00179         }
00180     }
00181 };