demo for tak offsite

faradaym · faradaym · commit c7e9ec969fd0 · 2025-08-13T17:08:53.000-05:00
Signed-off-by: faradaym &lt;rcheyenne.truss@gmail.com&gt;
diff --git a/examples/Basic-Ducks/MamaDuck/MamaDuck.ino b/examples/Basic-Ducks/MamaDuck/MamaDuck.ino
@@ -8,13 +8,26 @@
 #include <arduino-timer.h>
 #include <CDP.h>
 
+// GPS Setup
+#include <TinyGPS++.h>
+TinyGPSPlus tgps;
+HardwareSerial GPS(1);
+
+// // Setup BMP180
+// #include <Adafruit_BMP085_U.h>
+// Adafruit_BMP085_Unified bmp = Adafruit_BMP085_Unified(10085);
+
 #ifdef SERIAL_PORT_USBVIRTUAL
 #define Serial SERIAL_PORT_USBVIRTUAL
 #endif
 
 bool sendData(std::vector<byte> message);
 bool runSensor(void *);
 
+static void smartDelay(unsigned long ms);
+String getGPSData();
+// String getBMPData();
+
 // create a built-in mama duck
 MamaDuck duck;
 
@@ -26,6 +39,19 @@ const int INTERVAL_MS = 60000;
 int counter = 1;
 bool setupOK = false;
 
+std::string arduinoStringFromHex(byte* data, int size) 
+{
+  std::string buf = "";
+  buf.reserve(size * 2); // 2 digit hex
+  const char* cs = "0123456789ABCDEF";
+  for (int i = 0; i < size; i++) {
+    byte val = data[i];
+    buf += cs[(val >> 4) & 0x0F];
+    buf += cs[val & 0x0F];
+  }
+  return buf;
+}
+
 void setup() {
   // We are using a hardcoded device id here, but it should be retrieved or
   // given during the device provisioning then converted to a byte vector to
@@ -38,9 +64,21 @@ void setup() {
     Serial.println("[MAMA] Failed to setup MamaDuck");
     return;
   }
-
   setupOK = true;
 
+  GPS.begin(9600, SERIAL_8N1, 34, 12);  
+
+  // // BMP setup
+  // if (!bmp.begin()) {
+  //   /* There was a problem detecting the BMP085 ... check your connections */
+  //   Serial.print(
+  //       "Ooops, no BMP085 detected ... Check your wiring or I2C ADDR!");
+  //   while (1)
+  //     ;
+  // } else {
+  //   Serial.println("BMP on");
+  // }
+
   // Initialize the timer. The timer thread runs separately from the main loop
   // and will trigger sending a counter message.
   timer.every(INTERVAL_MS, runSensor);
@@ -72,20 +110,75 @@ void loop() {
 
 bool runSensor(void *) {
   bool result;
-  
-  std::string message = std::string("Counter:") + std::to_string(counter) + " " + std::string("Free Memory:") + std::to_string(freeMemory());
+
+  // String bmpData = getBMPData();
+  String gpsData = getGPSData();
+
+  String message = "\"" + String("GPS: ") + gpsData + "\"";
+  // String message = "\"" + String("BMP: ") + bmpData + "\"";
   Serial.print("[MAMA] sensor data: ");
   Serial.println(message.c_str());
 
-  result = sendData(stringToByteVector(message));
-  if (result) {
-     Serial.println("[MAMA] runSensor ok.");
-  } else {
-     Serial.println("[MAMA] runSensor failed.");
+  duck.storeSensorData(stringToByteVector(message.c_str()));
+  return true;
+}
+
+static void smartDelay(unsigned long ms)
+{
+  unsigned long start = millis();
+  do
+  {
+    while (GPS.available())
+      tgps.encode(GPS.read());
+  } while (millis() - start < ms);
+}
+
+// Getting GPS data
+String getGPSData() {
+
+  // Encoding the GPS
+  smartDelay(5000);
+  
+  // Printing the GPS data
+  Serial.println("--- GPS ---");
+  Serial.print("Latitude  : ");
+  Serial.println(tgps.location.lat(), 5);  
+  Serial.print("Longitude : ");
+  Serial.println(tgps.location.lng(), 4);
+  Serial.print("Altitude  : ");
+  Serial.print(tgps.altitude.feet() / 3.2808);
+  Serial.println("M");
+  Serial.print("Satellites: ");
+  Serial.println(tgps.satellites.value());
+  Serial.println("**********************");
+
+  // Creating a message of the Latitude and Longitude
+  String sensorVal = "Lat:" + String(tgps.location.lat(), 5) + " Lng:" + String(tgps.location.lng(), 4);
+
+  // Check to see if GPS data is being received
+  if (millis() > 5000 && tgps.charsProcessed() < 10)
+  {
+    Serial.println(F("No GPS data received: check wiring"));
   }
-  return result;
+
+  return sensorVal;
 }
 
+// String getBMPData() {
+  
+//   float T, P;
+
+//   bmp.getTemperature(&T);
+//   Serial.println(T);
+//   bmp.getPressure(&P);
+//   Serial.println(P);
+
+//   String sensorVal = "Temp:" + String(T) + " Pres:" + String(P);
+
+
+//   return sensorVal;
+// }
+
 bool sendData(std::vector<byte> message) {
   bool sentOk = false;
   
diff --git a/examples/Basic-Ducks/MamaDuck/platformio.ini b/examples/Basic-Ducks/MamaDuck/platformio.ini
@@ -19,13 +19,17 @@ lib_deps =
 	SPI
 	contrem/arduino-timer@^3.0.1
 	bblanchon/ArduinoJson@^7.0.3
+	adafruit/Adafruit BMP085 Unified@^1.1.3
+    adafruit/Adafruit Unified Sensor@^1.1.14
 
 [env:esp32]
 lib_deps =
 
 [env:local_cdp]
 lib_deps = 
 	symlink://../../../
+	adafruit/Adafruit BMP085 Unified@^1.1.3
+    adafruit/Adafruit Unified Sensor@^1.1.14
 
 [env:release_cdp]
 lib_deps = 
@@ -100,6 +104,8 @@ monitor_filters = time
 lib_deps = 
 	${env:esp32.lib_deps}
 	${env:local_cdp.lib_deps}
+	adafruit/Adafruit BMP085 Unified@^1.1.3
+    adafruit/Adafruit Unified Sensor@^1.1.14
 
 [env:local_ttgo_lora32_v1]
 platform = espressif32
@@ -110,3 +116,5 @@ monitor_filters = time
 lib_deps = 
 	${env:esp32.lib_deps}
 	${env:local_cdp.lib_deps}
+	adafruit/Adafruit BMP085 Unified@^1.1.3
+    adafruit/Adafruit Unified Sensor@^1.1.14
diff --git a/src/DuckNet.cpp b/src/DuckNet.cpp
@@ -5,7 +5,7 @@
 DuckNet::DuckNet(BloomFilter *filter): bloomFilter(filter) {
 }
 
-CircularBuffer atakBuffer = CircularBuffer(CDPCFG_CDP_CHATBUF_SIZE);
+CircularBuffer atakMessageBuffer = CircularBuffer(CDPCFG_CDP_CHATBUF_SIZE);
 
 #ifndef CDPCFG_WIFI_NONE
 
@@ -152,46 +152,46 @@ int DuckNet::setupWebServer(bool createCaptivePortal, std::string html) {
     }
   });
 
-  webServer.on("/sendAtakMessage.json", HTTP_POST, [&](AsyncWebServerRequest* request) {
-    int err = DUCK_ERR_NONE;
-
-    std::vector<byte> message;
-    std::string clientId = "";
-
-    const AsyncWebParameter* p = request->getParam(0);
-    std::string msg = p->value().c_str();
-    message.insert(message.end(), msg.begin(), msg.end());
-    std::vector<byte> muid;
-
-    txPacket->prepareForSending(bloomFilter, BROADCAST_DUID, DuckType::UNKNOWN, topics::achat, message);
-    auto atakPacket = txPacket->getBuffer(); //TODO: no auto
-
-    addToAtakBuffer(CdpPacket(atakPacket));
-    err = duckRadio.sendData(atakPacket);
-
-    switch (err) {
-      case DUCK_ERR_NONE:
-      {
-        loginfo_ln("success sending packer");
-        request->send(200, "text/html", "OK.");
-      }
-      break;
-      case DUCKLORA_ERR_MSG_TOO_LARGE:
-      request->send(413, "text/html", "Message payload too big!");
-      break;
-      case DUCKLORA_ERR_HANDLE_PACKET:
-      request->send(400, "text/html", "BadRequest");
-      break;
-      default:
-      request->send(500, "text/html", "Oops! Unknown error.");
-      break;
-    }
-  });
+  // webServer.on("/sendAtakMessage.json", HTTP_POST, [&](AsyncWebServerRequest* request) {
+  //   int err = DUCK_ERR_NONE;
+
+  //   std::vector<byte> message;
+  //   std::string clientId = "";
+
+  //   const AsyncWebParameter* p = request->getParam(0);
+  //   std::string msg = p->value().c_str();
+  //   message.insert(message.end(), msg.begin(), msg.end());
+  //   std::vector<byte> muid;
+
+  //   txPacket->prepareForSending(bloomFilter, BROADCAST_DUID, DuckType::UNKNOWN, topics::achat, message);
+  //   auto atakPacket = txPacket->getBuffer(); //TODO: no auto
+
+  //   addToAtakBuffer(CdpPacket(atakPacket));
+  //   err = duckRadio.sendData(atakPacket);
+
+  //   switch (err) {
+  //     case DUCK_ERR_NONE:
+  //     {
+  //       loginfo_ln("success sending packer");
+  //       request->send(200, "text/html", "OK.");
+  //     }
+  //     break;
+  //     case DUCKLORA_ERR_MSG_TOO_LARGE:
+  //     request->send(413, "text/html", "Message payload too big!");
+  //     break;
+  //     case DUCKLORA_ERR_HANDLE_PACKET:
+  //     request->send(400, "text/html", "BadRequest");
+  //     break;
+  //     default:
+  //     request->send(500, "text/html", "Oops! Unknown error.");
+  //     break;
+  //   }
+  // });
 
   webServer.on("/atakHistory", HTTP_GET, [&](AsyncWebServerRequest* request) {
     size_t atakSize;
 
-    uint8_t* atakBytes = DuckNet::serializeAtakHistoryToBytes(&atakBuffer, &atakSize);
+    uint8_t* atakBytes = DuckNet::serializeAtakHistoryToBytes(&atakMessageBuffer, &atakSize);
 
     // std::shared_ptr<uint8_t> atakData(atakBytes, [](uint8_t* p) { delete[] p; });
 
@@ -203,8 +203,7 @@ int DuckNet::setupWebServer(bool createCaptivePortal, std::string html) {
 });
 
   webServer.on("/atakChatHistory", HTTP_GET, [&](AsyncWebServerRequest* request){
-      loginfo_ln("this is what should be called in captive portal");
-      std::string response = DuckNet::serializeAtakHistoryToJSON(&atakBuffer);
+      std::string response = DuckNet::serializeAtakHistoryToJSON(&atakMessageBuffer);
       const char* res = response.c_str();
       request->send(200, "text/json", res);
   });
@@ -357,10 +356,14 @@ int DuckNet::setupInternet(std::string ssid, std::string password)
 
 }
 
-void DuckNet::addToAtakBuffer(CdpPacket message) {
-  if(atakBuffer.findMuid(message.muid) < 0){
-    message.timeReceived = millis();
-    atakBuffer.push(message);
+void DuckNet::addToAtakBuffer(std::vector<byte> message) {
+  txPacket->prepareForSending(bloomFilter, BROADCAST_DUID, DuckType::UNKNOWN, topics::achat, message);
+  auto atakBuffer = txPacket->getBuffer(); //TODO: no auto
+  CdpPacket atakPacket(atakBuffer);
+
+  if(atakMessageBuffer.findMuid(atakPacket.muid) < 0){
+    atakPacket.timeReceived = millis();
+    atakMessageBuffer.push(atakPacket);
     loginfo_ln("pushed new packet to buffer");
   }
 }
diff --git a/src/Ducks/Duck.cpp b/src/Ducks/Duck.cpp
@@ -28,6 +28,10 @@ Duck::~Duck() {
   delete duckNet;
 }
 
+void Duck::storeSensorData(std::vector<byte> sensorData){
+  duckNet->addToAtakBuffer(sensorData);
+}
+
 void Duck::setEncrypt(bool state) {
   duckcrypto::setEncrypt(state);
 }
diff --git a/src/Ducks/MamaDuck.cpp b/src/Ducks/MamaDuck.cpp
@@ -107,22 +107,22 @@ void MamaDuck::handleReceivedPacket() {
             loginfo_ln("handleReceivedPacket: packet RELAY DONE");
           }
         break;
-        case topics::achat:{
-          packet.timeReceived = millis();
-          duckNet->addToAtakBuffer(packet);
-
-          std::vector<byte> data;
-          byte numPairs = 1;
-          data.insert(data.end(), numPairs);
-          data.insert(data.end(), packet.muid.begin(), packet.muid.end());
-
-          err = duckRadio.relayPacket(rxPacket);
-          if (err != DUCK_ERR_NONE) {
-            logerr_ln("====> ERROR handleReceivedPacket failed to relay. rc = %d",err);
-          } else {
-            loginfo_ln("handleReceivedPacket: packet RELAY DONE");
-          }
-        }
+        // case topics::achat:{
+        //   packet.timeReceived = millis();
+        //   duckNet->addToAtakBuffer(packet);
+
+        //   std::vector<byte> data;
+        //   byte numPairs = 1;
+        //   data.insert(data.end(), numPairs);
+        //   data.insert(data.end(), packet.muid.begin(), packet.muid.end());
+
+        //   err = duckRadio.relayPacket(rxPacket);
+        //   if (err != DUCK_ERR_NONE) {
+        //     logerr_ln("====> ERROR handleReceivedPacket failed to relay. rc = %d",err);
+        //   } else {
+        //     loginfo_ln("handleReceivedPacket: packet RELAY DONE");
+        //   }
+        // }
         break;
         default:
           err = duckRadio.relayPacket(rxPacket);
diff --git a/src/include/Duck.h b/src/include/Duck.h
@@ -28,6 +28,7 @@ class Duck {
   virtual ~Duck();
 
   std::string getCDPVersion() { return duckutils::getCDPVersion(); }
+  void storeSensorData(std::vector<byte> sensorData);
 
   /**
    * @brief Set the Device Name object
diff --git a/src/include/DuckNet.h b/src/include/DuckNet.h
@@ -119,7 +119,7 @@ class DuckNet {
     return DUCK_ERR_NONE;
   }
 
-   void addToAtakBuffer(DuckPacket message) {
+   void addToAtakBuffer(DuckPacket std::vector<byte>) {
     logwarn_ln("WARNING addToAtakBuffer skipped, device has no WiFi.");
   }
   std::string serializeAtakHistoryToJSON(CircularBuffer* buffer) {
@@ -213,7 +213,7 @@ class DuckNet {
   /**
    * @brief add ATAK message to history buffer
   */
-  void addToAtakBuffer(CdpPacket message);
+  void addToAtakBuffer(std::vector<byte> message);
 
    /**
    * @brief retrieve all messages from from message circular buffer
diff --git a/src/include/chatPage.h b/src/include/chatPage.h
@@ -39,7 +39,7 @@ const char chat_page[] PROGMEM = R"=====(
             card.classList.add("received-message-card");
         }
         // console.log(newMessage)
-        card.innerHTML = newMessage.body.body + '</p><span class="duid">FROM DUCKID: '
+        card.innerHTML = newMessage.body + '</p><span class="duid">FROM DUCKID: '
         + newMessage.sduid + '</span></p><span class="name">';
 
         document.getElementById('message-container').prepend(card);

Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,10 @@ Duck::~Duck() {`
`28`	`28`	`delete duckNet;`
`29`	`29`	`}`
`30`	`30`
	`31`	`+void Duck::storeSensorData(std::vector<byte> sensorData){`
	`32`	`+ duckNet->addToAtakBuffer(sensorData);`
	`33`	`+}`
	`34`	`+`
`31`	`35`	`void Duck::setEncrypt(bool state) {`
`32`	`36`	`duckcrypto::setEncrypt(state);`
`33`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ const char chat_page[] PROGMEM = R"=====(`
`39`	`39`	`card.classList.add("received-message-card");`
`40`	`40`	`}`
`41`	`41`	`// console.log(newMessage)`
`42`		`- card.innerHTML = newMessage.body.body + '</p><span class="duid">FROM DUCKID: '`
	`42`	`+ card.innerHTML = newMessage.body + '</p><span class="duid">FROM DUCKID: '`
`43`	`43`	`+ newMessage.sduid + '</span></p><span class="name">';`
`44`	`44`
`45`	`45`	`document.getElementById('message-container').prepend(card);`