ideasX-encoder-firmware/interface/ideasx_interface.c

#include "interface/ideasx_interface.h"

static const char* TAG = "IdeasX";

MQTT_Client mqttClient;
static IdeasX_Config_t ideasX_config;
static IdeasX_Health_t ideasX_health;
static os_timer_t health_timer;


static void ICACHE_FLASH_ATTR ideasX_publish_health(void)
{
    uint8_t topic[40], payload[40];
    ideasX_health.vcell.value = Encoder_GetVoltage();
    ideasX_health.soc.value = Encoder_GetSOC();
    ideasX_health.rssi.value = wifi_station_get_rssi();

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.vcell.topic);
    os_sprintf(payload, "%d", ideasX_health.vcell.value);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.soc.topic);
    os_sprintf(payload, "%d", ideasX_health.soc.value);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.rssi.topic);
    os_sprintf(payload, "%d", ideasX_health.rssi.value);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);
}

static void ICACHE_FLASH_ATTR ideasX_connected_cb(uint32_t *args)
{
    struct station_config stationConfig;
    wifi_station_get_config(&stationConfig);
    uint8_t topic[40], payload[40];

    ESP_LOGI(TAG, "Connected to IdeasX");

    if (ideasX_config.success_cb != NULL)
        ideasX_config.success_cb();

    // publish static health information
    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.hw_ver.topic);
    os_sprintf(payload, "%d,%d", ideasX_health.hw_ver.major, ideasX_health.hw_ver.minor);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.fw_ver.topic);
    os_sprintf(payload, "%d,%d", ideasX_health.fw_ver.major, ideasX_health.fw_ver.minor);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.alive.topic);
    os_sprintf(payload, "%d", ideasX_health.alive.flag);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(ideasX_health.ssid.value, "%s", stationConfig.ssid);
    os_sprintf(ideasX_health.bssid.value, MACSTR, MAC2STR(stationConfig.bssid));

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.ssid.topic);
    os_sprintf(payload, "%s", ideasX_health.ssid.value);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.bssid.topic);
    os_sprintf(payload, "%s", ideasX_health.bssid.value);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    os_sprintf(topic, "%s%s", ideasX_config.health_topic, ideasX_health.ota.topic);
    os_sprintf(payload, "%d", ideasX_health.ota.flag);
    MQTT_Publish(&mqttClient, topic, payload, os_strlen(payload), HEALTH_QOS, HEALTH_RETAIN);

    ideasX_publish_health();

    // setup publish health timer
    os_timer_disarm(&ideasX_health.health_timer);
    os_timer_arm(&ideasX_health.health_timer, ideasX_health.health_report_rate*1000, true);   // change to system task
}

static void ICACHE_FLASH_ATTR ideasX_disconnected_cb(uint32_t *args)
{
    ESP_LOGI(TAG, "Disconnected from IdeasX");
    os_timer_disarm(&ideasX_health.health_timer);
    if (ideasX_config.fail_cb != NULL)
        ideasX_config.fail_cb();
}

static void ICACHE_FLASH_ATTR ideasX_published_cb(uint32_t *args)
{
    // subscribe to command topics
    ESP_LOGD(TAG, "Published Messaged");
}

void ICACHE_FLASH_ATTR IdeasX_Connect(void)
{
    MQTT_Connect(&mqttClient);
}

void ICACHE_FLASH_ATTR IdeasX_Disconnect(void)
{
    MQTT_Disconnect(&mqttClient);
}

void ICACHE_FLASH_ATTR ideasX_system_config_init()
{
    uint8_t mac_address[6];
    wifi_get_macaddr(STATION_MODE, mac_address);
    os_sprintf(ideasX_config.device_id, MACSTR, MAC2STR(mac_address));
    os_sprintf(ideasX_config.mqtt_client_id, MACSTR, MAC2STR(mac_address));

    os_sprintf(ideasX_config.command_topic, "encoder/%s/command/", ideasX_config.device_id);
    os_sprintf(ideasX_config.health_topic, "encoder/%s/health/", ideasX_config.device_id);
    os_sprintf(ideasX_config.mqtt_host, "%s", MQTT_HOST_DEFAULT);
    ideasX_config.mqtt_port = MQTT_PORT_DEFAULT;
    os_sprintf(ideasX_config.mqtt_user, "%s", "");
    os_sprintf(ideasX_config.mqtt_pass, "%s", "");

    #ifdef MQTT_USER_DEFAULT
        os_sprintf(ideasX_config.mqtt_user, "%s", MQTT_USER_DEFAULT);
        os_sprintf(ideasX_config.mqtt_pass, "%s", MQTT_PASS_DEFAULT);
    #endif
    ideasX_config.mqtt_keepalive = MQTT_KEEPALIVE_DEFAULT;

    ideasX_config.success_cb = NULL;
    ideasX_config.fail_cb = NULL;

}

void ICACHE_FLASH_ATTR ideasX_health_config_init()
{
    // setup ideasX topics
    os_sprintf(ideasX_health.hw_ver.topic, "%s", HW_VERSION_HEALTH_TOPIC);
    os_sprintf(ideasX_health.fw_ver.topic, "%s", FW_VERSION_HEALTH_TOPIC);
    os_sprintf(ideasX_health.alive.topic, "%s", ALIVE_HEALTH_TOPIC);
    os_sprintf(ideasX_health.vcell.topic, "%s", VCELL_HEALTH_TOPIC);
    os_sprintf(ideasX_health.soc.topic, "%s", SOC_HEALTH_TOPIC);
    os_sprintf(ideasX_health.rom.topic, "%s", ROM_HEALTH_TOPIC);
    os_sprintf(ideasX_health.ota.topic, "%s", OTA_HEALTH_TOPIC);
    os_sprintf(ideasX_health.ssid.topic, "%s", SSID_HEALTH_TOPIC);
    os_sprintf(ideasX_health.bssid.topic, "%s", BSSID_HEALTH_TOPIC);
    os_sprintf(ideasX_health.rssi.topic, "%s", RSSI_HEALTH_TOPIC);
    ideasX_health.health_report_rate = HEALTH_REPORT_RATE_DEFAULT;

    // load default values for static items
    ideasX_health.hw_ver.minor = HW_VERSION_MINOR_DEFAULT;
    ideasX_health.hw_ver.major = HW_VERSION_MAJOR_DEFAULT;
    ideasX_health.fw_ver.minor = FW_VERSION_MINOR_DEFAULT;
    ideasX_health.fw_ver.major = FW_VERSION_MAJOR_DEFAULT;
    ideasX_health.alive.flag = true;
    ideasX_health.ota.flag = false;

    ideasX_health.health_timer = health_timer;
    os_timer_disarm(&ideasX_health.health_timer);
    os_timer_setfn(&ideasX_health.health_timer, (os_timer_func_t *)ideasX_publish_health, NULL);
}

void ICACHE_FLASH_ATTR IdeasX_UpdateBatteryStatus(uint16_t vcell, uint16_t soc)
{
    ideasX_health.soc.value = soc;
    ideasX_health.vcell.value = vcell;
}

void ICACHE_FLASH_ATTR IdeasX_SetStatusCallbacks(ideasX_function_t success, ideasX_function_t fail)
{
    ideasX_config.success_cb = success;
    ideasX_config.fail_cb = fail;
}

void ICACHE_FLASH_ATTR IdeasX_Init(void)
{
    ideasX_system_config_init();
    ideasX_health_config_init();

    MQTT_InitConnection(&mqttClient, ideasX_config.mqtt_host, ideasX_config.mqtt_port, DEFAULT_SECURITY);
    MQTT_InitClient(&mqttClient, ideasX_config.mqtt_client_id, ideasX_config.mqtt_user, ideasX_config.mqtt_pass,
        ideasX_config.mqtt_keepalive, MQTT_CLEAN_SESSION);
    MQTT_InitLWT(&mqttClient, ideasX_health.alive.topic, "0", 0, 0);
    MQTT_OnConnected(&mqttClient, ideasX_connected_cb);
    MQTT_OnDisconnected(&mqttClient, ideasX_disconnected_cb);
    //MQTT_OnPublished(&mqttClient, mqttPublishedCb);
    //MQTT_OnData(&mqttClient, mqttDataCb);
}