#include <WiFi.h>
#include "wifi-credentials.h"
#include "connection-wifi.h"
#include "gps.h"
#include "dht.h"
#include "senddata.h"
#include "functions.h"

uint64_t sleepInterval = 60 * 5; // Sleep for 5 minutes

int TIME_TO_SLEEP_IN_SECONDS = 5; // 
unsigned long uS_TO_S_FACTOR = 1000000;

void gatherDataAndSend() {
    char* temp = readTemperature();
    Serial.print("Temperature: ");Serial.println(temp);

    char* latlng = readGPS();
    Serial.print("GPS: ");Serial.println(latlng);

    char* data = createQueryString(temp, latlng);
    Serial.print("data: "); Serial.println(data);

    sendData(data);

    free(temp);
    free(latlng);
    free(data);
}

void setup() {
  Serial.begin(115200);
  Serial.println("### ### ### ### ### ### ### ### ### ### ###");
  GPS_SERIAL.begin(115200);
  dht.setup(DHT_PIN, DHTesp::DHT22);

  gatherDataAndSend();
  
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP_IN_SECONDS * uS_TO_S_FACTOR * 60);
  Serial.flush();
  esp_deep_sleep_start();
}

void loop() {
  Serial.println("### ### ### this is loop - should not have been called.");

  // Gather data and send to server:
  //gatherDataAndSend();

  // Enter deep sleep mode:
  //esp_deep_sleep(sleepInterval * 1000000); // Convert seconds to microseconds
}

sketch.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

HttpClient
DHT sensor library for ESPx
TinyGPSPlus
WiFi

libraries.txt

#define WIFI_SSID "Wokwi-GUEST"
#define WIFI_PASSWORD ""

wifi-credentials.h

#include <TinyGPS++.h>

#define GPS_SERIAL Serial2
TinyGPSPlus gps;

char* readGPS() {
    // Assuming these are global variables
    char* gpsSimulatedLatitude = "55.6713088";
    char* gpsSimulatedLongitude = "12.5525389";
    
    // Calculate the length of the resulting string
    size_t totalLength = strlen(gpsSimulatedLatitude) + strlen(gpsSimulatedLongitude) + 2; // Plus 2 for comma and null terminator
    
    // Allocate memory for the resulting string
    char* gpsData = (char*)malloc(totalLength * sizeof(char));
    
    // Check if memory allocation was successful
    if (gpsData == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(1); // Exit the program due to failure
    }
    
    // Concatenate latitude, comma, and longitude into the result string
    sprintf(gpsData, "%s,%s", gpsSimulatedLatitude, gpsSimulatedLongitude);
    
    return gpsData;
}

/*
//String gpsSimulatedLatitude = "55.6713088";
//String gpsSimulatedLongitude = "12.5525389";
String readGPS() {

  // Return simulated data
  return gpsSimulatedLatitude + "," + gpsSimulatedLongitude;

  // Read data from GPS module
  while (GPS_SERIAL.available() > 0) {

    if (gps.encode(GPS_SERIAL.read())) {

      // Check if GPS data is valid
      if (gps.location.isValid()) {

        // Get latitude and longitude
        String latitude = String(gps.location.lat(), 6);
        String longitude = String(gps.location.lng(), 6);

        // Return coordinates as a string
        return "Latitude: " + latitude + ", Longitude: " + longitude;
      }

    }

  }

  // Return empty string if no valid coordinates are available
  return "";
}
*/

gps.h

#include <DHTesp.h>
const int DHT_PIN = 15;
DHTesp dht;

/*typedef struct {
    float temperature;
    float humidity;
} TempAndHumidity;*/

char* readTemperature() {
    TempAndHumidity data = dht.getTempAndHumidity();
    
    // Allocate memory for the string representation of temperature
    char* temperatureString = (char*)malloc(10 * sizeof(char)); // Assuming a maximum of 10 characters
    
    // Convert temperature to string with 2 decimal places
    sprintf(temperatureString, "%.2f", data.temperature);
    
    return temperatureString;
}

dht.h

unsigned long connectionTimeoutWifi = 10000; // Default timeout: 10 seconds

bool establishConnection_WiFi() {
  unsigned long startTime = millis();

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  
  while (WiFi.status() != WL_CONNECTED) {
    if (millis() - startTime >= connectionTimeoutWifi) {
      Serial.println("Connection timeout");
      return false;
    }
    delay(1000);
    Serial.println("Connecting to WiFi..");
  }
  Serial.println("Connected to WiFi");
  return true;
}

bool closeConnection_WiFi() {
  if (WiFi.status() == WL_CONNECTED)
  {
    //WiFi.end();
  }
  return true;
}

connection-wifi.h

#include <HTTPClient.h>
HTTPClient http;

String apiUrl = "https://www.non-existing-domainXz.com/";

// Using WiFi connection instead of 4G:
bool establishConnection() { return establishConnection_WiFi(); }
bool closeConnection() { closeConnection_WiFi(); }

void _sendDataToServer(const char* data) {
  int httpResponseCode = http.POST(data);
  
  if (httpResponseCode > 0) {
    Serial.print("HTTP Response code: ");
    Serial.println(httpResponseCode);
  } else {
    Serial.print("Error code: ");
    Serial.println(httpResponseCode);
  }
}

void sendData(const char* data) {
  Serial.println("Establishing connection...");
  if (!establishConnection()) {
    Serial.println("Failed to establishing connection. End.");
    return;
  }
  
  Serial.print("Sending data:");
  Serial.println(data);
  
  http.begin(apiUrl);
  http.addHeader("Content-Type", "application/x-www-form-urlencoded");
  _sendDataToServer(data);
  http.end();

  closeConnection();
}

senddata.h

char* createQueryString(const char* Temp, const char* LatLng) {
    // Calculate total length of the query string
    int totalLength = strlen("t=") + strlen(Temp) + strlen("&g=") + strlen(LatLng) + 1; // +1 for null terminator

    // Allocate memory for the query string
    char* queryString = (char*)malloc(totalLength * sizeof(char));
    if (queryString == NULL) {
        printf("Memory allocation failed\n");
        return NULL; // Return NULL if memory allocation fails
    }

    // Construct the query string
    sprintf(queryString, "t=%s&g=%s", Temp, LatLng);

    return queryString;
}
