configuration.cpp

Go to the documentation of this file.

#include "configuration.hpp"
 
#include <ArduinoLog.h>
#include <libents/proto/transcoder.h>
#include <string.h>
 
static UserConfiguration config = UserConfiguration_init_default;
 
void setConfig(const UserConfiguration& new_config) {
  // deeeeep copy
  config.logger_id = new_config.logger_id;
  config.cell_id = new_config.cell_id;
  config.Upload_method = new_config.Upload_method;
  config.Upload_interval = new_config.Upload_interval;
  config.enabled_sensors_count = new_config.enabled_sensors_count;
  memcpy(config.enabled_sensors, new_config.enabled_sensors,
         sizeof(config.enabled_sensors));
  config.Voltage_Slope = new_config.Voltage_Slope;
  config.Voltage_Offset = new_config.Voltage_Offset;
  config.Current_Slope = new_config.Current_Slope;
  config.Current_Offset = new_config.Current_Offset;
  strncpy(config.WiFi_SSID, new_config.WiFi_SSID, sizeof(config.WiFi_SSID));
  strncpy(config.WiFi_Password, new_config.WiFi_Password,
          sizeof(config.WiFi_Password));
  strncpy(config.API_Endpoint_URL, new_config.API_Endpoint_URL,
          sizeof(config.API_Endpoint_URL));
  config.API_Endpoint_Port = new_config.API_Endpoint_Port;
 
  // Check that the user config can be encoded/decoded?? (John)
  uint8_t buffer[UserConfiguration_size];
  size_t message_length = EncodeUserConfiguration(&config, buffer);
  UserConfiguration decoded_config = UserConfiguration_init_zero;
 
  if (message_length != -1) {
    // printEncodedData(buffer, message_length);
 
    if (DecodeUserConfiguration(buffer, message_length, &decoded_config) == 0) {
      // printDecodedConfig(&decoded_config);
    } else {
      Log.errorln("Failed to decode the configuration");
    }
  } else {
    Log.errorln("Failed to encode the configuration");
  }
}
 
const UserConfiguration& getConfig() { return config; }
 
String getConfigJson() {
  const UserConfiguration& config = getConfig();
 
  String json = "{";
  json += "\"logger_id\":" + String(config.logger_id) + ",";
  json += "\"cell_id\":" + String(config.cell_id) + ",";
  json += "\"upload_method\":\"" +
          String(config.Upload_method == Uploadmethod_WiFi ? "WiFi" : "LoRa") +
          "\",";
  json += "\"upload_interval\":" + String(config.Upload_interval) + ",";
 
  // Enabled sensors
  json += "\"enabled_sensors\":[";
  for (uint8_t i = 0; i < config.enabled_sensors_count; i++) {
    if (i > 0) json += ",";
    switch (config.enabled_sensors[i]) {
      case EnabledSensor_Voltage:
        json += "\"Voltage\"";
        break;
      case EnabledSensor_Current:
        json += "\"Current\"";
        break;
      case EnabledSensor_Teros12:
        json += "\"Teros12\"";
        break;
      case EnabledSensor_Teros21:
        json += "\"Teros21\"";
        break;
      case EnabledSensor_BME280:
        json += "\"BME280\"";
        break;
      case EnabledSensor_Phytos31:
        json += "\"Phytos31\"";
        break;
      case EnabledSensor_SEN0308:
        json += "\"SEN0308\"";
        break;
      case EnabledSensor_SEN0257:
        json += "\"SEN0257\"";
        break;
      case EnabledSensor_YFS210C:
        json += "\"YFS210C\"";
        break;
      case EnabledSensor_PCAP02:
        json += "\"PCAP02\"";
        break;
      default:
        break;
    }
  }
  json += "],";
 
  char calib_buffer[32];
  snprintf(calib_buffer, sizeof(calib_buffer), "%g", config.Voltage_Slope);
  json += "\"calibration_v_slope\":" + String(calib_buffer) + ",";
  snprintf(calib_buffer, sizeof(calib_buffer), "%g", config.Voltage_Offset);
  json += "\"calibration_v_offset\":" + String(calib_buffer) + ",";
  snprintf(calib_buffer, sizeof(calib_buffer), "%g", config.Current_Slope);
  json += "\"calibration_i_slope\":" + String(calib_buffer) + ",";
  snprintf(calib_buffer, sizeof(calib_buffer), "%g", config.Current_Offset);
  json += "\"calibration_i_offset\":" + String(calib_buffer) + ",";
 
  // WiFi settings
  json += "\"wifi_ssid\":\"" + String(config.WiFi_SSID) + "\",";
  // Do not send password
  // json += "\"wifi_password\":\"" + String(config.WiFi_Password) + "\",";
  json += "\"api_endpoint_url\":\"" + String(config.API_Endpoint_URL) + "\"";
 
  json += "}";
 
  return json;
}
 
void printConfig(const UserConfiguration& pconfig) {
  Log.noticeln(" ============ Configuration Details ============");
  Log.noticeln(" Logger ID: %u", pconfig.logger_id);
  Log.noticeln(" Cell ID: %u", pconfig.cell_id);
  Log.noticeln(" Upload Method: %s",
               pconfig.Upload_method == Uploadmethod_LoRa ? "LoRa" : "WiFi");
  Log.noticeln(" Upload Interval: %u sec", pconfig.Upload_interval);
 
  Log.noticeln(" Enabled Sensors (%d):", pconfig.enabled_sensors_count);
  for (int i = 0; i < pconfig.enabled_sensors_count; i++) {
    const char* sensor_name = "Unknown";
    switch (pconfig.enabled_sensors[i]) {
      case EnabledSensor_Voltage:
        sensor_name = "Voltage";
        break;
      case EnabledSensor_Current:
        sensor_name = "Current";
        break;
      case EnabledSensor_Teros12:
        sensor_name = "Teros12";
        break;
      case EnabledSensor_Teros21:
        sensor_name = "Teros21";
        break;
      case EnabledSensor_BME280:
        sensor_name = "BME280";
        break;
      case EnabledSensor_Phytos31:
        sensor_name = "Phytos31";
        break;
      case EnabledSensor_SEN0308:
        sensor_name = "SEN0308";
        break;
      case EnabledSensor_SEN0257:
        sensor_name = "SEN0257";
        break;
      case EnabledSensor_YFS210C:
        sensor_name = "YFS210C";
        break;
      case EnabledSensor_PCAP02:
        sensor_name = "PCAP02";
        break;
    }
    Log.noticeln("   - %s", sensor_name);
  }
 
  // NOTE(jtmadden): This doesn't print all the precision
  Log.noticeln(" Calibration Data:");
  Log.noticeln("   Voltage Slope: %D", pconfig.Voltage_Slope);
  Log.noticeln("   Voltage Offset: %D", pconfig.Voltage_Offset);
  Log.noticeln("   Current Slope: %D", pconfig.Current_Slope);
  Log.noticeln("   Current Offset: %D", pconfig.Current_Offset);
 
  Log.noticeln(" WiFi Settings:");
  Log.noticeln("   SSID: %s", pconfig.WiFi_SSID);
  Log.noticeln("   Password: %s", pconfig.WiFi_Password);
  Log.noticeln("   API Endpoint: %s", pconfig.API_Endpoint_URL);
  Log.noticeln(" =============================");
}
 
void printReceivedConfig() { printConfig(config); }