Revision 58:8d4a354816b1, committed 2020-02-17

Comitter:

pathfindr

Date:

Mon Feb 17 23:24:52 2020 +0000

Parent:

57:066dfbe8b4b9

Commit message:

usb

Changed in this revision

diff -r 066dfbe8b4b9 -r 8d4a354816b1 DW1000/DW1000.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DW1000/DW1000.cpp	Mon Feb 17 23:24:52 2020 +0000
@@ -0,0 +1,446 @@
+// Adapted from Matthias Grob & Manuel Stalder - ETH Zürich - 2015
+#include "DW1000.h"
+#include "NRFuart.h"
+ 
+// Change this depending on whether damaged or heatlhy DWM1000 modules are used.
+const bool DWM1000_DAMAGED = false;
+//const bool DWM1000_DAMAGED = false;
+ 
+/*DW1000::DW1000(PinName MOSI, PinName MISO, PinName SCLK, PinName CS, PinName IRQ, PinName RESET) : irq(IRQ), spi(MOSI, MISO, SCLK), cs(CS), reset(RESET) {
+    irq.rise(this, &DW1000::ISR);
+    */
+    
+DW1000::DW1000(PinName MOSI, PinName MISO, PinName SCLK, PinName CS, PinName IRQ, PinName RESET) : irq(IRQ), spi(MOSI, MISO, SCLK), cs(CS), reset(RESET) {
+    //irq.rise(this, &DW1000::ISR);
+ 
+    //setCallbacks(NULL, NULL);
+ 
+    select();
+    deselect();                         // Chip must be deselected first
+    resetAll();                         // we do a soft reset of the DW1000 everytime the driver starts
+ 
+    // Configuration TODO: make method for that
+    // User Manual "2.5.5 Default Configurations that should be modified" p. 22
+    //Those values are for the standard mode (6.8Mbps, 5, 16Mhz, 32 Symbols) and are INCOMPLETE!
+//    writeRegister16(DW1000_AGC_CTRL, 0x04, 0x8870);
+//    writeRegister32(DW1000_AGC_CTRL, 0x0C, 0x2502A907);
+//    writeRegister32(DW1000_DRX_CONF, 0x08, 0x311A002D);
+//    writeRegister8 (DW1000_LDE_CTRL, 0x0806, 0xD);
+//    writeRegister16(DW1000_LDE_CTRL, 0x1806, 0x1607);
+//    writeRegister32(DW1000_TX_POWER, 0, 0x0E082848);
+//    writeRegister32(DW1000_RF_CONF, 0x0C, 0x001E3FE0);
+//    writeRegister8 (DW1000_TX_CAL, 0x0B, 0xC0);
+//    writeRegister8 (DW1000_FS_CTRL, 0x0B, 0xA6);
+ 
+ 
+    //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
+ 
+    //irq.enable_irq();
+}
+ 
+/*
+void DW1000::setCallbacks(void (*callbackRX)(void), void (*callbackTX)(void)) {
+    bool RX = false;
+    bool TX = false;
+    if (callbackRX) {
+        this->callbackRX.attach(callbackRX);
+        RX = true;
+    }
+    if (callbackTX) {
+        this->callbackTX.attach(callbackTX);
+        TX = true;
+    }
+    setInterrupt(RX, TX);
+}
+*/
+ 
+uint32_t DW1000::getDeviceID() {
+    uint32_t result;
+    readRegister(DW1000_DEV_ID, 0, (uint8_t*)&result, 4);
+    return result;
+}
+ 
+uint64_t DW1000::getEUI() {
+    uint64_t result;
+    readRegister(DW1000_EUI, 0, (uint8_t*)&result, 8);
+    return result;
+}
+ 
+void DW1000::setEUI(uint64_t EUI) {
+    writeRegister(DW1000_EUI, 0, (uint8_t*)&EUI, 8);
+}
+ 
+float DW1000::getVoltage() {
+    uint8_t buffer[7] = {0x80, 0x0A, 0x0F, 0x01, 0x00};             // algorithm form User Manual p57
+    writeRegister(DW1000_RF_CONF, 0x11, buffer, 2);
+    writeRegister(DW1000_RF_CONF, 0x12, &buffer[2], 1);
+    writeRegister(DW1000_TX_CAL, 0x00, &buffer[3], 1);
+    writeRegister(DW1000_TX_CAL, 0x00, &buffer[4], 1);
+    readRegister(DW1000_TX_CAL, 0x03, &buffer[5], 2);               // get the 8-Bit readings for Voltage and Temperature
+    float Voltage = buffer[5] * 0.0057 + 2.3;
+    //float Temperature = buffer[6] * 1.13 - 113.0;                 // TODO: getTemperature was always ~35 degree with better formula/calibration
+    return Voltage;
+}
+ 
+uint64_t DW1000::getStatus() {
+    return readRegister40(DW1000_SYS_STATUS, 0);
+}
+ 
+bool DW1000::hasReceivedFrame() {
+    uint64_t status = getStatus();
+    return status & 0x4000;
+}
+ 
+void DW1000::clearReceivedFlag() {
+    writeRegister16(DW1000_SYS_STATUS, 0, 0x6F00);              // clearing of receiving status bits
+}
+ 
+bool DW1000::hasTransmissionStarted() {
+    uint64_t status = getStatus();
+    return status & 0x10;
+}
+ 
+bool DW1000::hasSentPreamble() {
+    uint64_t status = getStatus();
+    return status & 0x20;
+}
+ 
+bool DW1000::hasSentPHYHeader() {
+    uint64_t status = getStatus();
+    return status & 0x40;
+}
+ 
+bool DW1000::hasSentFrame() {
+    uint64_t status = getStatus();
+    return status & 0x80;
+}
+ 
+void DW1000::clearSentFlag() {
+    writeRegister8(DW1000_SYS_STATUS, 0, 0xF8);                 // clearing of sending status bits
+}
+ 
+uint64_t DW1000::getSYSTimestamp() {
+    return readRegister40(DW1000_SYS_TIME, 0);
+}
+ 
+uint64_t DW1000::getRXTimestamp() {
+    return readRegister40(DW1000_RX_TIME, 0);
+}
+ 
+uint64_t DW1000::getTXTimestamp() {
+    return readRegister40(DW1000_TX_TIME, 0);
+}
+ 
+float DW1000::getSYSTimestampUS() {
+    return getSYSTimestamp() * TIMEUNITS_TO_US;
+}
+ 
+float DW1000::getRXTimestampUS() {
+    return getRXTimestamp() * TIMEUNITS_TO_US;
+}
+ 
+float DW1000::getTXTimestampUS() {
+    return getTXTimestamp() * TIMEUNITS_TO_US;
+}
+ 
+uint16_t DW1000::getStdNoise() {
+    return readRegister16(DW1000_RX_FQUAL, 0x00);
+}
+ 
+uint16_t DW1000::getPACC() {
+    uint32_t v = readRegister32(DW1000_RX_FINFO, 0x00);
+    v >>= 20;
+    return static_cast<uint16_t>(v);
+}
+ 
+uint16_t DW1000::getFPINDEX() {
+    return readRegister16(DW1000_RX_TIME, 0x05);
+}
+ 
+uint16_t DW1000::getFPAMPL1() {
+    return readRegister16(DW1000_RX_TIME, 0x07);
+}
+ 
+uint16_t DW1000::getFPAMPL2() {
+    return readRegister16(DW1000_RX_FQUAL, 0x02);
+}
+ 
+uint16_t DW1000::getFPAMPL3() {
+    return readRegister16(DW1000_RX_FQUAL, 0x04);
+}
+ 
+uint16_t DW1000::getCIRPWR() {
+    return readRegister16(DW1000_RX_FQUAL, 0x06);
+}
+ 
+uint8_t DW1000::getPRF()
+{
+    uint32_t prf_mask = static_cast<uint32_t>(0x1 << 19 | 0x1 << 18);
+    uint32_t prf = readRegister32(DW1000_CHAN_CTRL, 0x00);
+    prf >>= 18;
+    return static_cast<uint8_t>(prf & prf_mask);
+}
+ 
+void DW1000::sendString(char* message) {
+    sendFrame((uint8_t*)message, strlen(message)+1);
+}
+ 
+void DW1000::receiveString(char* message) {
+    readRegister(DW1000_RX_BUFFER, 0, (uint8_t*)message, getFramelength());  // get data from buffer
+}
+ 
+void DW1000::sendFrame(uint8_t* message, uint16_t length) {
+    //if (length >= 1021) length = 1021;                            // check for maximim length a frame can have with 1024 Byte frames [not used, see constructor]
+    if (length >= 125) length = 125;                                // check for maximim length a frame can have with 127 Byte frames
+ 
+    Timer timer;
+    timer.start();
+    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
+}
+ 
+void DW1000::sendDelayedFrame(uint8_t* message, uint16_t length, uint64_t TxTimestamp) {
+    clearSentFlag();                                                // This is necessary, otherwise we pick up the transmission time of the previous send
+ 
+    if (TxTimestamp > CONST_2POWER40) {
+        TxTimestamp -= CONST_2POWER40;
+    }
+ 
+    //if (length >= 1021) length = 1021;                            // check for maximim length a frame can have with 1024 Byte frames [not used, see constructor]
+    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
+}
+ 
+void DW1000::startRX() {
+    writeRegister8(DW1000_SYS_CTRL, 0x01, 0x01);                    // start listening for preamble by setting the RXENAB bit
+    wait_us(16);                                                    // According to page 81 in the user manual (RXENAB bit)
+}
+ 
+void DW1000::stopTRX() {
+    writeRegister8(DW1000_SYS_CTRL, 0, 0x40);                       // disable tranceiver go back to idle mode by setting the TRXOFF bit
+}
+ 
+// PRIVATE Methods ------------------------------------------------------------------------------------
+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
+    wait_us(150);
+    writeRegister16(DW1000_PMSC, 0, 0x0200);                        // recover to PLL clock
+}
+ 
+void DW1000::resetRX() {    
+    writeRegister8(DW1000_PMSC, 3, 0xE0);   // set RX reset
+    writeRegister8(DW1000_PMSC, 3, 0xF0);   // clear RX reset
+}
+ 
+void DW1000::hardwareReset(PinName reset_pin) {
+    DigitalInOut reset(reset_pin);
+    hardwareReset(reset);
+}
+ 
+void DW1000::hardwareReset(DigitalInOut& reset) {
+    if (reset.is_connected()) {
+        // DWM1000 RESET logic.
+        if (DWM1000_DAMAGED) {
+            /*
+            // The following code works for damaged DWM1000 modules.
+            // IMPORTANT: This will damage healthy DWM1000 modules!
+            reset.output();
+            reset = 1;
+            wait_ms(100);
+            reset = 0;
+            wait_ms(100);
+            reset = 1;
+            wait_ms(100);
+            */
+        } else {
+            // The following code works for healthy DWM1000 modules
+            reset.output();
+            reset = 0;
+            wait_ms(100);
+            reset.input();
+        }
+    }
+}
+ 
+void DW1000::softwareReset() {
+    stopTRX();
+    clearReceivedFlag();
+    clearSentFlag();
+}
+ 
+void DW1000::resetAll() {
+    hardwareReset(reset);
+ 
+    writeRegister8(DW1000_PMSC, 0, 0x01);   // set clock to XTAL
+    writeRegister8(DW1000_PMSC, 3, 0x00);   // set All reset
+    wait_us(10);                            // wait for PLL to lock
+    writeRegister8(DW1000_PMSC, 3, 0xF0);   // clear All reset
+}
+ 
+ 
+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::ISR() {
+    uint64_t status = getStatus();
+    if (status & 0x4000) {                                          // a frame was received
+        callbackRX.call();
+        writeRegister16(DW1000_SYS_STATUS, 0, 0x6F00);              // clearing of receiving status bits
+    }
+    if (status & 0x80) {                                            // sending complete
+        callbackTX.call();
+        writeRegister8(DW1000_SYS_STATUS, 0, 0xF8);                 // clearing of sending status bits
+    }
+}
+*/
+ 
+uint16_t DW1000::getFramelength() {
+    uint16_t framelength = readRegister16(DW1000_RX_FINFO, 0);      // get framelength
+    framelength = (framelength & 0x03FF) - 2;                       // take only the right bits and subtract the 2 CRC Bytes
+    return framelength;
+}
+ 
+// SPI Interface ------------------------------------------------------------------------------------
+uint8_t DW1000::readRegister8(uint8_t reg, uint16_t subaddress) {
+    uint8_t result;
+    readRegister(reg, subaddress, &result, 1);
+    return result;
+}
+ 
+uint16_t DW1000::readRegister16(uint8_t reg, uint16_t subaddress) {
+    uint16_t result;
+    readRegister(reg, subaddress, (uint8_t*)&result, 2);
+    return result;
+}
+ 
+uint32_t DW1000::readRegister32(uint8_t reg, uint16_t subaddress) {
+    uint32_t result;
+    readRegister(reg, subaddress, (uint8_t*)&result, 4);
+    return result;
+}
+ 
+uint64_t DW1000::readRegister40(uint8_t reg, uint16_t subaddress) {
+    uint64_t result;
+    readRegister(reg, subaddress, (uint8_t*)&result, 5);
+    result &= 0xFFFFFFFFFF;                                 // only 40-Bit
+    return result;
+}
+ 
+void DW1000::writeRegister8(uint8_t reg, uint16_t subaddress, uint8_t buffer) {
+    writeRegister(reg, subaddress, &buffer, 1);
+}
+ 
+void DW1000::writeRegister16(uint8_t reg, uint16_t subaddress, uint16_t buffer) {
+    writeRegister(reg, subaddress, (uint8_t*)&buffer, 2);
+}
+ 
+void DW1000::writeRegister32(uint8_t reg, uint16_t subaddress, uint32_t buffer) {
+    writeRegister(reg, subaddress, (uint8_t*)&buffer, 4);
+}
+ 
+void DW1000::writeRegister40(uint8_t reg, uint16_t subaddress, uint64_t buffer) {
+    writeRegister(reg, subaddress, (uint8_t*)&buffer, 5);
+}
+ 
+void DW1000::readRegister(uint8_t reg, uint16_t subaddress, uint8_t *buffer, int length) {
+    setupTransaction(reg, subaddress, false);
+    for(int i=0; i<length; i++)                             // get data
+        buffer[i] = spi.write(0x00);
+    deselect();
+}
+ 
+void DW1000::writeRegister(uint8_t reg, uint16_t subaddress, uint8_t *buffer, int length) {
+    setupTransaction(reg, subaddress, true);
+    for(int i=0; i<length; i++)                             // put data
+        spi.write(buffer[i]);
+    deselect();
+}
+ 
+void DW1000::setupTransaction(uint8_t reg, uint16_t subaddress, bool write) {
+    reg |=  (write * DW1000_WRITE_FLAG);                                        // set read/write flag
+    select();
+    if (subaddress > 0) {                                                       // there's a subadress, we need to set flag and send second header byte
+        spi.write(reg | DW1000_SUBADDRESS_FLAG);
+        if (subaddress > 0x7F) {                                                // sub address too long, we need to set flag and send third header byte
+            spi.write((uint8_t)(subaddress & 0x7F) | DW1000_2_SUBADDRESS_FLAG); // and 
+            spi.write((uint8_t)(subaddress >> 7));
+        } else {
+            spi.write((uint8_t)subaddress);
+        }
+    } else {
+        spi.write(reg);                                                         // say which register address we want to access
+    }
+}
+ 
+void DW1000::select() {     // always called to start an SPI transmission
+    /*
+    if (irq != NULL) {
+        //irq->disable_irq();
+        irq.disable_irq();
+    }
+    */
+    cs = 0;                 // set Cable Select pin low to start transmission
+}
+ 
+void DW1000::deselect() {   // always called to end an SPI transmission
+    cs = 1;                 // set Cable Select pin high to stop transmission
+    /*
+    if (irq != NULL) {
+        //irq->enable_irq();
+        irq.enable_irq();
+    }
+    */
+}
\ No newline at end of file

diff -r 066dfbe8b4b9 -r 8d4a354816b1 DW1000/DW1000.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DW1000/DW1000.h	Mon Feb 17 23:24:52 2020 +0000
@@ -0,0 +1,151 @@
+// Adapted from Matthias Grob & Manuel Stalder - ETH Zürich - 2015
+ 
+#ifndef DW1000_H
+#define DW1000_H
+ 
+#include "mbed.h"
+ 
+// register addresses
+//      Mnemonic                    Address Bytes Description
+#define DW1000_DEV_ID               0x00 //     4 Device Identifier – includes device type and revision information
+#define DW1000_EUI                  0x01 //     8 Extended Unique Identifier
+#define DW1000_PANADR               0x03 //     4 PAN Identifier and Short Address
+#define DW1000_SYS_CFG              0x04 //     4 System Configuration bitmap
+#define DW1000_SYS_TIME             0x06 //     5 System Time Counter (40-bit)
+#define DW1000_TX_FCTRL             0x08 //     5 Transmit Frame Control
+#define DW1000_TX_BUFFER            0x09 //  1024 Transmit Data Buffer
+#define DW1000_DX_TIME              0x0A //     5 Delayed Send or Receive Time (40-bit)
+#define DW1000_RX_FWTO              0x0C //     2 Receive Frame Wait Timeout Period
+#define DW1000_SYS_CTRL             0x0D //     4 System Control Register
+#define DW1000_SYS_MASK             0x0E //     4 System Event Mask Register
+#define DW1000_SYS_STATUS           0x0F //     5 System Event Status Register
+#define DW1000_RX_FINFO             0x10 //     4 RX Frame Information                (in double buffer set)
+#define DW1000_RX_BUFFER            0x11 //  1024 Receive Data Buffer                 (in double buffer set)
+#define DW1000_RX_FQUAL             0x12 //     8 Rx Frame Quality information        (in double buffer set)
+#define DW1000_RX_TTCKI             0x13 //     4 Receiver Time Tracking Interval     (in double buffer set)
+#define DW1000_RX_TTCKO             0x14 //     5 Receiver Time Tracking Offset       (in double buffer set)
+#define DW1000_RX_TIME              0x15 //    14 Receive Message Time of Arrival     (in double buffer set)
+#define DW1000_TX_TIME              0x17 //    10 Transmit Message Time of Sending    (in double buffer set)
+#define DW1000_TX_ANTD              0x18 //     2 16-bit Delay from Transmit to Antenna
+#define DW1000_SYS_STATE            0x19 //     5 System State information
+#define DW1000_ACK_RESP_T           0x1A //     4 Acknowledgement Time and Response Time
+#define DW1000_RX_SNIFF             0x1D //     4 Pulsed Preamble Reception Configuration
+#define DW1000_TX_POWER             0x1E //     4 TX Power Control
+#define DW1000_CHAN_CTRL            0x1F //     4 Channel Control
+#define DW1000_USR_SFD              0x21 //    41 User-specified short/long TX/RX SFD sequences
+#define DW1000_AGC_CTRL             0x23 //    32 Automatic Gain Control configuration
+#define DW1000_EXT_SYNC             0x24 //    12 External synchronisation control.
+#define DW1000_ACC_MEM              0x25 //  4064 Read access to accumulator data
+#define DW1000_GPIO_CTRL            0x26 //    44 Peripheral register bus 1 access - GPIO control
+#define DW1000_DRX_CONF             0x27 //    44 Digital Receiver configuration
+#define DW1000_RF_CONF              0x28 //    58 Analog RF Configuration
+#define DW1000_TX_CAL               0x2A //    52 Transmitter calibration block
+#define DW1000_FS_CTRL              0x2B //    21 Frequency synthesiser control block
+#define DW1000_AON                  0x2C //    12 Always-On register set
+#define DW1000_OTP_IF               0x2D //    18 One Time Programmable Memory Interface
+#define DW1000_LDE_CTRL             0x2E //     - Leading edge detection control block
+#define DW1000_DIG_DIAG             0x2F //    41 Digital Diagnostics Interface
+#define DW1000_PMSC                 0x36 //    48 Power Management System Control Block
+ 
+#define DW1000_WRITE_FLAG           0x80 // First Bit of the address has to be 1 to indicate we want to write
+#define DW1000_SUBADDRESS_FLAG      0x40 // if we have a sub address second Bit has to be 1
+#define DW1000_2_SUBADDRESS_FLAG    0x80 // if we have a long sub adress (more than 7 Bit) we set this Bit in the first part
+ 
+ 
+ 
+//#define SYS_STATUS_ALL_RX_ERR  (SYS_STATUS_RXPHE | SYS_STATUS_RXFCE | SYS_STATUS_RXRFSL | SYS_STATUS_RXSFDTO | SYS_STATUS_AFFREJ | SYS_STATUS_LDEERR)
+                                
+ 
+class DW1000
+{
+    public:
+        const static float TIMEUNITS_TO_US = (1/(128*499.2f));  // conversion between the decawave timeunits (ca 15.65ps) to microseconds.
+        const static float US_TO_TIMEUNITS = (128*499.2f);      // conversion between microseconds to the decawave timeunits (ca 15.65ps).
+        const static uint64_t CONST_2POWER40 = 1099511627776;  // Time register in DW1000 is 40 bit so this is needed to detect overflows.
+ 
+        DW1000(PinName MOSI, PinName MISO, PinName SCLK, PinName CS, PinName IRQ, PinName RESET);              // constructor, uses SPI class             // constructor, uses SPI class
+ 
+        void setCallbacks(void (*callbackRX)(void), void (*callbackTX)(void));                  // setter for callback functions, automatically enables interrupt, if NULL is passed the coresponding interrupt gets disabled
+        template<typename T>
+        void setCallbacks(T* tptr, void (T::*mptrRX)(void), void (T::*mptrTX)(void))
+        {      // overloaded setter to treat member function pointers of objects
+            callbackRX.attach(tptr, mptrRX);                                                    // possible client code: dw.setCallbacks(this, &A::callbackRX, &A::callbackTX);
+            callbackTX.attach(tptr, mptrTX);                                                    // concept seen in line 100 of http://developer.mbed.org/users/mbed_official/code/mbed/docs/4fc01daae5a5/InterruptIn_8h_source.html
+            setInterrupt(true,true);
+        }
+ 
+        // Device API
+        uint32_t getDeviceID();                                                                 // gets the Device ID which should be 0xDECA0130 (good for testing SPI!)
+        uint64_t getEUI();                                                                      // gets 64 bit Extended Unique Identifier according to IEEE standard
+        void setEUI(uint64_t EUI);                                                              // sets 64 bit Extended Unique Identifier according to IEEE standard
+        float getVoltage();                                                                     // gets the current chip voltage measurement form the A/D converter
+        uint64_t getStatus();                                                                   // get the 40 bit device status
+        bool hasTransmissionStarted();                                                          // check if frame transmission has started
+        bool hasSentPreamble();                                                                 // check if preamble has been sent
+        bool hasSentPHYHeader();                                                                // check if PHY header has been sent
+        bool hasSentFrame();                                                                    // check if frame has been sent completely
+        bool hasReceivedFrame();
+        void clearReceivedFlag();
+        void clearSentFlag();
+        uint64_t getSYSTimestamp();
+        uint64_t getRXTimestamp();
+        uint64_t getTXTimestamp();
+        float getSYSTimestampUS();
+        float getRXTimestampUS();
+        float getTXTimestampUS();
+ 
+        uint16_t getStdNoise();
+        uint16_t getPACC();
+        uint16_t getFPINDEX();
+        uint16_t getFPAMPL1();
+        uint16_t getFPAMPL2();
+        uint16_t getFPAMPL3();
+        uint16_t getCIRPWR();
+        uint8_t getPRF();
+        
+        void sendString(char* message);                                                         // to send String with arbitrary length
+        void receiveString(char* message);                                                      // to receive char string (length of the buffer must be 1021 to be safe)
+        void sendFrame(uint8_t* message, uint16_t length);                                      // send a raw frame (length in bytes)
+        void sendDelayedFrame(uint8_t* message, uint16_t length, uint64_t TxTimestamp);
+        uint16_t getFramelength();                                                              // to get the framelength of the received frame from the PHY header
+        void startRX();                                                                         // start listening for frames
+        void stopTRX();                                                                         // disable tranceiver go back to idle mode
+ 
+        static void hardwareReset(PinName reset_pin);
+        static void hardwareReset(DigitalInOut& reset_pin);
+        void softwareReset();
+ 
+        uint8_t readRegister8(uint8_t reg, uint16_t subaddress);                                // expressive methods to read or write the number of bits written in the name
+        uint16_t readRegister16(uint8_t reg, uint16_t subaddress);
+        uint32_t readRegister32(uint8_t reg, uint16_t subaddress);
+        uint64_t readRegister40(uint8_t reg, uint16_t subaddress);
+        void writeRegister8(uint8_t reg, uint16_t subaddress, uint8_t buffer);
+        void writeRegister16(uint8_t reg, uint16_t subaddress, uint16_t buffer);
+        void writeRegister32(uint8_t reg, uint16_t subaddress, uint32_t buffer);
+        void writeRegister40(uint8_t reg, uint16_t subaddress, uint64_t buffer);
+        void readRegister(uint8_t reg, uint16_t subaddress, uint8_t *buffer, int length);       // reads the selected part of a slave register into the buffer memory
+        void writeRegister(uint8_t reg, uint16_t subaddress, uint8_t *buffer, int length);      // writes the buffer memory to the selected slave register
+ 
+    private:
+        void loadLDE();                                                                         // load the leading edge detection algorithm to RAM, [IMPORTANT because receiving malfunction may occur] see User Manual LDELOAD on p22 & p158
+        void resetRX();                                                                         // soft reset only the tranciever part of DW1000
+        void resetAll();                                                                        // soft reset the entire DW1000 (some registers stay as they were see User Manual)
+ 
+        // Interrupt
+        InterruptIn irq;
+        FunctionPointer callbackRX;                                                             // function pointer to callback which is called when successfull RX took place
+        FunctionPointer callbackTX;                                                             // function pointer to callback which is called when successfull TX took place
+        void setInterrupt(bool RX, bool TX);                                                    // set Interrupt for received a good frame (CRC ok) or transmission done
+        void ISR();                                                                             // interrupt handling method (also calls according callback methods)
+        
+        // SPI Inteface
+        SPI spi;                                                                                // SPI Bus
+        DigitalOut cs;                                                                          // Slave selector for SPI-Bus (here explicitly needed to start and end SPI transactions also usable to wake up DW1000)
+        DigitalInOut reset;
+ 
+        void setupTransaction(uint8_t reg, uint16_t subaddress, bool write);                    // sets up an SPI read or write transaction with correct register address and offset
+        void select();                                                                          // selects the only slave for a transaction
+        void deselect();   
+};
+ 
+#endif
\ No newline at end of file

diff -r 066dfbe8b4b9 -r 8d4a354816b1 DW1000/DW1000Utils.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DW1000/DW1000Utils.h	Mon Feb 17 23:24:52 2020 +0000
@@ -0,0 +1,181 @@
+#pragma once
+ 
+#include <mbed.h>
+#include "DW1000.h"
+ 
+class DW1000Utils
+{
+public:
+    // Recommended settings:
+    // Data rate 110 kbps - Preamble length 2048 or 4096.
+    // Data rate 850 kbps - Preamble length 256, 512 or 1024.
+    // Data rate 6.8 Mbps - Preamble length 64.
+ 
+    const static uint32_t PREAMBLE_LENGTH_64 = (1 << 18);
+    const static uint32_t PREAMBLE_LENGTH_128 = (1 << 18) | (1 << 20);
+    const static uint32_t PREAMBLE_LENGTH_256 = (1 << 18) | (1 << 21);
+    const static uint32_t PREAMBLE_LENGTH_512 = (1 << 18) | (1 << 20) | (1 << 21);
+    const static uint32_t PREAMBLE_LENGTH_1024 = (1 << 19);
+    const static uint32_t PREAMBLE_LENGTH_2048 = (1 << 19) | (1 << 21);
+    const static uint32_t PREAMBLE_LENGTH_4096 = (1 << 18) | (1 << 19);
+ 
+    enum PrfSetting
+    {
+        PRF_16_MHz = 1,
+        PRF_64_MHz,
+    };
+ 
+    enum DataRateSetting
+    {
+        RATE_110_kbps = 1,
+        RATE_850_kbps,
+        RATE_6_8_Mbps,
+    };
+ 
+    // Set pulse repetition frequency
+    static void setPulseRepetitionFrequency(DW1000* dw_ptr, PrfSetting prf_setting)
+    {
+        // Transmit PRF setting (see page 75 of user manual)
+        uint32_t prf_value;
+        if (prf_setting == PRF_16_MHz)
+        {
+            prf_value = (1 << 16);
+        }
+        else
+        {
+            prf_value = (1 << 17);
+        }
+        uint32_t prf_mask = (1 << 16) | (1 << 17);
+        uint32_t tx_ctrl = dw_ptr->readRegister32(DW1000_TX_FCTRL, 0x00);
+        tx_ctrl &= ~prf_mask;
+        tx_ctrl |= (prf_value & prf_mask);
+        dw_ptr->writeRegister32(DW1000_TX_FCTRL, 0x00, tx_ctrl);
+ 
+        // Receive PRF setting (see page 109 and of user manual)
+        if (prf_setting == PRF_16_MHz)
+        {
+            prf_value = (1 << 18);
+        }
+        else
+        {
+            prf_value = (1 << 19);
+        }
+        prf_mask = (1 << 18) | (1 << 19);
+        uint32_t chan_ctrl = dw_ptr->readRegister32(DW1000_CHAN_CTRL, 0x00);
+        chan_ctrl &= ~prf_mask;
+        chan_ctrl |= (prf_value & prf_mask);
+        dw_ptr->writeRegister32(DW1000_CHAN_CTRL, 0x00, chan_ctrl);
+    }
+ 
+    // Set preamble length (see page 76 of user manual)
+    static void setPreambleLength(DW1000* dw_ptr, uint32_t preamble_setting)
+    {
+        uint32_t preamble_mask = (1 << 18) | (1 << 19) | (1 << 20) | (1 << 21);
+        uint32_t tx_ctrl = dw_ptr->readRegister32(DW1000_TX_FCTRL, 0x00);
+        tx_ctrl &= ~preamble_mask;
+        tx_ctrl |= (preamble_setting & preamble_mask);
+        dw_ptr->writeRegister32(DW1000_TX_FCTRL, 0x00, tx_ctrl);
+    }
+ 
+    // Set data rate
+    static void setDataRate(DW1000* dw_ptr, DataRateSetting rate_setting)
+    {
+        // Transmit data rate (see page 73 of user manual)
+        uint32_t rate_value;
+        if (rate_setting == RATE_110_kbps)
+        {
+            rate_value = 0;
+        }
+        else if (rate_setting == RATE_850_kbps)
+        {
+            rate_value = (1 << 13);
+        }
+        else
+        {
+            rate_value = (1 << 14);
+        }
+        uint32_t rate_mask = (1 << 13) | (1 << 14);
+        uint32_t tx_ctrl = dw_ptr->readRegister32(DW1000_TX_FCTRL, 0x00);
+        tx_ctrl &= ~rate_mask;
+        tx_ctrl |= (rate_value & rate_mask);
+        dw_ptr->writeRegister32(DW1000_TX_FCTRL, 0x00, tx_ctrl);
+ 
+        // Receive data rate (see page 72 of user manual)
+        if (rate_setting == RATE_110_kbps)
+        {
+            rate_value = (1 << 18);
+            rate_value = (1 << 22);
+        }
+        else if (rate_setting == RATE_850_kbps)
+        {
+            rate_value = (1 << 18);
+        }
+        else
+        {
+            rate_value = 0;
+        }
+        rate_mask = (1 << 18) | (1 << 22);
+        uint32_t sys_cfg = dw_ptr->readRegister32(DW1000_SYS_CFG, 0x00);
+        sys_cfg &= ~rate_mask;
+        sys_cfg |= (rate_value & rate_mask);
+        dw_ptr->writeRegister32(DW1000_SYS_CFG, 0x00, sys_cfg);
+ 
+        if (rate_setting == RATE_110_kbps)
+        {
+            dw_ptr->writeRegister16(DW1000_DRX_CONF, 0x02, 0x000A);     // DRX_TUNE0b for 110 kbps
+            dw_ptr->writeRegister16(DW1000_DRX_CONF, 0x06, 0x0064);     // DRX_TUNE1b for 110 kbps & > 1024 symbols
+        }
+        else if (rate_setting == RATE_850_kbps)
+        {
+            dw_ptr->writeRegister16(DW1000_DRX_CONF, 0x02, 0x0001);     // DRX_TUNE0b for 850 kbps
+            dw_ptr->writeRegister16(DW1000_DRX_CONF, 0x06, 0x0020);     // DRX_TUNE1b for 850 kbps & 128 - 1024 symbols
+        }
+        else
+        {
+            dw_ptr->writeRegister16(DW1000_DRX_CONF, 0x02, 0x0001);     // DRX_TUNE0b for 6.8 Mbps
+            dw_ptr->writeRegister16(DW1000_DRX_CONF, 0x06, 0x0010);     // DRX_TUNE1b for 6.8 Mbps & 64 symbols
+        }
+    }
+ 
+    // Improved settings for direct path detection in non-line-of-sight environments.
+    // See DecaWave Application Note APS006.
+    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)
+    {
+        setDataRate(dw_ptr, rate_setting);
+        setPulseRepetitionFrequency(dw_ptr, prf_setting);
+        setPreambleLength(dw_ptr, preamble_setting);
+ 
+        // Setting for Noise Threshold Multiplier 1
+        dw_ptr->writeRegister8(DW1000_LDE_CTRL, 0x0806, 0x07);                  // LDE_CFG1
+        // Setting for Noise Threshold Multiplier 2
+        if (prf_setting == PRF_16_MHz)
+        {
+            dw_ptr->writeRegister16(DW1000_LDE_CTRL, 0x1806, 0x0003);           // LDE_CFG2 for 16 MHz PRF
+        }
+        else
+        {
+            dw_ptr->writeRegister16(DW1000_LDE_CTRL, 0x1806, 0x1603);           // LDE_CFG2 for 64 MHz PRF
+        }
+    }
+ 
+    // Default settings for line-of-sight environments
+    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)
+    {
+        setDataRate(dw_ptr, rate_setting);
+        setPulseRepetitionFrequency(dw_ptr, prf_setting);
+        setPreambleLength(dw_ptr, preamble_setting);
+ 
+        // Setting for Noise Threshold Multiplier 1
+            dw_ptr->writeRegister8(DW1000_LDE_CTRL, 0x0806, 0x0c);              // LDE_CFG1
+//        dw_ptr->writeRegister8(DW1000_LDE_CTRL, 0x0806, 0x0d);                // LDE_CFG1
+        // Setting for Noise Threshold Multiplier 2
+        if (prf_setting == PRF_16_MHz)
+        {
+            dw_ptr->writeRegister16(DW1000_LDE_CTRL, 0x1806, 0x1607);           // LDE_CFG2 for 16 MHz PRF
+        }
+        else
+        {
+            dw_ptr->writeRegister16(DW1000_LDE_CTRL, 0x1806, 0x0607);           // LDE_CFG2 for 64 MHz PRF
+        }
+    }
+};
\ No newline at end of file

diff -r 066dfbe8b4b9 -r 8d4a354816b1 LED.cpp
--- a/LED.cpp	Thu Feb 13 00:57:06 2020 +0000
+++ b/LED.cpp	Mon Feb 17 23:24:52 2020 +0000
@@ -4,6 +4,7 @@
 // LED
 //------------------------------------------------------------------------------ 
 DigitalOut led1(PN_LED);
+DigitalOut led2(PN_LED_BLUE);
 
 void LED1on(long milliseconds = 0) {
     led1 = 0;
@@ -42,4 +43,42 @@
 }
 void LED1off() {
     led1 = 1;
+}
+
+
+
+
+
+void LED2on(long milliseconds = 0) {
+    led2 = 0;
+    if (milliseconds > 0) {
+        ThisThread::sleep_for(milliseconds);
+        led2 = 1;
+    }
+}
+void LED2blink(int count = 2, long milliseconds = 100) {
+    for (int i = 0; i < (count*2); i++) {
+        led2 = !led2;
+        if (milliseconds > 0) {
+            ThisThread::sleep_for(milliseconds);
+        } else { 
+            ThisThread::sleep_for(100); //default if 0 provided
+        }
+    }
+    led2 = 1;
+}
+void LED2errorCode(int pattern, int count) {
+    for (int i = 0; i < count; i++) {
+        for (int p = 0; p < pattern; p++) {
+            led2 = 0;
+            ThisThread::sleep_for(200);
+            led2 = 1;
+            ThisThread::sleep_for(300);
+        }
+        ThisThread::sleep_for(1000);
+    }
+    led2 = 1;
+}
+void LED2off() {
+    led2 = 1;
 }
\ No newline at end of file

diff -r 066dfbe8b4b9 -r 8d4a354816b1 LED.h
--- a/LED.h	Thu Feb 13 00:57:06 2020 +0000
+++ b/LED.h	Mon Feb 17 23:24:52 2020 +0000
@@ -4,10 +4,18 @@
 #include "main.h"
 
 extern DigitalOut led1;
+extern DigitalOut led2;
+
 extern void LED1on(long milliseconds);
 extern void LED1blink(int count, long milliseconds);
 extern void LED1blinkRTC(int count);
 extern void LED1errorCode(int pattern, int count);
 extern void LED1off(void);
 
+extern void LED2on(long milliseconds);
+extern void LED2blink(int count, long milliseconds);
+extern void LED2blinkRTC(int count);
+extern void LED2errorCode(int pattern, int count);
+extern void LED2off(void);
+
 #endif
\ No newline at end of file

diff -r 066dfbe8b4b9 -r 8d4a354816b1 Lis2dh12.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lis2dh12.lib	Mon Feb 17 23:24:52 2020 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/teams/Pathfindr/code/Lis2dh12/#9a41168aed47

diff -r 066dfbe8b4b9 -r 8d4a354816b1 MM2WayRanging.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/MM2WayRanging.cpp	Mon Feb 17 23:24:52 2020 +0000
@@ -0,0 +1,188 @@
+#include "MM2WayRanging.h"
+#include "NRFuart.h"
+
+
+MM2WayRanging::MM2WayRanging(DW1000& DW) : dw(DW) {
+    isBeacon = true;
+    overflow = false;
+    address = 0;
+    
+    LocalTimer.start();
+    dw.startRX();   
+}
+
+
+bool MM2WayRanging::waitForFrameRX(float time_before) {
+    bool frameReceived = false;
+    while(!frameReceived && (LocalTimer.read() < time_before + 0.02f)) {
+        frameReceived = dw.hasReceivedFrame();
+    }; // wait for succeeding or timeout
+    if (frameReceived) {
+        //debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "Frame Received\n");debug_exe();
+        callbackRX();
+        dw.clearReceivedFlag();
+    } else {
+        //debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "Receive Timeout\n");debug_exe();
+    }
+    return frameReceived;
+}
+
+
+bool MM2WayRanging::waitForFrameTX(float time_before) {
+    bool frameSent = false;
+    while(!frameSent && (LocalTimer.read() < time_before + 0.02f)) {
+        frameSent = dw.hasSentFrame();
+    }; // wait for succeeding or timeout
+    if (frameSent) {
+        //debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "Frame Sent\n");debug_exe();
+        callbackTX();
+        dw.clearSentFlag();
+    } else {
+        //debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "Send Timeout\n");debug_exe();
+    }
+    return frameSent;
+}
+
+ 
+
+void MM2WayRanging::callbackRX() {
+    dw.readRegister(DW1000_RX_BUFFER, 0, (uint8_t*)&receivedFrame, dw.getFramelength());
+    
+    //MESSAGES ADDRESSED FOR ALL DETECTORS
+    if (receivedFrame.destination == 0) {  
+        switch (receivedFrame.type) {
+            case BEACON_READY:
+                anchor_to_beacon_Send(receivedFrame.source);
+                //TODO - WE COULD ALSO TIME THIS FRAME AND THEN DIVIDE BY THREE TO GET MORE ACCURACY?
+                break;
+            default : break;
+        }
+    }
+    
+    //MESSAGES ADDRESSED FOR ME
+    if (receivedFrame.destination == address) 
+        switch (receivedFrame.type) {
+            case ANCHOR_TO_BEACON_PING:
+                RxTimestamp = dw.getRXTimestamp();
+                beacon_to_anchor_response_Send(receivedFrame.source, RxTimestamp);
+                break;
+            case BEACON_TO_ANCHOR_RESPONSE:
+                rangingRxTimestamp[receivedFrame.destination] = dw.getRXTimestamp();
+                //Calulate time/distance
+                rangingTOF[receivedFrame.source] = (rangingRxTimestamp[receivedFrame.source] - rangingTxTimestamp[receivedFrame.source]); //TODO need to remove ANSWER_DELAY_TIMEUNITS from this
+                rangingDistance[receivedFrame.source] = (rangingTOF[receivedFrame.source] * 300 * TIMEUNITS_TO_US / 4); //TODO should this be divide by 2?
+                debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "Distance(%d): %d\n",receivedFrame.source, rangingDistance[receivedFrame.source]);debug_exe();
+                break;
+            default : break;
+        }
+ 
+    //debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "Received From: %d\n",receivedFrame.destination);debug_exe();
+    dw.startRX();
+}
+
+ 
+
+void MM2WayRanging::callbackTX() {
+    //dw.readRegister(DW1000_TX_BUFFER, 0, (uint8_t*)&sentFrame, dw.getFramelength());
+    switch (rangingFrame.type) {
+        case BEACON_READY:
+            //No Need to do anything
+            break;
+        case ANCHOR_TO_BEACON_PING:
+            rangingTxTimestamp[rangingFrame.destination] = dw.getTXTimestamp();
+            break;
+        case BEACON_TO_ANCHOR_RESPONSE:
+            //No Need to do anything
+            break;
+        default: break;
+    }
+}
+
+
+
+bool MM2WayRanging::beacon_requestRanging() {
+    float time_before = LocalTimer.read();
+    beacon_ready_Send();
+    bool sendSuccess = waitForFrameTX(time_before);
+    if (sendSuccess) {
+        //WAIT FOR FIRST RANGING FROM AN ANCHOR - TIMEOUT AFTER NO RANGING FOR CERTAIN TIME
+        float lastRangingTime = LocalTimer.read();
+        while((LocalTimer.read() - lastRangingTime) < 0.02f) {
+            if (waitForFrameRX(lastRangingTime)) {
+                lastRangingTime = LocalTimer.read();
+            }
+        }
+    } else {
+        //Send Fail   
+    }
+    //debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "Range End - %d\n",destination);debug_exe();
+}
+
+
+
+void MM2WayRanging::anchor_standbyToRange() {
+    float time_before = LocalTimer.read();
+    waitForFrameRX(time_before);
+}
+
+
+void MM2WayRanging::beacon_ready_Send() {
+    rangingFrame.source = address;
+    rangingFrame.destination = 0;
+    rangingFrame.type = BEACON_READY;
+    dw.sendFrame((uint8_t*)&rangingFrame, sizeof(rangingFrame));
+}
+ 
+void MM2WayRanging::anchor_to_beacon_Send(uint8_t destination) {
+    rangingFrame.source = address;
+    rangingFrame.destination = destination;
+    rangingFrame.type = ANCHOR_TO_BEACON_PING;
+    dw.sendFrame((uint8_t*)&rangingFrame, sizeof(rangingFrame));
+}
+
+void MM2WayRanging::beacon_to_anchor_response_Send(uint8_t destination, uint64_t rxTimestamp) {
+    rangingFrame.source = address;
+    rangingFrame.destination = destination;
+    rangingFrame.type = BEACON_TO_ANCHOR_RESPONSE;
+    if(rxTimestamp + ANSWER_DELAY_TIMEUNITS > MMRANGING_2POWER40) {
+        dw.sendDelayedFrame((uint8_t*)&rangingFrame, sizeof(rangingFrame), rxTimestamp + ANSWER_DELAY_TIMEUNITS - MMRANGING_2POWER40);
+    } else {
+        dw.sendDelayedFrame((uint8_t*)&rangingFrame, sizeof(rangingFrame), rxTimestamp + ANSWER_DELAY_TIMEUNITS);
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+void MM2WayRanging::correctReceiverTimestamps(uint8_t source){
+    if(receiverTimestamps[source][0] > receiverTimestamps[source][1]){
+        receiverTimestamps[source][1] += MMRANGING_2POWER40;
+        receiverTimestamps[source][2] += MMRANGING_2POWER40;
+    }
+    if(receiverTimestamps[source][1] > receiverTimestamps[source][2]){
+        receiverTimestamps[source][2] += MMRANGING_2POWER40;
+    }
+}
+ 
+void MM2WayRanging::correctSenderTimestamps(uint8_t source){
+    if (senderTimestamps[source][0] > senderTimestamps[source][1]) {
+        senderTimestamps[source][1] += MMRANGING_2POWER40;
+        senderTimestamps[source][2] += MMRANGING_2POWER40;
+        overflow = true;
+    } else if (senderTimestamps[source][1] > senderTimestamps[source][2]) {
+        senderTimestamps[source][2] += MMRANGING_2POWER40;
+        overflow = true;
+    } else { 
+        overflow = false;
+    }
+}
+*/
\ No newline at end of file

diff -r 066dfbe8b4b9 -r 8d4a354816b1 MM2WayRanging.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/MM2WayRanging.h	Mon Feb 17 23:24:52 2020 +0000
@@ -0,0 +1,68 @@
+#ifndef MM2WAYRANGING_H
+#define MM2WAYRANGING_H
+ 
+#include "mbed.h"
+#include "DW1000.h"
+
+
+#define TIMEUNITS_TO_US       (1/(128*499.2))               // conversion between the decawave timeunits (ca 15.65ps) to microseconds.
+#define US_TO_TIMEUNITS       (128*499.2)                   // conversion between microseconds to the decawave timeunits (ca 15.65ps).
+#define MMRANGING_2POWER40    1099511627776                 // decimal value of 2^40 to correct timeroverflow between timestamps
+ 
+//Predefined delay for the critical answers in the ranging algorithm
+//HAS TO BE BIGGER THAN THE PROCESSING TIME OF THE FRAME ON THE NODE
+#define ANSWER_DELAY_US             2500                                    //2500 works for 110kbps, 900 for 6.8Mbps
+#define ANSWER_DELAY_TIMEUNITS      ANSWER_DELAY_US * (128*499.2)
+
+class MM2WayRanging {
+ 
+public:
+    MM2WayRanging(DW1000& DW);
+ 
+    bool beacon_requestRanging();
+    void anchor_standbyToRange();
+ 
+    bool isBeacon;
+    uint8_t address;                // Identifies the nodes as source and destination in rangingframes
+    bool overflow;                  // TRUE if counter overflows while ranging
+ 
+private:
+    DW1000& dw;
+    Timer LocalTimer;
+ 
+    bool waitForFrameTX(float time_before);
+    bool waitForFrameRX(float time_before);
+    void callbackRX();
+    void callbackTX();
+    
+    void beacon_ready_Send();
+    void anchor_to_beacon_Send(uint8_t destination);
+    void beacon_to_anchor_response_Send(uint8_t destination, uint64_t rxTimestamp);
+ 
+    //void correctReceiverTimestamps(uint8_t source);
+    //void correctSenderTimestamps(uint8_t source);
+ 
+    enum FrameType{
+        BEACON_READY=1,
+        ANCHOR_TO_BEACON_PING,
+        BEACON_TO_ANCHOR_RESPONSE
+    };
+ 
+    //the packed attribute makes sure the types only use their respective size in memory (8 bit for uint8_t), otherwise they would always use 32 bit
+    //IT IS A GCC SPECIFIC DIRECTIVE
+    struct __attribute__((packed, aligned(1))) RangingFrame {
+        uint8_t source;
+        uint8_t destination;
+        uint8_t type;
+    };
+ 
+    RangingFrame rangingFrame;                  // buffer in class for sending a frame (not made locally because then we can recall in the interrupt what was sent)
+    RangingFrame receivedFrame;
+    
+    uint64_t RxTimestamp;
+    uint64_t rangingTxTimestamp[5];
+    uint64_t rangingRxTimestamp[5];
+    uint64_t rangingTOF[5];
+    float rangingDistance[5];
+};
+#endif
\ No newline at end of file

diff -r 066dfbe8b4b9 -r 8d4a354816b1 aconno_I2C.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/aconno_I2C.lib	Mon Feb 17 23:24:52 2020 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/users/jurica238814/code/aconno_I2C/#b2f0c302ba6d

diff -r 066dfbe8b4b9 -r 8d4a354816b1 board.h
--- a/board.h	Thu Feb 13 00:57:06 2020 +0000
+++ b/board.h	Mon Feb 17 23:24:52 2020 +0000
@@ -9,11 +9,9 @@
 #define PN_LED                  P0_30   // Green
 #define PN_LED_BLUE             P0_31   // Blue
 
-#define PN_SPI_MOSI             P0_23
-#define PN_SPI_MISO             P0_19
-#define PN_SPI_CLK              P0_24
-#define PN_SPI_CS0              P0_22
-#define PN_SPI_CS1              P0_17
+#define PN_SPI_MOSI             P0_20
+#define PN_SPI_MISO             P0_18
+#define PN_SPI_CLK              P0_16
 #define PN_UART_RX              P0_11
 #define PN_UART_TX              P0_5
 #define PN_UART_CTS             P0_30
@@ -24,6 +22,13 @@
 #define PN_I2C_SDA              P0_29
 #define PN_I2C_SCL              P0_28
 
+#define DW1000_RST              P0_24
+#define DW1000_IRQ              P0_19
+#define DW1000_RDY              P0_25
+#define DW1000_CS               P0_17
+
+
+
 
 //MEMORY FOR DISK
 //#define BD_PAGE_SIZE    4096

diff -r 066dfbe8b4b9 -r 8d4a354816b1 main.cpp
--- a/main.cpp	Thu Feb 13 00:57:06 2020 +0000
+++ b/main.cpp	Mon Feb 17 23:24:52 2020 +0000
@@ -1,4 +1,4 @@
- #include "main.h"
+#include "main.h"
 // MUST USE MBED 5.10.4   2fd0c5cfbd
 
 /*
@@ -26,12 +26,16 @@
 float            RET_temperature                                    = 0.0;
 float            RET_humidity                                       = 0.0;
 bool             RET_motionState                                    = false;
+int8_t           RET_accX                                           = 0;
+int8_t           RET_accY                                           = 0;
+int8_t           RET_accZ                                           = 0;
+time_t           RET_motionLastDetected                             = 0;
+time_t           RET_InMotionSeconds                                = 0;
+time_t           RET_NoMotionSeconds                                = 0;
 bool             RET_impactState                                    = false;
 
 //STATE
 bool             RET_busy                                           = false;
-uint8_t          RET_state                                          = STATE_SETUP;
-uint8_t          RET_state_prev                                     = RET_state;
 bool             RET_asleep                                         = false;
 bool             RET_coldBoot                                       = true;
 
@@ -73,9 +77,14 @@
 time_t           EVENT_settingsScan_time                            = 0;
 
 bool             EVENT_uwbScan                                      = false;
-time_t           EVENT_uwbScan_interval                        = 60;
+time_t           EVENT_uwbScan_interval                             = 60;
 time_t           EVENT_uwbScan_time                                 = 0;
 
+bool             EVENT_resetACCInt                                  = false;
+time_t           EVENT_resetACCInt_interval                         = DEFAULT_INTERVAL_RESETACCINT;
+time_t           EVENT_resetACCInt_time                             = 0;
+
+
 //BLE
 uint16_t         RET_setting_beacon_interval_ms                     = DEFAULT_BEACON_INTERVAL_MS;
 uint16_t         RET_setting_beacon_interval_ms_active              = DEFAULT_BEACON_INTERVAL_MS;
@@ -108,6 +117,8 @@
 //GPIO
 //------------------------------------------------------------------------------ 
 InterruptIn button(PN_IN_BUTTON);
+InterruptIn accInt1(PN_ACC_INT1);
+//InterruptIn DW_irq(DW1000_IRQ);
 
 //------------------------------------------------------------------------------
 //PERIPHERALS
@@ -117,6 +128,10 @@
 LowPowerTicker RTCticker;
 LowPowerTimer LPtimer;
 
+I2C i2c(PN_I2C_SDA,PN_I2C_SCL);
+SPI spi(PN_SPI_MOSI,PN_SPI_MISO,PN_SPI_CLK);
+Lis2dh12 acc(&i2c, 0x32);
+
 //------------------------------------------------------------------------------
 //SEMAPHORES
 //------------------------------------------------------------------------------ 
@@ -200,7 +215,7 @@
 
 
 //------------------------------------------------------------------------------
-// USER BUTTON HANDLING
+// INTERUPTS
 //------------------------------------------------------------------------------ 
 void buttonPress() {
     RET_buttonPressTime = LPtimer.read_ms();
@@ -220,7 +235,10 @@
     RET_buttonReleaseTime_prev = RET_buttonReleaseTime;
 }
 
-
+void accInt1ISR() {
+    //led2 = !led2;
+    RET_motionLastDetected = RET_RTCunixtime;
+}
 
 //------------------------------------------------------------------------------
 // RTC TICKER
@@ -253,9 +271,25 @@
         if (EVENT_uwbScan_time > 0 && RET_RTCunixtime >= EVENT_uwbScan_time) {
             RET_haveEventsToRun = true; EVENT_uwbScan = true;
         }
+        if (EVENT_resetACCInt_time > 0 && RET_RTCunixtime >= EVENT_resetACCInt_time) {
+            RET_haveEventsToRun = true; EVENT_resetACCInt = true;
+        }
     }
     
-    if (RET_haveEventsToRun) {
+    //CHECK FOR MOTION OPT 
+    //Had motion in last 5 seconds?
+    if (RET_motionLastDetected > 0 && (RET_RTCunixtime-RET_motionLastDetected) < 5) {
+        EVENT_motionClear_time = (RET_RTCunixtime + EVENT_motionClear_interval);
+        if (RET_motionState == 0) {
+            RET_motionState = 1;
+            RET_BLEpacketUpdate = true;
+            RET_haveEventsToRun = true;
+        }
+    }
+    led1 = !RET_motionState;
+    
+    //WAKE UP MAIN LOOP AND RUN ANY EVENTS
+    if (RET_haveEventsToRun && RET_asleep) {
         mainthread.release();
     }
 }
@@ -430,7 +464,7 @@
 // BLE SETTINGS SCAN
 //------------------------------------------------------------------------------ 
 void settingsScan() {
-    LED1on(0);
+    //LED1on(0);
     bleStopAdvertising();
     LowPowerTimer bleScan_t;
     bleScan_t.start();
@@ -452,17 +486,62 @@
     }
     bleScan_t.stop();
     myble.gap().stopScan();
-    LED1off();
+    //LED1off();
+}
+
+//------------------------------------------------------------------------------
+// UWB SCAN
+//------------------------------------------------------------------------------ 
+struct __attribute__((packed, aligned(1))) DistancesFrame {
+        uint8_t source;
+        uint8_t destination;
+        uint8_t type;
+        float dist[4];
+    };
+    
+DW1000 dw(PN_SPI_MOSI, PN_SPI_MISO, PN_SPI_CLK, DW1000_CS, DW1000_IRQ, DW1000_RST);   // Device driver instanceSPI pins: (MOSI, MISO, SCLK, CS, IRQ)
+//DW1000 dw(&spi,DW_irq,DW1000_CS,DW1000_RST);
+MM2WayRanging node(dw);
+
+void uwbScan() {
+    
+}
+
+//------------------------------------------------------------------------------
+// ACC
+//------------------------------------------------------------------------------ 
+void acc_configForMotionInt() {
+    acc.setMode(LOW_POWER);
+    acc.enableAxes(X_axis);
+    acc.enableAxes(Y_axis);
+    acc.enableAxes(Z_axis);    
+    acc.setODR(ODR_1Hz);
+    acc.setScale(_8g);
+    acc.int1Setup(0b01000000);       // IntActivity 1 driven to INT1 pad
+    //acc.setCTRL_REG2(0b11001011);  //High pass filter active
+    acc.setCTRL_REG2(0b00000000);    //High pass filter off
+    acc.int1Latch(0b00000000);       //Dont latch
+    acc.int1Threshold(7);
+    acc.int1Duration(0x00);  
+    acc.int1Config(0b01111111);     // INT2_CFG Enable XHigh, YHigh and ZHigh, triggers INT1 on any motion
+    acc.clearIntFlag(); //reset int1 
+}
+
+void acc_updateOrientation() {
+    //Divide by 16 to get range of +- 16 on each axis
+    RET_accX = (acc.readXAxis() / 16);
+    RET_accY = (acc.readYAxis() / 16);
+    RET_accZ = (acc.readZAxis() / 16);
 }
 
 //------------------------------------------------------------------------------
 // STATE ENGINE
 //------------------------------------------------------------------------------ 
 void mainStateEngine() {
-    if(debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "MainStateEngine");debug_exe();}
+    if(RET_debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "MainStateEngine");debug_exe();}
     
     if (EVENT_buttonPress) {
-        if(debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_ButtonPress");debug_exe();}
+        if(RET_debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_ButtonPress");debug_exe();}
         EVENT_buttonClear_time = (RET_RTCunixtime + EVENT_buttonClear_interval);
         RET_setting_beacon_interval_ms_active = DEFAULT_BEACON_INTERVAL_FAST_MS;
         RET_BLEpacketUpdate = true;
@@ -470,60 +549,68 @@
     }
     
     if (EVENT_motionClear) {
-        if(debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_MotionClear");debug_exe();}
+        if(RET_debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_MotionClear");debug_exe();}
         EVENT_motionClear_time = 0;
+        EVENT_motionClear = false;
         RET_motionState = false;
         RET_impactState = false;
+        acc_updateOrientation(); //update orientation data
         RET_BLEpacketUpdate = true;
-        EVENT_motionClear = false;
     }
     
     if (EVENT_buttonClear) {
-        if(debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_ButtonClear");debug_exe();}
+        if(RET_debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_ButtonClear");debug_exe();}
         EVENT_buttonClear_time = 0;
+        EVENT_buttonClear = false;
         RET_buttonPressed = false;
         RET_buttonPressCount = 0;
         RET_setting_beacon_interval_ms_active = RET_setting_beacon_interval_ms; //reset back to normal broadcast rate
         RET_BLEpacketUpdate = true;
-        EVENT_buttonClear = false;
     }
     
     if (EVENT_battery) {
-        if(debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_Battery");debug_exe();}
+        if(RET_debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_Battery");debug_exe();}
         EVENT_battery_time = (RET_RTCunixtime + EVENT_battery_interval);
+        EVENT_battery = false;
         updateBatteryV();
         RET_BLEpacketUpdate = true;
-        EVENT_battery = false;
     }
     
     if (EVENT_temperature) {
-        if(debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_Temperature");debug_exe();}
+        if(RET_debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_Temperature");debug_exe();}
         EVENT_temperature_time = (RET_RTCunixtime + EVENT_temperature_interval);
-        RET_BLEpacketUpdate = true;
         EVENT_temperature = false;
         //get temperature TODO - only update ble if different to last
+        RET_BLEpacketUpdate = true;
     }
     
     if (EVENT_humidity) {
-        if(debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_Humidity");debug_exe();}
+        if(RET_debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_Humidity");debug_exe();}
         EVENT_humidity_time = (RET_RTCunixtime + EVENT_humidity_interval);
-        RET_BLEpacketUpdate = true;
         EVENT_humidity = false;
         //get humidity TODO - only update ble if different to last
+        RET_BLEpacketUpdate = true;
     }
     
     if (EVENT_settingsScan) {
-        if(debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_SettingsScan");debug_exe();}
+        if(RET_debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_SettingsScan");debug_exe();}
         EVENT_settingsScan_time = (RET_RTCunixtime + EVENT_settingsScan_interval);
         EVENT_settingsScan = false;
         settingsScan();
     }
     
     if (EVENT_uwbScan) {
-        if(debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_uwbScan");debug_exe();}
+        if(RET_debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_uwbScan");debug_exe();}
         EVENT_uwbScan_time = (RET_RTCunixtime + EVENT_uwbScan_interval);
         EVENT_uwbScan = false;
     }
+    
+    /*if (EVENT_resetACCInt) {
+        if(RET_debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "EVENT_resetACCInt1");debug_exe();}
+        EVENT_resetACCInt_time = 0;
+        EVENT_resetACCInt = false;
+        acc.clearIntFlag();
+    }*/
         
     //BLE START OR UPDATE
     if (RET_bleBroadcasting == false) {
@@ -535,13 +622,15 @@
     }
     if (RET_BLEpacketUpdate == true) {
         if(RET_debug) {debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer), "BLE Update only");debug_exe();}
-        bleUpdateAndAdvertise();
-    }    
+        bleUpdateAndAdvertise(); //this function also sets RET_BLEpacketUpdate = false
+    }
     
     //END
     RET_haveEventsToRun = false;
 }
 
+
+
 //------------------------------------------------------------------------------
 // MAIN
 //------------------------------------------------------------------------------ 
@@ -554,13 +643,32 @@
     LPtimer.start();
     button.fall(&buttonPress);
     button.rise(&buttonRelease);
+    accInt1.rise(&accInt1ISR);
     //read_app_data_from_flash(&app_data);
+    acc_configForMotionInt();
     firstRun();
+    debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer),"Ready\n");debug_exe();
     
     //MAIN LOOP
     while(true) {
         RET_asleep = false;
-        LED1on(20);
+        //LED2on(30);
+        
+        
+        while(1) {
+            debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer),"UWB SCAN START\n");debug_exe();
+            uwbScan();
+            debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer),"UWB SCAN END\n");debug_exe();
+            nrf_configureForSleep();
+            ThisThread::sleep_for(1000);
+        }
+        
+        
+        while(1) {
+            acc_updateOrientation();
+            debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer),"X:%d    Y:%d   D:%d\n",RET_accX,RET_accY,RET_accZ);debug_exe();
+            ThisThread::sleep_for(20);
+        }
         
         //STATE ENGINE
         mainStateEngine();
@@ -573,6 +681,7 @@
         
         //DEBUGGING OFF TIMER
         if(RET_debug){
+            debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer),"TIME:%d\n",RET_RTCunixtime);debug_exe();
             if (RET_RTCunixtime > RET_debug_offat) {
                 debug_prep();snprintf(GLOBAL_debug_buffer, sizeof(GLOBAL_debug_buffer),"DEBUGGING OFF\n");debug_exe();
                 RET_debug = false;
@@ -580,13 +689,13 @@
         }
                 
         //PRE-SLEEP ACTIONS
-        //if (GLOBAL_needToConfigureLis3dh) { lis3dh_configureForSleep(RET_setting_motion_g,RET_setting_impact_g); }
+        acc_configForMotionInt();
         watchdogKick();
         //SLEEP
         nrf_configureForSleep();
         NRFuart_uninit();
         RET_asleep = true;
-        LED1off();
+        //LED1off();
         mainthread.wait(DEFAULT_SLEEP_FRAME);
     }
 }
\ No newline at end of file

diff -r 066dfbe8b4b9 -r 8d4a354816b1 main.h
--- a/main.h	Thu Feb 13 00:57:06 2020 +0000
+++ b/main.h	Mon Feb 17 23:24:52 2020 +0000
@@ -24,7 +24,7 @@
 #define USE_NRF_TEMP_SENSOR                 false
 
 //DEFAULT VELUES
-#define DEFAULT_SLEEP_FRAME                 120000
+#define DEFAULT_SLEEP_FRAME                 360000 // 6 mins
 #define DEFAULT_MOTION_G                    7
 #define DEFAULT_MOTION_START_SECONDS        120
 #define DEFAULT_MOTION_STOP_SECONDS         120
@@ -41,16 +41,15 @@
 #define TENDAYSINSECONDS                    864000
 
 //DEFAULT EVENT TIMES IN SECONDS
-#define DEFAULT_INTERVAL_MOTIONCLEAR        120
+#define DEFAULT_INTERVAL_MOTIONCLEAR        60
+#define DEFAULT_INTERVAL_RESETACCINT        10
 #define DEFAULT_INTERVAL_BUTTONCLEAR        20
 #define DEFAULT_INTERVAL_BATTERY            ONEDAYINSECONDS
 #define DEFAULT_INTERVAL_TEMPERATURE        60
 #define DEFAULT_INTERVAL_HUMIDITY           120
-#define DEFAULT_INTERVAL_SETTINGSSCAN       60
-
+#define DEFAULT_INTERVAL_SETTINGSSCAN       0
 
 //DEFINES
-#define ACTIVITY_BUFFERSIZE                 100
 #define DEBUG_BUFFERSIZE                    200
 
 //------------------------------------------------------------------------------
@@ -66,13 +65,16 @@
 //------------------------------------------------------------------------------
 #include "WatchdogTimer.h"
 #include "acd_nrf52_saadc.h"
+#include "DW1000.h"
+#include "MM2WayRanging.h"
+#include "Lis2dh12.h"
+#include "Lis2dh12_regs.h"
 
 //------------------------------------------------------------------------------
 //Application headers
 //------------------------------------------------------------------------------
 #include "NRFuart.h"
 #include "app_data.h"
-#include "states.h"
 #include "LED.h"
 
 //BLE SERVICE IDS
@@ -91,10 +93,8 @@
 
 extern bool GLOBAL_accel_healthy;
 extern bool GLOBAL_requireSoftReset;
-extern bool GLOBAL_motionFlagTriggered;
 extern bool GLOBAL_debugLED;
 extern bool GLOBAL_needToConfigureLis3dh;
-extern bool GLOBAL_LEDSequenceinProgress;
 extern time_t GLOBAL_RTCunixtime;
 extern char GLOBAL_debug_buffer[DEBUG_BUFFERSIZE];
 //FUNCS

diff -r 066dfbe8b4b9 -r 8d4a354816b1 states.h
--- a/states.h	Thu Feb 13 00:57:06 2020 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,7 +0,0 @@
-#define STATE_SETUP              0
-#define STATE_NORMAL             1
-#define STATE_LAUNCH             2
-#define STATE_ALARM              4
-#define STATE_BUTTONPRESS1       81
-#define STATE_BUTTONPRESS3       82
-#define STATE_SCORCHEDEARTH      90
\ No newline at end of file