void Adafruit_TFTLCD::fillScreen(uint16_t color) {
if(driver == ID_932X) {
// For the 932X, a full-screen address window is already the default
// state, just need to set the address pointer to the top-left corner.
// Although we could fill in any direction, the code uses the current
// screen rotation because some users find it disconcerting when a
// fill does not occur top-to-bottom.
uint16_t x, y;
switch(rotation) {
default: x = 0 ; y = 0 ; break;
case 1 : x = TFTWIDTH - 1; y = 0 ; break;
case 2 : x = TFTWIDTH - 1; y = TFTHEIGHT - 1; break;
case 3 : x = 0 ; y = TFTHEIGHT - 1; break;
}
CS_ACTIVE;
writeRegister16(0x0020, x);
writeRegister16(0x0021, y);
} else if (driver == ID_9341) {
setAddrWindow(0, 0, _width - 1, _height - 1);
} else if(driver == ID_7575) {
// For the 7575, there is no settable address pointer, instead the
// address window must be set for each drawing operation. However,
// this display takes rotation into account for the parameters, no
// need to do extra rotation math here.
setAddrWindow(0, 0, _width - 1, _height - 1);
}
flood(color, (long)TFTWIDTH * (long)TFTHEIGHT);
}
void Adafruit_TFTLCD::drawPixel(int16_t x, int16_t y, uint16_t color) {
// Clip
if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return;
CS_ACTIVE;
if(driver == ID_932X) {
int16_t t;
switch(rotation) {
case 1:
t = x;
x = TFTWIDTH - 1 - y;
y = t;
break;
case 2:
x = TFTWIDTH - 1 - x;
y = TFTHEIGHT - 1 - y;
break;
case 3:
t = x;
x = y;
y = TFTHEIGHT - 1 - t;
break;
}
writeRegister16(0x0020, x);
writeRegister16(0x0021, y);
writeRegister16(0x0022, color);
} else if(driver == ID_7575) {
uint8_t hi, lo;
switch(rotation) {
default:
lo = 0 ;
break;
case 1 :
lo = 0x60;
break;
case 2 :
lo = 0xc0;
break;
case 3 :
lo = 0xa0;
break;
}
writeRegister8( HX8347G_MEMACCESS , lo);
// Only upper-left is set -- bottom-right is full screen default
writeRegisterPair(HX8347G_COLADDRSTART_HI, HX8347G_COLADDRSTART_LO, x);
writeRegisterPair(HX8347G_ROWADDRSTART_HI, HX8347G_ROWADDRSTART_LO, y);
hi = color >> 8;
lo = color;
CD_COMMAND;
write8(0x22);
CD_DATA;
write8(hi);
write8(lo);
}
// Deprecated function -- here for compat w/old code
void Adafruit_TFTLCD::goTo(int x, int y) {
if (driver == 0x9325 || driver == 0x9328) {
writeRegister16(0x0020, x); // GRAM Address Set (Horizontal Address) (R20h)
writeRegister16(0x0021, y); // GRAM Address Set (Vertical Address) (R21h)
writeCommand(0x0022); // Write Data to GRAM (R22h)
}
if (driver == 0x7575) {
writeRegister8(HX8347G_COLADDRSTART2, x>>8);
writeRegister8(HX8347G_COLADDRSTART1, x);
writeRegister8(HX8347G_ROWADDRSTART2, y>>8);
writeRegister8(HX8347G_ROWADDRSTART1, y);
writeRegister8(HX8347G_COLADDREND2, 0);
writeRegister8(HX8347G_COLADDREND1, TFTWIDTH-1);
writeRegister8(HX8347G_ROWADDREND2, (TFTHEIGHT-1)>>8);
writeRegister8(HX8347G_ROWADDREND1, (TFTHEIGHT-1)&0xFF);
writeCommand(0x0022); // Write Data to GRAM (R22h)
}
DW1000::DW1000()
{
spi = mraa_spi_init(5);
mraa_spi_frequency(spi, DW1000_SPI_CLOCK_SPEED);
cs = mraa_gpio_init(DW_CS);
mraa_gpio_dir(cs, MRAA_GPIO_OUT);
mraa_gpio_write(cs, 0x1);
resetAll(); // we do a soft reset of the DW1000 everytime the driver starts
//Those values are for the 110kbps mode (5, 16MHz, 1024 Symbols) and are quite complete
writeRegister16(DW1000_AGC_CTRL, 0x04, 0x8870); //AGC_TUNE1 for 16MHz PRF
writeRegister32(DW1000_AGC_CTRL, 0x0C, 0x2502A907); //AGC_TUNE2 (Universal)
writeRegister16(DW1000_AGC_CTRL, 0x12, 0x0055); //AGC_TUNE3 (Universal)
writeRegister16(DW1000_DRX_CONF, 0x02, 0x000A); //DRX_TUNE0b for 110kbps
writeRegister16(DW1000_DRX_CONF, 0x04, 0x0087); //DRX_TUNE1a for 16MHz PRF
writeRegister16(DW1000_DRX_CONF, 0x06, 0x0064); //DRX_TUNE1b for 110kbps & > 1024 symbols
writeRegister32(DW1000_DRX_CONF, 0x08, 0x351A009A); //PAC size for 1024 symbols preamble & 16MHz PRF
//writeRegister32(DW1000_DRX_CONF, 0x08, 0x371A011D); //PAC size for 2048 symbols preamble
writeRegister8 (DW1000_LDE_CTRL, 0x0806, 0xD); //LDE_CFG1
writeRegister16(DW1000_LDE_CTRL, 0x1806, 0x1607); //LDE_CFG2 for 16MHz PRF
writeRegister32(DW1000_TX_POWER, 0, 0x28282828); //Power for channel 5
writeRegister8(DW1000_RF_CONF, 0x0B, 0xD8); //RF_RXCTRLH for channel 5
writeRegister32(DW1000_RF_CONF, 0x0C, 0x001E3FE0); //RF_TXCTRL for channel 5
writeRegister8 (DW1000_TX_CAL, 0x0B, 0xC0); //TC_PGDELAY for channel 5
writeRegister32 (DW1000_FS_CTRL, 0x07, 0x0800041D); //FS_PLLCFG for channel 5
writeRegister8 (DW1000_FS_CTRL, 0x0B, 0xA6); //FS_PLLTUNE for channel 5
loadLDE(); // important everytime DW1000 initialises/awakes otherwise the LDE algorithm must be turned off or there's receiving malfunction see User Manual LDELOAD on p22 & p158
// 110kbps CAUTION: a lot of other registers have to be set for an optimized operation on 110kbps
writeRegister16(DW1000_TX_FCTRL, 1, 0x0800 | 0x0100 | 0x0080); // use 1024 symbols preamble (0x0800) (previously 2048 - 0x2800), 16MHz pulse repetition frequency (0x0100), 110kbps bit rate (0x0080) see p.69 of DW1000 User Manual
writeRegister8(DW1000_SYS_CFG, 2, 0x44); // enable special receiving option for 110kbps (disable smartTxPower)!! (0x44) see p.64 of DW1000 User Manual [DO NOT enable 1024 byte frames (0x03) becuase it generates disturbance of ranging don't know why...]
writeRegister16(DW1000_TX_ANTD, 0, 16384); // set TX and RX Antenna delay to neutral because we calibrate afterwards
writeRegister16(DW1000_LDE_CTRL, 0x1804, 16384); // = 2^14 a quarter of the range of the 16-Bit register which corresponds to zero calibration in a round trip (TX1+RX2+TX2+RX1)
writeRegister8(DW1000_SYS_CFG, 3, 0x20); // enable auto reenabling receiver after error
}
void DW1000::sendFrame(uint8_t* message, uint16_t length) {
if (length >= 125) length = 125; // check for maximim length a frame can have with 127 Byte frames
writeRegister(DW1000_TX_BUFFER, 0, message, length); // fill buffer
uint8_t backup = readRegister8(DW1000_TX_FCTRL, 1); // put length of frame
length += 2; // including 2 CRC Bytes
length = ((backup & 0xFC) << 8) | (length & 0x03FF);
writeRegister16(DW1000_TX_FCTRL, 0, length);
stopTRX(); // stop receiving
writeRegister8(DW1000_SYS_CTRL, 0, 0x02); // trigger sending process by setting the TXSTRT bit
startRX(); // enable receiver again
}
void DW1000::sendDelayedFrame(uint8_t* message, uint16_t length, uint64_t TxTimestamp) {
if (length >= 125) length = 125; // check for maximim length a frame can have with 127 Byte frames
writeRegister(DW1000_TX_BUFFER, 0, message, length); // fill buffer
uint8_t backup = readRegister8(DW1000_TX_FCTRL, 1); // put length of frame
length += 2; // including 2 CRC Bytes
length = ((backup & 0xFC) << 8) | (length & 0x03FF);
writeRegister16(DW1000_TX_FCTRL, 0, length);
writeRegister40(DW1000_DX_TIME, 0, TxTimestamp); //write the timestamp on which to send the message
stopTRX(); // stop receiving
writeRegister8(DW1000_SYS_CTRL, 0, 0x02 | 0x04); // trigger sending process by setting the TXSTRT and TXDLYS bit
startRX(); // enable receiver again
}
void Adafruit_TFTLCD::begin(uint16_t id) {
uint8_t i = 0;
reset();
if((id == 0x9325) || (id == 0x9328)) {
uint16_t a, d;
driver = ID_932X;
CS_ACTIVE;
while(i < sizeof(ILI932x_regValues) / sizeof(uint16_t)) {
a = pgm_read_word(&ILI932x_regValues[i++]);
d = pgm_read_word(&ILI932x_regValues[i++]);
if(a == TFTLCD_DELAY) delay(d);
else writeRegister16(a, d);
}
setRotation(rotation);
setAddrWindow(0, 0, TFTWIDTH-1, TFTHEIGHT-1);
} else if(id == 0x7575) {
uint8_t a, d;
driver = ID_7575;
CS_ACTIVE;
while(i < sizeof(HX8347G_regValues)) {
a = pgm_read_byte(&HX8347G_regValues[i++]);
d = pgm_read_byte(&HX8347G_regValues[i++]);
if(a == TFTLCD_DELAY) delay(d);
else writeRegister8(a, d);
}
setRotation(rotation);
setLR(); // Lower-right corner of address window
} else {
driver = ID_UNKNOWN;
return;
}
}
// Sets the LCD address window (and address counter, on 932X).
// Relevant to rect/screen fills and H/V lines. Input coordinates are
// assumed pre-sorted (e.g. x2 >= x1).
void Adafruit_TFTLCD::setAddrWindow(int x1, int y1, int x2, int y2) {
CS_ACTIVE;
if(driver == ID_932X) {
// Values passed are in current (possibly rotated) coordinate
// system. 932X requires hardware-native coords regardless of
// MADCTL, so rotate inputs as needed. The address counter is
// set to the top-left corner -- although fill operations can be
// done in any direction, the current screen rotation is applied
// because some users find it disconcerting when a fill does not
// occur top-to-bottom.
int x, y, t;
switch(rotation) {
default:
x = x1;
y = y1;
break;
case 1:
t = y1;
y1 = x1;
x1 = TFTWIDTH - 1 - y2;
y2 = x2;
x2 = TFTWIDTH - 1 - t;
x = x2;
y = y1;
break;
case 2:
t = x1;
x1 = TFTWIDTH - 1 - x2;
x2 = TFTWIDTH - 1 - t;
t = y1;
y1 = TFTHEIGHT - 1 - y2;
y2 = TFTHEIGHT - 1 - t;
x = x2;
y = y2;
break;
case 3:
t = x1;
x1 = y1;
y1 = TFTHEIGHT - 1 - x2;
x2 = y2;
y2 = TFTHEIGHT - 1 - t;
x = x1;
y = y2;
break;
}
writeRegister16(0x0050, x1); // Set address window
writeRegister16(0x0051, x2);
writeRegister16(0x0052, y1);
writeRegister16(0x0053, y2);
writeRegister16(0x0020, x ); // Set address counter to top left
writeRegister16(0x0021, y );
} else if(driver == ID_7575) {
writeRegisterPair(HX8347G_COLADDRSTART_HI, HX8347G_COLADDRSTART_LO, x1);
writeRegisterPair(HX8347G_ROWADDRSTART_HI, HX8347G_ROWADDRSTART_LO, y1);
writeRegisterPair(HX8347G_COLADDREND_HI , HX8347G_COLADDREND_LO , x2);
writeRegisterPair(HX8347G_ROWADDREND_HI , HX8347G_ROWADDREND_LO , y2);
} else if (driver == ID_9341) {
uint32_t t;
t = x1;
t <<= 16;
t |= x2;
writeRegister32(ILI9341_COLADDRSET, t);
t = y1;
t <<= 16;
t |= y2;
writeRegister32(ILI9341_PAGEADDRSET, t);
}
CS_IDLE;
}
void Adafruit_TFTLCD::begin(uint16_t id) {
uint8_t i = 0;
reset();
if((id == 0x9325) || (id == 0x9328)) {
uint16_t a, d;
driver = ID_932X;
CS_ACTIVE;
while(i < sizeof(ILI932x_regValues) / sizeof(uint16_t)) {
a = pgm_read_word(&ILI932x_regValues[i++]);
d = pgm_read_word(&ILI932x_regValues[i++]);
if(a == TFTLCD_DELAY) delay(d);
else writeRegister16(a, d);
}
setRotation(rotation);
setAddrWindow(0, 0, TFTWIDTH-1, TFTHEIGHT-1);
} else if (id == 0x9341) {
uint16_t a, d;
driver = ID_9341;
CS_ACTIVE;
writeRegister8(ILI9341_SOFTRESET, 0);
delay(50);
writeRegister8(ILI9341_DISPLAYOFF, 0);
writeRegister8(ILI9341_POWERCONTROL1, 0x23);
writeRegister8(ILI9341_POWERCONTROL2, 0x10);
writeRegister16(ILI9341_VCOMCONTROL1, 0x2B2B);
writeRegister8(ILI9341_VCOMCONTROL2, 0xC0);
writeRegister8(ILI9341_MEMCONTROL, ILI9341_MADCTL_MY | ILI9341_MADCTL_BGR);
writeRegister8(ILI9341_PIXELFORMAT, 0x55);
writeRegister16(ILI9341_FRAMECONTROL, 0x001B);
writeRegister8(ILI9341_ENTRYMODE, 0x07);
/* writeRegister32(ILI9341_DISPLAYFUNC, 0x0A822700);*/
writeRegister8(ILI9341_SLEEPOUT, 0);
delay(150);
writeRegister8(ILI9341_DISPLAYON, 0);
delay(500);
setAddrWindow(0, 0, TFTWIDTH-1, TFTHEIGHT-1);
} else if(id == 0x7575) {
uint8_t a, d;
driver = ID_7575;
CS_ACTIVE;
while(i < sizeof(HX8347G_regValues)) {
a = pgm_read_byte(&HX8347G_regValues[i++]);
d = pgm_read_byte(&HX8347G_regValues[i++]);
if(a == TFTLCD_DELAY) delay(d);
else writeRegister8(a, d);
}
setRotation(rotation);
setLR(); // Lower-right corner of address window
} else {
driver = ID_UNKNOWN;
return;
}
}
void Adafruit_TFTLCD::begin(uint16_t id) {
uint8_t i = 0;
reset();
delay(200);
if((id == 0x9325) || (id == 0x9328)) {
uint16_t a, d;
driver = ID_932X;
CS_ACTIVE;
while(i < sizeof(ILI932x_regValues) / sizeof(uint16_t)) {
a = pgm_read_word(&ILI932x_regValues[i++]);
d = pgm_read_word(&ILI932x_regValues[i++]);
if(a == TFTLCD_DELAY) delay(d);
else writeRegister16(a, d);
}
setRotation(rotation);
setAddrWindow(0, 0, TFTWIDTH-1, TFTHEIGHT-1);
} else if (id == 0x9341) {
// ILI9341 mcufriend
driver = ID_9341;
CS_ACTIVE;
while(i < sizeof(ILI9341_regValues)) {
uint8_t r = pgm_read_byte(&ILI9341_regValues[i++]);
uint8_t len = pgm_read_byte(&ILI9341_regValues[i++]);
if(r == TFTLCD_DELAY) {
delay(len);
} else {
//Serial.print("Register $"); Serial.print(r, HEX);
//Serial.print(" datalen "); Serial.println(len);
CS_ACTIVE;
CD_COMMAND;
write8(r);
CD_DATA;
for (uint8_t d=0; d<len; d++) {
uint8_t x = pgm_read_byte(&ILI9341_regValues[i++]);
write8(x);
}
CS_IDLE;
}
}
return;
} else if (id == 0x8357) {
// HX8357D
driver = ID_HX8357D;
CS_ACTIVE;
while(i < sizeof(HX8357D_regValues)) {
uint8_t r = pgm_read_byte(&HX8357D_regValues[i++]);
uint8_t len = pgm_read_byte(&HX8357D_regValues[i++]);
if(r == TFTLCD_DELAY) {
delay(len);
} else {
//Serial.print("Register $"); Serial.print(r, HEX);
//Serial.print(" datalen "); Serial.println(len);
CS_ACTIVE;
CD_COMMAND;
write8(r);
CD_DATA;
for (uint8_t d=0; d<len; d++) {
uint8_t x = pgm_read_byte(&HX8357D_regValues[i++]);
write8(x);
}
CS_IDLE;
}
}
return;
} else if(id == 0x7575) {
uint8_t a, d;
driver = ID_7575;
CS_ACTIVE;
while(i < sizeof(HX8347G_regValues)) {
a = pgm_read_byte(&HX8347G_regValues[i++]);
d = pgm_read_byte(&HX8347G_regValues[i++]);
if(a == TFTLCD_DELAY) delay(d);
else writeRegister8(a, d);
}
setRotation(rotation);
setLR(); // Lower-right corner of address window
} else if(id == 0x0154){
//S6D0154
uint16_t a, d;
driver = ID_S6D0154;
CS_ACTIVE;
//writeRegister16(0x80,0x008D); //Testkey
//writeRegister16(0x92,0x0010);
writeRegister16(0x11,0x001A);
writeRegister16(0x12,0x3121);
writeRegister16(0x13,0x006C);
writeRegister16(0x14,0x4249);
writeRegister16(0x10,0x0800);
delay(10);
writeRegister16(0x11,0x011A);
delay(10);
writeRegister16(0x11,0x031A);
delay(10);
writeRegister16(0x11,0x071A);
delay(10);
writeRegister16(0x11,0x0F1A);
delay(20);
writeRegister16(0x11,0x0F3A);
delay(30);
writeRegister16(0x01,0x0128);
writeRegister16(0x02,0x0100);
writeRegister16(0x03,0x1030);
writeRegister16(0x07,0x1012);
writeRegister16(0x08,0x0303);
writeRegister16(0x0B,0x1100);
writeRegister16(0x0C,0x0000);
writeRegister16(0x0F,0x1801);
writeRegister16(0x15,0x0020);
/*
writeRegister16(0x50,0x0101);
writeRegister16(0x51,0x0603);
writeRegister16(0x52,0x0408);
writeRegister16(0x53,0x0000);
writeRegister16(0x54,0x0605);
writeRegister16(0x55,0x0406);
writeRegister16(0x56,0x0303);
writeRegister16(0x57,0x0303);
writeRegister16(0x58,0x0010);
writeRegister16(0x59,0x1000);
*/
writeRegister16(0x07,0x0012);
delay(40);
writeRegister16(0x07,0x0013);/* GRAM Address Set */
writeRegister16(0x07,0x0017);/* Display Control DISPLAY ON */
setAddrWindow(0, 0, TFTWIDTH-1, TFTHEIGHT-1);
} else if (id == 0x9327){
// ILI9327 8 bit parallel interface
driver = ID_ILI9327;
CS_ACTIVE;
while(i < sizeof(ILI9327_regValues)) {
uint8_t r = pgm_read_byte(&ILI9327_regValues[i++]);
uint8_t len = pgm_read_byte(&ILI9327_regValues[i++]);
if(r == TFTLCD_DELAY) {
delay(len);
} else {
//Serial.print("Register $"); Serial.print(r, HEX);
//Serial.print(" datalen "); Serial.println(len);
CS_ACTIVE;
CD_COMMAND;
write8(r);
CD_DATA;
for (uint8_t d=0; d<len; d++) {
uint8_t x = pgm_read_byte(&ILI9327_regValues[i++]);
write8(x);
}
CS_IDLE;
}
}
return;
} else if (id == 0x9488){
// ILI9488 8 bit parallel interface
driver = ID_ILI9488;
CS_ACTIVE;
while(i < sizeof(ILI9488_regValues)) {
uint8_t r = pgm_read_byte(&ILI9488_regValues[i++]);
uint8_t len = pgm_read_byte(&ILI9488_regValues[i++]);
if(r == TFTLCD_DELAY) {
delay(len);
} else {
//Serial.print("Register $"); Serial.print(r, HEX);
//Serial.print(" datalen "); Serial.println(len);
CS_ACTIVE;
CD_COMMAND;
write8(r);
CD_DATA;
for (uint8_t d=0; d<len; d++) {
uint8_t x = pgm_read_byte(&ILI9488_regValues[i++]);
write8(x);
}
CS_IDLE;
}
}
return;
} else {
driver = ID_UNKNOWN;
return;
}
}
void Adafruit_TFTLCD::begin(uint16_t id) {
uint8_t i = 0;
reset();
delay(200);
if((id == 0x9325) || (id == 0x9328)) {
uint16_t a, d;
driver = ID_932X;
CS_ACTIVE;
while(i < sizeof(ILI932x_regValues) / sizeof(uint16_t)) {
a = pgm_read_word(&ILI932x_regValues[i++]);
d = pgm_read_word(&ILI932x_regValues[i++]);
if(a == TFTLCD_DELAY) delay(d);
else writeRegister16(a, d);
}
setRotation(rotation);
setAddrWindow(0, 0, TFTWIDTH-1, TFTHEIGHT-1);
} else if (id == 0x9341) {
uint16_t a, d;
driver = ID_9341;
CS_ACTIVE;
writeRegister8(ILI9341_SOFTRESET, 0);
delay(50);
writeRegister8(ILI9341_DISPLAYOFF, 0);
writeRegister8(ILI9341_POWERCONTROL1, 0x23);
writeRegister8(ILI9341_POWERCONTROL2, 0x10);
writeRegister16(ILI9341_VCOMCONTROL1, 0x2B2B);
writeRegister8(ILI9341_VCOMCONTROL2, 0xC0);
writeRegister8(ILI9341_MEMCONTROL, ILI9341_MADCTL_MY | ILI9341_MADCTL_BGR);
writeRegister8(ILI9341_PIXELFORMAT, 0x55);
writeRegister16(ILI9341_FRAMECONTROL, 0x001B);
writeRegister8(ILI9341_ENTRYMODE, 0x07);
/* writeRegister32(ILI9341_DISPLAYFUNC, 0x0A822700);*/
writeRegister8(ILI9341_SLEEPOUT, 0);
delay(150);
writeRegister8(ILI9341_DISPLAYON, 0);
delay(500);
setAddrWindow(0, 0, TFTWIDTH-1, TFTHEIGHT-1);
return;
} else if (id == 0x8357) {
// HX8357D
driver = ID_HX8357D;
CS_ACTIVE;
while(i < sizeof(HX8357D_regValues)) {
uint8_t r = pgm_read_byte(&HX8357D_regValues[i++]);
uint8_t len = pgm_read_byte(&HX8357D_regValues[i++]);
if(r == TFTLCD_DELAY) {
delay(len);
} else {
//Serial.print("Register $"); Serial.print(r, HEX);
//Serial.print(" datalen "); Serial.println(len);
CS_ACTIVE;
CD_COMMAND;
write8(r);
CD_DATA;
for (uint8_t d=0; d<len; d++) {
uint8_t x = pgm_read_byte(&HX8357D_regValues[i++]);
write8(x);
}
CS_IDLE;
}
}
return;
} else if(id == 0x7575) {
uint8_t a, d;
driver = ID_7575;
CS_ACTIVE;
while(i < sizeof(HX8347G_regValues)) {
a = pgm_read_byte(&HX8347G_regValues[i++]);
d = pgm_read_byte(&HX8347G_regValues[i++]);
if(a == TFTLCD_DELAY) delay(d);
else writeRegister8(a, d);
}
setRotation(rotation);
setLR(); // Lower-right corner of address window
} else {
driver = ID_UNKNOWN;
return;
}
}
void DW1000::setInterrupt(bool RX, bool TX)
{
writeRegister16(DW1000_SYS_MASK, 0, RX*0x4000 | TX*0x0080); // RX good frame 0x4000, TX done 0x0080
}
void DW1000::loadLDE() { // initialise LDE algorithm LDELOAD User Manual p22
writeRegister16(DW1000_PMSC, 0, 0x0301); // set clock to XTAL so OTP is reliable
writeRegister16(DW1000_OTP_IF, 0x06, 0x8000); // set LDELOAD bit in OTP
usleep(150);
writeRegister16(DW1000_PMSC, 0, 0x0200); // recover to PLL clock
}
