Add a Custom Sensor to GEIA Custom Sensor

/*
  GEIA custom sensor - MQTT example
  Target: ESP32
  Library: PubSubClient

  Replace every YOUR_... value before uploading.
  Replace readSensorValue1() and readSensorValue2() with your sensor library calls.
  Never publish real credentials in a public repository.
*/

#include <WiFi.h>
#include <PubSubClient.h>
#include <math.h>

// Wi-Fi
const char* WIFI_SSID = "YOUR_WIFI_SSID";
const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";

// MQTT details supplied by GEIA or shown on the Grow Hub page
const char* MQTT_HOST = "YOUR_ASSIGNED_MQTT_HOST";
const uint16_t MQTT_PORT = 1883;
const char* MQTT_USER = "YOUR_MQTT_USERNAME_OR_TOKEN";
const char* MQTT_PASSWORD = "YOUR_MQTT_PASSWORD";

// Use the location ID for a cloud connection.
// Leave LOCATION_ID empty ("") for a local Grow Hub connection.
const char* LOCATION_ID = "YOUR_LOCATION_ID";
const char* SENSOR_ID = "YOUR_SENSOR_ID";

const unsigned long PUBLISH_EVERY_MS = 30000;
const float MINIMUM_CHANGE = 0.1f;

WiFiClient networkClient;
PubSubClient mqtt(networkClient);

unsigned long lastPublishAt = 0;
unsigned long lastMqttAttemptAt = 0;
float lastValue1 = NAN;
float lastValue2 = NAN;

// Replace these two functions with real sensor library calls.
float readSensorValue1() {
  return 22.5f;
}

float readSensorValue2() {
  return 55.1f;
}

String sensorTopic() {
  String topic = "e/s/" + String(SENSOR_ID);

  if (strlen(LOCATION_ID) > 0) {
    topic = "/" + String(LOCATION_ID) + "/" + topic;
  }

  return topic;
}

void connectWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print('.');
  }
  Serial.println(" connected");
}

void maintainMqtt() {
  if (mqtt.connected()) {
    return;
  }

  const unsigned long now = millis();
  if (now - lastMqttAttemptAt < 5000) {
    return;
  }
  lastMqttAttemptAt = now;

  String clientId = "GEIA-CustomSensor-" + String(random(0xffff), HEX);
  Serial.print("Connecting to MQTT...");

  if (mqtt.connect(clientId.c_str(), MQTT_USER, MQTT_PASSWORD)) {
    Serial.println(" connected");
  } else {
    Serial.print(" failed, state=");
    Serial.println(mqtt.state());
  }
}

void publishSensorReading() {
  if (!mqtt.connected()) {
    return;
  }

  const float value1 = readSensorValue1();
  const float value2 = readSensorValue2();

  if (isnan(value1) || isnan(value2)) {
    Serial.println("Sensor returned an invalid value");
    return;
  }

  const bool firstReading = isnan(lastValue1) || isnan(lastValue2);
  const bool changed = fabsf(value1 - lastValue1) >= MINIMUM_CHANGE ||
                       fabsf(value2 - lastValue2) >= MINIMUM_CHANGE;

  if (!firstReading && !changed) {
    Serial.println("Reading has not changed enough; not publishing");
    return;
  }

  // This example sends two space-separated values: "value_1 value_2".
  // For a one-value sensor, use only String(value1, 2).
  String payload = String(value1, 2) + " " + String(value2, 2);
  String topic = sensorTopic();

  if (mqtt.publish(topic.c_str(), payload.c_str(), true)) {
    Serial.println("Published " + payload + " to " + topic);
    lastValue1 = value1;
    lastValue2 = value2;
  } else {
    Serial.println("MQTT publish failed");
  }
}

void setup() {
  Serial.begin(115200);
  randomSeed(micros());
  connectWiFi();
  mqtt.setServer(MQTT_HOST, MQTT_PORT);
}

void loop() {
  if (WiFi.status() != WL_CONNECTED) {
    connectWiFi();
  }

  maintainMqtt();
  mqtt.loop();

  const unsigned long now = millis();
  if (now - lastPublishAt >= PUBLISH_EVERY_MS) {
    lastPublishAt = now;
    publishSensorReading();
  }
}

/*
  GEIA custom sensor - REST API logging example
  Target: ESP32
  Libraries: HTTPClient and ArduinoJson

  This starter example:
  1. reads two sensor values;
  2. sends them to the GEIA sensor-data route;
  3. refreshes the JWT after a 401 response; and
  4. retries the reading once.

  Confirm the API base, routes and JSON fields for your assigned cluster.
  Add current TLS certificate validation before production deployment.
  Never publish real credentials in a public repository.
*/

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <math.h>

// Wi-Fi
const char* WIFI_SSID = "YOUR_WIFI_SSID";
const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";

// Use the API base supplied with your credentials.
const char* API_BASE = "https://api.geia.ai";
const char* SENSOR_LOG_ROUTE = "/data/add/sensor";
const char* TOKEN_REFRESH_ROUTE = "/auth/refresh";

const char* SENSOR_ID = "YOUR_SENSOR_ID";
String accessToken = "YOUR_INITIAL_JWT_ACCESS_TOKEN";
String refreshToken = "YOUR_REFRESH_TOKEN";

const unsigned long UPLOAD_EVERY_MS = 300000;
unsigned long lastUploadAt = 0;

// Replace these two functions with real sensor library calls.
float readSensorValue1() {
  return 22.5f;
}

float readSensorValue2() {
  return 55.1f;
}

void connectWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print('.');
  }
  Serial.println(" connected");
}

// Replace this function with secure NVS/Preferences storage if tokens must
// survive a restart. Some servers may also rotate the refresh token.
void saveRenewedTokens() {
  // Example: save accessToken and refreshToken with Preferences.
}

int postSensorPayload(const String& payload) {
  HTTPClient http;
  const String url = String(API_BASE) + SENSOR_LOG_ROUTE;

  if (!http.begin(url)) {
    Serial.println("Could not start HTTPS request");
    return -1;
  }

  http.addHeader("Content-Type", "application/json");
  http.addHeader("Authorization", "Bearer " + accessToken);
  http.setTimeout(15000);

  const int status = http.POST(payload);
  const String body = http.getString();

  Serial.print("Sensor API status: ");
  Serial.println(status);
  if (status < 200 || status >= 300) {
    Serial.println(body);
  }

  http.end();
  return status;
}

bool refreshAccessToken() {
  HTTPClient http;
  const String url = String(API_BASE) + TOKEN_REFRESH_ROUTE;

  if (!http.begin(url)) {
    Serial.println("Could not start token-refresh request");
    return false;
  }

  http.addHeader("Content-Type", "application/json");
  http.setTimeout(15000);

  StaticJsonDocument<256> request;
  request["refresh_token"] = refreshToken;

  String payload;
  serializeJson(request, payload);

  const int status = http.POST(payload);
  const String body = http.getString();
  http.end();

  if (status < 200 || status >= 300) {
    Serial.print("Token refresh failed, status: ");
    Serial.println(status);
    Serial.println(body);
    return false;
  }

  StaticJsonDocument<768> response;
  const DeserializationError jsonError = deserializeJson(response, body);
  if (jsonError) {
    Serial.print("Could not read token response: ");
    Serial.println(jsonError.c_str());
    return false;
  }

  String newAccessToken;
  if (!response["jwt"].isNull()) {
    newAccessToken = response["jwt"].as<String>();
  } else if (!response["token"].isNull()) {
    newAccessToken = response["token"].as<String>();
  } else if (!response["data"]["jwt"].isNull()) {
    newAccessToken = response["data"]["jwt"].as<String>();
  } else if (!response["data"]["token"].isNull()) {
    newAccessToken = response["data"]["token"].as<String>();
  }

  if (newAccessToken.length() == 0) {
    Serial.println("Refresh response did not contain a new access token");
    return false;
  }

  accessToken = newAccessToken;

  if (!response["refresh_token"].isNull()) {
    refreshToken = response["refresh_token"].as<String>();
  } else if (!response["data"]["refresh_token"].isNull()) {
    refreshToken = response["data"]["refresh_token"].as<String>();
  }

  saveRenewedTokens();
  Serial.println("Access token refreshed");
  return true;
}

bool uploadSensorReading(float value1, float value2) {
  StaticJsonDocument<256> document;
  document["sensor_id"] = SENSOR_ID;
  document["value_1"] = value1;
  document["value_2"] = value2;

  // Leave sample_timestamp out if the server should set the time.
  String payload;
  serializeJson(document, payload);

  int status = postSensorPayload(payload);
  if (status == 401) {
    Serial.println("Access token expired; refreshing it now");
    if (!refreshAccessToken()) {
      return false;
    }
    status = postSensorPayload(payload);  // Retry only once.
  }

  return status >= 200 && status < 300;
}

void setup() {
  Serial.begin(115200);
  connectWiFi();
  lastUploadAt = millis() - UPLOAD_EVERY_MS;  // Send the first reading now.
}

void loop() {
  if (WiFi.status() != WL_CONNECTED) {
    connectWiFi();
  }

  const unsigned long now = millis();
  if (now - lastUploadAt < UPLOAD_EVERY_MS) {
    return;
  }
  lastUploadAt = now;

  const float value1 = readSensorValue1();
  const float value2 = readSensorValue2();

  if (isnan(value1) || isnan(value2)) {
    Serial.println("Sensor returned an invalid value");
    return;
  }

  if (uploadSensorReading(value1, value2)) {
    Serial.println("Sensor reading uploaded");
  } else {
    Serial.println("Sensor reading was not uploaded");
  }
}