ESP32 Byte Order

[donsay]

Hi All.

I'm working on a TLM beacon with nimble 2.36. I'm not sure if the following are bugs or I just missed something.

• It seems the byte order for the AdvCount and Volt properties are reversed.
• If the temperature is negative, the Temperature property is 1 degree higher than what was set in setTemp(). For example, if the value passed to setTemp is -15, the value in the TLM beacon is -14. If the temperature is positive, the value in the beacon is correct.

My hardware is an ESP32-C6 in the Arduino IDE.

Thanks.
Don

[h2zero]

The TLM class follows the specification for byte order, which is reversed in most cases. Not sure about the temperature issue, can you share the code?

[donsay]

Hi.

Thanks for the reply. My code is basically the sample TLM project, with a few modifications.

// NIMBLE project is here
// https://github.com/h2zero/NimBLE-Arduino/tree/master/src

#include <Arduino.h>
#include <NimBLEDevice.h>
#include <NimBLEEddystoneTLM.h>
#include <sys/time.h>
#include <esp_sleep.h>

#define GPIO_DEEP_SLEEP_DURATION 10 // sleep x seconds and then wake up
#define BEACON_POWER             3  // 3dbm

RTC_DATA_ATTR static time_t   last;      // remember last boot in RTC Memory
RTC_DATA_ATTR static uint32_t bootcount; // remember number of boots in RTC Memory
NimBLEAdvertising*            pAdvertising;
struct timeval                nowTimeStruct;

#define BEACON_UUID \
    "8ec76ea3-6668-48da-9866-75be8bc86f4d" // UUID 1 128-Bit (may use linux tool uuidgen or random numbers via https://www.uuidgenerator.net/)

// Check
// https://github.com/google/eddystone/blob/master/eddystone-tlm/tlm-plain.md
// and http://www.hugi.scene.org/online/coding/hugi%2015%20-%20cmtadfix.htm
// for the temperature value. It is a 8.8 fixed-point notation
void setBeacon()
{
    // for monitoring GPIO inputs 
    int SensorStatus = 0;
    
    // volts is specified in thousands of millivolts, 3300mV = 3.3V
    uint16_t rndVolts = random(2800, 3700);
    Serial.printf("Random Battery voltage is %d 0x%04X mV\n", rndVolts, rndVolts);
    Serial.printf("Sensor data is %d\n", SensorStatus);
    
    // use the lower four bits of the voltage for some GPIO inputs
    uint16_t mixedData = (rndVolts << 4) | SensorStatus;
    Serial.printf("Mixed Data is %d => 0x%08X mV\n", mixedData, mixedData);

    NimBLEEddystoneTLM eddystoneTLM;
  
    // increment the count and reverse the byte order for advCount
    bootcount++;
    uint32_t advCount = 0;
    byte b1 = (bootcount & 0xFF000000) > 24;
    byte b2 = (bootcount & 0x00FF0000) > 16;
    byte b3 = (bootcount & 0x0000FF00) > 8;
    byte b4 = (bootcount & 0x000000FF);
   
    advCount = b1 | (b2 << 8) | (b3 << 16) | (b4 << 24);
    eddystoneTLM.setCount(advCount);
 
    // voltage byte order backwards...
    byte lb = (byte)((mixedData & 0xFF00) >> 8);
    byte hb = (byte)(mixedData  & 0x00FF);
    uint16_t mdata = (hb << 8) | lb;
    
    // set the TLM battery voltage
    eddystoneTLM.setVolt(mdata);

    // generate an arbitrary temperature for testing
    int16_t temp = random(-3000, 3000);
    float t = (float)temp / 100.0;
    
    // round it and ignore the fractional part
    int8_t w = (int8_t)round(t) ;
    uint8_t f = 0.0;

    // the NIMBLE library seems to add 1 to the value if it's negative,
    // so compensate for it here
    if (t<0)
    {
        w = w-1;
    }
    
    // just some debug...
    Serial.printf("Random Temperature is: %d => %.2f\n", temp, t);
    Serial.printf("Rounded temperature: %d\n", w);
            
    // make a fixed format integer temperature value for NIMBLE
    int16_t fixedtemp = 0.0;
    fixedtemp = fixedtemp | w;
    
    // set the TLM temperature
    eddystoneTLM.setTemp(fixedtemp);
    
    // just some debug...
    Serial.printf("Extracted Battery voltage is %d mV = 0x%04X\n", (mixedData & 0xFFF0) >> 4, (mixedData & 0xFFF0) >> 4);
    Serial.printf("Extracted Sensor data is %d\n", mixedData & 0x000F);
    
    NimBLEAdvertisementData        oAdvertisementData = BLEAdvertisementData();
    NimBLEAdvertisementData        oScanResponseData  = BLEAdvertisementData();
    NimBLEEddystoneTLM::BeaconData beaconData         = eddystoneTLM.getData();
    oScanResponseData.setServiceData(NimBLEUUID("FEAA"),
                                     reinterpret_cast<const uint8_t*>(&beaconData),
                                     sizeof(NimBLEEddystoneTLM::BeaconData));

    oAdvertisementData.addTxPower();
    oAdvertisementData.setShortName("ESPTest");
    oAdvertisementData.setName("ESP32TlmBeacon");
    pAdvertising->setAdvertisementData(oAdvertisementData);
    pAdvertising->setScanResponseData(oScanResponseData);
}

void setup()
{
    pinMode(0, INPUT);
    pinMode(1, INPUT);
    pinMode(2, INPUT);
    pinMode(3, INPUT);

    Serial.begin(115200);
    gettimeofday(&nowTimeStruct, NULL);

    Serial.printf("Starting ESP32. Bootcount = %lu\n", bootcount);
    Serial.printf("Deep sleep (%llds since last reset, %llds since last boot)\n",
                  nowTimeStruct.tv_sec,
                  nowTimeStruct.tv_sec - last);
    last = nowTimeStruct.tv_sec;

    if (bootcount == 0xFFFFFFFF)
    {
        bootcount = 1;
    } 

    NimBLEDevice::init("TLMBeacon");
    NimBLEDevice::setPower(BEACON_POWER, NimBLETxPowerType::Advertise);

    pAdvertising = NimBLEDevice::getAdvertising();
    setBeacon();
    pAdvertising->start();
    Serial.println("Advertising started for 10s ...");
    delay(10000);
    pAdvertising->stop();
    Serial.printf("Enter deep sleep for 10s\n");
    esp_deep_sleep(1000000LL * GPIO_DEEP_SLEEP_DURATION);
}

void loop() {}