Introduce a track id, unique for all consuming systems. (#187 / #183)

amandel · web-flow · commit 68128e18004f · 2020-12-28T19:47:07.000+01:00
* Add all bin file distribution * Create UUID as TrackId and pass on to consumers fixes #183 * Remove some BLE metadata
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -82,6 +82,12 @@ jobs:
       run: |
         zip --junk-paths obs-${{ env.OBS_VERSION }}.zip \
           bin/.pio/build/esp32dev/firmware.bin
+        cp /github/home/.platformio/packages/framework-arduinoespressif32/tools/sdk/bin/bootloader_dio_40m.bin 0x01000.bin
+        cp bin/.pio/build/esp32dev/partitions.bin 0x08000.bin
+        cp /github/home/.platformio/packages/framework-arduinoespressif32/tools/partitions/boot_app0.bin 0x0e000.bin
+        cp bin/.pio/build/esp32dev/firmware.bin 0x10000.bin
+        zip --junk-paths obs-${{ env.OBS_VERSION }}-full-flash.zip \
+          0x*.bin
 
     - name: Analyze with SonarCloud
       env:
@@ -115,6 +121,14 @@ jobs:
           bin/.pio/build/esp32dev/firmware.bin
         if-no-files-found: error
 
+    - name: Upload Build Asset Full Flash
+      uses: actions/upload-artifact@v2
+      with:
+        name: obs ${{ env.OBS_VERSION }} full flash
+        path: |
+          0x*.bin
+        if-no-files-found: error
+
     - name: Generate changelog
       id: changelog
       if: ${{ env.OBS_PREPARE_RELEASE == 'true' }}
@@ -161,3 +175,15 @@ jobs:
         asset_path: ./obs-${{ env.OBS_VERSION }}.zip
         asset_name: obs-${{ env.OBS_VERSION }}.zip
         asset_content_type: application/zip
+
+    - name: Upload Release Asset Full Flash
+      id: upload-release-asset-full-flash
+      if: ${{ env.OBS_PREPARE_RELEASE == 'true' }}
+      uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }}
+        asset_path: ./obs-${{ env.OBS_VERSION }}-full-flash.zip
+        asset_name: obs-${{ env.OBS_VERSION }}-full-flash.zip
+        asset_content_type: application/zip
diff --git a/custom_config.ini.example b/custom_config.ini.example
@@ -16,3 +16,23 @@
 ; === build_flags ===
 ; build with development option
 ; build_flags = -D DEVELOP
+
+;;;; Loglevel for debugging ;;;;
+
+; None
+;build_flags = -DCORE_DEBUG_LEVEL=0
+
+; Error
+;build_flags = -DCORE_DEBUG_LEVEL=1
+
+; Warn
+;build_flags = -DCORE_DEBUG_LEVEL=2
+
+; Info
+;build_flags = -DCORE_DEBUG_LEVEL=3
+
+; Debug
+;build_flags = -DCORE_DEBUG_LEVEL=4
+
+; Verbose
+;build_flags = -DCORE_DEBUG_LEVEL=5
diff --git a/docs/software/firmware/bluetooth_services.md b/docs/software/firmware/bluetooth_services.md
@@ -94,6 +94,7 @@ The following events are defined:
 | Sensor Distance     | `1FE7FAF9-CE63-4236-0004-000000000002` | `NOTIFY`        | Gives sensor reading of the left and right sensor.                                  |
 | Close Pass          | `1FE7FAF9-CE63-4236-0004-000000000003` | `NOTIFY`        | Notifies of button confirmed close pass events.                                     |
 | Offset              | `1FE7FAF9-CE63-4236-0004-000000000004` | `READ`          | Configured handle bar offset values in cm.                                          |
+| Track Id            | `1FE7FAF9-CE63-4236-0004-000000000005` | `READ`          | UUID as text to uniquely identify the current recorded track.                       |
 
 This service uses binary format to transfer time counter as unit32 and unt16
 for distance in cm. 
@@ -116,3 +117,7 @@ to match the event to the correct time and so location.
 is purely to ease the user configuration. The offset is not considered in any 
 of the other reported values. The service uses 2 uint16 values to report the
 left and right offset in cm in that order.
+
+*Tack Id* holds a UUID as String representation that can be used to uniquely
+identify the recorded track. If the value changes, a new track is recorded, and
+the millisecond counter on the OBS likely is restarted. 
diff --git a/docs/software/firmware/csv_format.md b/docs/software/firmware/csv_format.md
@@ -38,6 +38,7 @@ understand.
 | `DeviceId` | `affe` | internal Id of the OBS |
 | `PresetId` | `Wade` | Id to identify the selected preset. A owner might define multiple presets |
 | `BluetoothEnabled` | `1` | 1 if bluetooth is enabled, 0 otherwise
+| `TrackId` | `38605ba-76...` | A uuid that can be used to uniquely identify the track.
 
 ## CSV
 
diff --git a/docs/software/firmware/flashtool.png b/docs/software/firmware/flashtool.png
diff --git a/docs/software/firmware/initial_flash.md b/docs/software/firmware/initial_flash.md
@@ -0,0 +1,92 @@
+# Initial ESP flashing
+
+You can always use an IDE setup to flash the ESP but if you simply 
+want to start using the OBS this way might be more straight forward. 
+
+As of today, this thing is foe Windows only.
+
+Other than for the next updates that you can do over the air using 
+the small release package, you need the "full flash" zip file, and 
+the _Flash Download Tools_ from
+[ESPRESSIF](https://www.espressif.com/en/support/download/other-tools?keys=&field_type_tid%5B%5D=13)
+
+## Preparation
+
+Download the latest release archive from 
+[OpenBikeSensorFirmware at GITHub](https://github.com/openbikesensor/OpenBikeSensorFirmware/releases). 
+You need the larger ZIP file named `obs-v9.9.9999-full-flash.zip`.
+Extract the files in a temporary folder, they are named like 
+0x??????.bin. The numbers are the base address where the data should 
+be flashed. Don`t worry this will make sense in the next steps.
+
+Please download _Flash Download Tools (ESP8266 & ESP32 & ESP32-S2)_ from
+[ESPRESSIF](https://www.espressif.com/en/support/download/other-tools?keys=&field_type_tid%5B%5D=13)
+and extract the tool also in a dedicated temporary folder. There
+will be no install step, the tool is started directly in the folder.
+
+Remove USB devices from your computer, that you do not need right now.
+They can be confused during the selection of the right device to be
+flashed.
+
+## Steps
+
+Connect ESP via USB (checkme - driver needed?). Windows should
+confirm that a new device was detected. 
+
+Start `flash_download_tool_3.X.X.exe`, in the folder of the _Flash 
+Download Tool_. Give it some time to start. It will open a console 
+window 1st and eventually a simple UI. 
+
+Choose `Developer Mode` - `ESP32 DownloadTool` in the UI. The 
+`Factory Mode` can be used if you need to flash a whole batch of 
+ESPs. In that case you can also connect multiple ESPs at the same 
+time.
+
+Now we need to tell the tool what needs to be flashed. At the
+top of the dialog you now see several lines starting, with 
+checkboxes, a textarea, 3 dots an `@` sign and one more
+text ara.
+
+For each of the 4 files we need to flash, select the 3 dots which
+will bring up a file selector where you need to choose one of
+the 4 *.bin files. The order is not important, but you need to 
+enter the _address_ of the file in the 2nd text field. The _address_ 
+is the same as the filename `0x10000` for example. The boxes get
+a green background confirming a positive sanity check of the flash 
+tool.
+
+Now select the checkboxes in front of the entries you just made.
+
+All other values stay with the default:
+`SPI SPEED` : `40MHz`, `SPI MODE` : `DIO` (This one will change 
+automatically in a moment), `FLASH SIZE` : `32Mbit` and finally
+`SpiAutoSet` : `selected`, `DoNotChgBin` : `not selected`.
+
+On the button you see a drop-down box `COM:` here you have to 
+select the correct com post for the flash process. If unsure
+leave the default and try a different value if the process 
+fails. Make sure you have no other devices connected!
+
+Press: "START".
+
+You should see something like this now:
+![Flashing in progress](flashtool.png)
+
+If all goes correct, you should see a progress bar with final 
+success message. Unplug the USB cable. The ESP is then ready 
+to be placed inside the OBS housing (if not done already).
+Thanks to OTA Update you should not need to update this way
+anymore.
+
+If you get some _red_ error feedback, check that the USB 
+connection is correct and that the right COM port was selected.
+If all fails, use the OBS Slack to get some help.
+Currently, there is not much troubleshooting info collected, 
+but this will change.
+
+
+## Licenses
+
+https://docs.espressif.com/projects/esp-idf/en/latest/esp32/COPYRIGHT.html
+
+TODO
diff --git a/src/OpenBikeSensorFirmware.cpp b/src/OpenBikeSensorFirmware.cpp
@@ -18,6 +18,7 @@
   the OpenBikeSensor sensor firmware.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <utils/obsutils.h>
 #include "OpenBikeSensorFirmware.h"
 
 #include "SPIFFS.h"
@@ -203,7 +204,7 @@ void setup() {
       displayTest->showTextOnGrid(2, 2, "SD... error",DEFAULT_FONT);
       if (config.simRaMode || digitalRead(PushButton_PIN) == HIGH) {
         break;
-      }
+      }  // FIXME: Stop trying!!?
     }
     Serial.println("Card Mount Failed");
     //delay(100);
@@ -267,10 +268,12 @@ void setup() {
 
   displayTest->showTextOnGrid(2, 3, "CSV file...",DEFAULT_FONT);
 
+  const String trackUniqueIdentifier = ObsUtils::createTrackUuid();
+
   if (SD.begin()) {
     writer = new CSVFileWriter;
     writer->setFileName();
-    writer->writeHeader();
+    writer->writeHeader(trackUniqueIdentifier);
     displayTest->showTextOnGrid(2, 3, "CSV file... ok",DEFAULT_FONT);
     Serial.println("File initialised");
   } else {
@@ -307,7 +310,8 @@ void setup() {
       cfg.getProperty<String>(ObsConfig::PROPERTY_OBS_NAME),
       config.sensorOffsets[LEFT_SENSOR_ID],
       config.sensorOffsets[RIGHT_SENSOR_ID],
-      batteryPercentage);
+      batteryPercentage,
+      trackUniqueIdentifier);
     bluetoothManager->activateBluetooth();
   } else {
     bluetoothManager = nullptr;
diff --git a/src/OpenBikeSensorFirmware.h b/src/OpenBikeSensorFirmware.h
@@ -18,8 +18,6 @@
 #include <Adafruit_BMP280.h>
 #include <VL53L0X.h>
 
-#ifdef BLUETOOTH_ACTIVATED
 #include "bluetooth/BluetoothManager.h"
-#endif
 
 #endif
diff --git a/src/bluetooth/BluetoothManager.cpp b/src/bluetooth/BluetoothManager.cpp
@@ -3,7 +3,8 @@
 void BluetoothManager::init(
   const String &obsName,
   const uint16_t leftOffset, const uint16_t rightOffset,
-  std::function<uint8_t()> batteryPercentage) {
+  std::function<uint8_t()> batteryPercentage,
+  const String &trackId) {
 
   ESP_ERROR_CHECK_WITHOUT_ABORT(
     esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));
@@ -17,7 +18,7 @@ void BluetoothManager::init(
   services.push_back(new DistanceService);
   services.push_back(new ConnectionService);
   services.push_back(new ClosePassService);
-  services.push_back(new ObsService(leftOffset, rightOffset));
+  services.push_back(new ObsService(leftOffset, rightOffset, trackId));
 
   for (auto &service : services) {
     service->setup(pServer);
@@ -45,12 +46,6 @@ void BluetoothManager::disconnectDevice() const {
 }
 
 void BluetoothManager::newSensorValues(const uint32_t millis, const uint16_t leftValues, const uint16_t rightValues) {
-  // Discarding values if they are more recent than 50 ms
-  if (millis - lastValueTimestamp < 50) {
-    return;
-  }
-  lastValueTimestamp = millis;
-
   for (auto &service : services) {
     service->newSensorValues(millis, leftValues, rightValues);
   }
diff --git a/src/bluetooth/BluetoothManager.h b/src/bluetooth/BluetoothManager.h
@@ -23,7 +23,8 @@ class BluetoothManager {
      */
     void init(const String &obsName,
               uint16_t leftOffset, uint16_t rightOffset,
-              std::function<uint8_t()> batteryPercentage);
+              std::function<uint8_t()> batteryPercentage,
+              const String &trackId);
 
     /**
      * Starts advertising all services that internally implement shouldAdvertise()
diff --git a/src/bluetooth/HeartRateService.cpp b/src/bluetooth/HeartRateService.cpp
@@ -2,13 +2,13 @@
 
 const unsigned long measurementInterval = 1000;
 
-const BLEUUID HeartRateService::SERVICE_UUID = BLEUUID((uint16_t)0x180d);
+const BLEUUID HeartRateService::SERVICE_UUID = BLEUUID((uint16_t)ESP_GATT_UUID_HEART_RATE_SVC);
 const char * HeartRateService::DESCRIPTION_TEXT =
   "Minimum left sensor distance during the last second in cm. "
   "Range 0cm to 999cm. 999 means infinity.";
 
 void HeartRateService::setup(BLEServer *pServer) {
-  mService = pServer->createService(SERVICE_UUID);
+  mService = pServer->createService(SERVICE_UUID, 5);
   mService->addCharacteristic(&mHeartRateMeasurementCharacteristics);
   mHeartRateDescriptor.setValue(DESCRIPTION_TEXT);
   mHeartRateDescriptor.setAccessPermissions(ESP_GATT_PERM_READ);
diff --git a/src/bluetooth/HeartRateService.h b/src/bluetooth/HeartRateService.h
@@ -13,9 +13,9 @@ class HeartRateService : public IBluetoothService {
   private:
     BLEService *mService = nullptr;
     BLECharacteristic mHeartRateMeasurementCharacteristics
-      = BLECharacteristic(BLEUUID((uint16_t)0x2A37), BLECharacteristic::PROPERTY_NOTIFY);
+      = BLECharacteristic(BLEUUID((uint16_t)ESP_GATT_HEART_RATE_MEAS), BLECharacteristic::PROPERTY_NOTIFY);
     BLEDescriptor mHeartRateDescriptor
-      = BLEDescriptor(BLEUUID((uint16_t)0x2901));
+      = BLEDescriptor(BLEUUID((uint16_t)ESP_GATT_UUID_CHAR_DESCRIPTION));
     unsigned long mCollectionStartTime = 0;
     uint16_t mMinimumDistance = MAX_SENSOR_VALUE;
     uint8_t mValue[4];
diff --git a/src/bluetooth/ObsService.cpp b/src/bluetooth/ObsService.cpp
@@ -26,19 +26,26 @@ const std::string ObsService::BUTTON_DESCRIPTION_TEXT(
   "Confirmed pass event: ms time uint32; left cm uint16; right cm uint16; 0xffff = no reading");
 const std::string ObsService::OFFSET_DESCRIPTION_TEXT(
   "Configured OBS offsets, left offset cm uint16, right offset cm uint16");
+const std::string ObsService::TRACK_ID_DESCRIPTION_TEXT(
+  "Textual UUID assigned to the current track recording");
 const BLEUUID ObsService::OBS_SERVICE_UUID = BLEUUID("1FE7FAF9-CE63-4236-0004-000000000000");
 const BLEUUID ObsService::OBS_TIME_CHARACTERISTIC_UUID = BLEUUID("1FE7FAF9-CE63-4236-0004-000000000001");
 const BLEUUID ObsService::OBS_DISTANCE_CHARACTERISTIC_UUID = BLEUUID("1FE7FAF9-CE63-4236-0004-000000000002");
 const BLEUUID ObsService::OBS_BUTTON_CHARACTERISTIC_UUID = BLEUUID("1FE7FAF9-CE63-4236-0004-000000000003");
 const BLEUUID ObsService::OBS_OFFSET_CHARACTERISTIC_UUID = BLEUUID("1FE7FAF9-CE63-4236-0004-000000000004");
-
-ObsService::ObsService(const uint16_t leftOffset, const uint16_t rightOffset) {
-  *(uint16_t*) mOffsetValue = leftOffset;
-  *(uint16_t*) &mOffsetValue[2] = rightOffset;
+const BLEUUID ObsService::OBS_TRACK_ID_CHARACTERISTIC_UUID = BLEUUID("1FE7FAF9-CE63-4236-0004-000000000005");
+
+ObsService::ObsService(const uint16_t leftOffset, const uint16_t rightOffset, const String &trackId) {
+  uint8_t offsets[4];
+  memcpy(offsets, &leftOffset, 2);
+  memcpy(&offsets[2], &rightOffset, 2);
+  mOffsetCharacteristic.setValue(offsets, 4);
+  mTrackIdCharacteristic.setValue(trackId.c_str());
 }
 
 void ObsService::setup(BLEServer *pServer) {
-  mService = pServer->createService(OBS_SERVICE_UUID);
+  // Each characteristic needs 2 handles and descriptor 1 handle.
+  mService = pServer->createService(OBS_SERVICE_UUID, 18);
 
   mService->addCharacteristic(&mTimeCharacteristic);
   mTimeCharacteristic.addDescriptor(&mTimeDescriptor);
@@ -59,7 +66,9 @@ void ObsService::setup(BLEServer *pServer) {
   mOffsetCharacteristic.addDescriptor(&mOffsetDescriptor);
   mOffsetDescriptor.setValue(OFFSET_DESCRIPTION_TEXT);
 
-  mOffsetCharacteristic.setValue(mOffsetValue, 4);
+  mService->addCharacteristic(&mTrackIdCharacteristic);
+  mTrackIdCharacteristic.addDescriptor(&mTrackIdDescriptor);
+  mTrackIdDescriptor.setValue(TRACK_ID_DESCRIPTION_TEXT);
 }
 
 bool ObsService::shouldAdvertise() {
@@ -71,22 +80,29 @@ BLEService* ObsService::getService() {
 }
 
 void ObsService::newSensorValues(uint32_t millis, uint16_t leftValue, uint16_t rightValue) {
-  *(uint32_t*) mDistanceValue = millis;
-  *(uint16_t*) &mDistanceValue[4] = leftValue == MAX_SENSOR_VALUE ? 0xffff : leftValue;
-  *(uint16_t*) &mDistanceValue[6] = rightValue == MAX_SENSOR_VALUE ? 0xffff : rightValue;
-  mDistanceCharacteristic.setValue(mDistanceValue, 8);
-  mDistanceCharacteristic.notify();
+  sendEventData(&mDistanceCharacteristic, millis, leftValue, rightValue);
 }
 
 void ObsService::newPassEvent(uint32_t millis, uint16_t leftValue, uint16_t rightValue) {
-  *(uint32_t*) mButtonValue = millis;
-  *(uint16_t*) &mButtonValue[4] = leftValue == MAX_SENSOR_VALUE ? 0xffff : leftValue;
-  *(uint16_t*) &mButtonValue[6] = rightValue == MAX_SENSOR_VALUE ? 0xffff : rightValue;
-  mButtonCharacteristic.setValue(mButtonValue, 8);
-  mButtonCharacteristic.notify();
+  sendEventData(&mButtonCharacteristic, millis, leftValue, rightValue);
 }
 
 void ObsTimeServiceCallback::onRead(BLECharacteristic *pCharacteristic) {
-  *mValue = millis();
-  pCharacteristic->setValue(*mValue);
-}
+  uint32_t value = millis();
+  pCharacteristic->setValue(value);
+}
+
+void ObsService::sendEventData(BLECharacteristic *characteristic, uint32_t millis, uint16_t leftValue, uint16_t rightValue) {
+  uint8_t event[8];
+  memcpy(event, &millis, sizeof(millis));
+  if (leftValue == MAX_SENSOR_VALUE) {
+    leftValue = 0xffff;
+  }
+  memcpy(&event[4], &leftValue, sizeof(leftValue));
+  if (rightValue == MAX_SENSOR_VALUE) {
+    rightValue = 0xffff;
+  }
+  memcpy(&event[6], &rightValue, sizeof(rightValue));
+  characteristic->setValue(event, 8);
+  characteristic->notify();
+}
diff --git a/src/bluetooth/ObsService.h b/src/bluetooth/ObsService.h
diff --git a/src/utils/obsutils.cpp b/src/utils/obsutils.cpp
diff --git a/src/utils/obsutils.h b/src/utils/obsutils.h
diff --git a/src/writer.cpp b/src/writer.cpp
diff --git a/src/writer.h b/src/writer.h
