void ICACHE_FLASH_ATTR
mqtt_connected_cb(uint32_t *args)
{
MQTT_Client* client = (MQTT_Client*)args;
INFO("MQTT: Connected\r\n");
INFO("MQTT: Subscribe Topic: %s\n", config.mqtt_topic_s01);
MQTT_Subscribe(client, config.mqtt_topic_s01, 0);
MQTT_Subscribe(client, config.mqtt_topic_s02, 0);
MQTT_Subscribe(client, config.mqtt_topic_s03, 0);
}
void ICACHE_FLASH_ATTR mqttConnectedCb(uint32_t *args)
{
MQTT_Client* client = (MQTT_Client*)args;
INFO("MQTT: Connected\r\n");
MQTT_Subscribe(client, TOPIC1, 0);
MQTT_Subscribe(client, TOPIC2, 1);
MQTT_Subscribe(client, TOPIC3, 2);
ds3231_get_temp((void *) 0);
}
void ICACHE_FLASH_ATTR mqttConnectedCb(uint32_t *args)
{
MQTT_Client* client = (MQTT_Client*)args;
os_printf("MQTT: Connected\r\n");
MQTT_Subscribe(client, (char *)sysCfg.mqtt_relay_subs_topic,0); // MQTT RELAY TOPIC
MQTT_Subscribe(client, (char *)sysCfg.mqtt_temp_subs_topic,0); // MQTT INPUT TEMP TOPIC
}
void ICACHE_FLASH_ATTR mqttConnectedCb(uint32_t *args) {
MQTT_Client* client = (MQTT_Client*) args;
os_printf("MQTT: Connected\r\n");
#ifdef ESP8266DOOR
MQTT_Subscribe(client, "/tc503/door", 0);
#endif
MQTT_Subscribe(client, "/tc503/reset", 0);
//#ifdef ESP8266OLED
// MQTT_Subscribe(client, "/tc503/time", 0);
//#endif
}
void mqtt_connected_cb(uint32_t *args)
{
MQTT_Client* client = (MQTT_Client*)args;
INFO("MQTT: Connected\r\n");
char tempreg[200];
os_sprintf(tempreg, MQTT_TOPICOUT, system_get_chip_id());
MQTT_Subscribe(client, MQTT_WATCHDOG, 0);
MQTT_Subscribe(client, tempreg, 1);
application_heartbeat();
}
void mqttConnectedCb(uint32_t *args)
{
MQTT_Client* client = (MQTT_Client*)args;
INFO("MQTT: Connected\r\n");
MQTT_Subscribe(client, "/LASS/886/00/06/g500001/cmd", 0); //command channel
MQTT_Subscribe(client, "/mqtt/timestamp", 1);
MQTT_Subscribe(client, "/mqtt/echo", 2);
// MQTT_Publish(client, "/LASS/886/00/06/g500001/pm3", "hello0", 6, 0, 0);
// MQTT_Publish(client, "/LASS/886/00/06/g500001/alive", "hello1", 6, 1, 0);
// MQTT_Publish(client, "/886/00/06/g500001/2", "hello2", 6, 2, 0);
}
void mqttConnectedCb(uint32_t *args)
{
MQTT_Client* client = (MQTT_Client*)args;
INFO("MQTT: Connected\r\n");
MQTT_Subscribe(client, "/mqtt/topic/0", 0);
MQTT_Subscribe(client, "/mqtt/topic/1", 1);
MQTT_Subscribe(client, "/mqtt/topic/2", 2);
MQTT_Publish(client, "/mqtt/topic/0", "hello0", 6, 0, 0);
MQTT_Publish(client, "/mqtt/topic/1", "hello1", 6, 1, 0);
MQTT_Publish(client, "/mqtt/topic/2", "hello2", 6, 2, 0);
}
void ICACHE_FLASH_ATTR subscribeDevTopic(MQTT_Client* client, char *subTopic) {
char stopic[40];
APP_INFO("Subscribe device topic, queue size before (%d/%d)\r\n", client->msgQueue.rb.fill_cnt, client->msgQueue.rb.size);
os_sprintf(stopic, "%s/%s", deviceTopic, subTopic);
BOOL result = MQTT_Subscribe(client, stopic, 2);
APP_INFO("Subscribe device topic result: %d, queue size after (%d/%d)\r\n", result, client->msgQueue.rb.fill_cnt, client->msgQueue.rb.size);
}
void ICACHE_FLASH_ATTR
MQTTCMD_Subscribe(CmdPacket *cmd) {
CmdRequest req;
cmdRequest(&req, cmd);
if (cmdGetArgc(&req) != 2) return;
MQTT_Client* client = &mqttClient;
uint16_t len;
// get topic
len = cmdArgLen(&req);
if (len > 128) return; // safety check
uint8_t* topic = (uint8_t*)os_zalloc(len + 1);
cmdPopArg(&req, topic, len);
topic[len] = 0;
// get qos
uint32_t qos = 0;
cmdPopArg(&req, (uint8_t*)&qos, 4);
DBG("MQTT: MQTTCMD_Subscribe topic=%s, qos=%u\n", topic, qos);
MQTT_Subscribe(client, (char*)topic, (uint8_t)qos);
os_free(topic);
return;
}
void ICACHE_FLASH_ATTR mqttConnectedCb(uint32_t *args)
{
MQTT_Client* client = (MQTT_Client*)args;
INFO("MQTT: Connected\r\n");
MQTT_Subscribe(client, MQTT_ROOMBA_CMD_TOPIC, 0);
mqtt_advertise(client);
}
void mqttConnectedCb(uint32_t *args)
{
MQTT_Client* client = (MQTT_Client*)args;
INFO("MQTT: Connected\r\n");
MQTT_Subscribe(client, "proxy/esp_8266/receive", 0);
MQTT_Publish(client, "esp_8266/send", "Hello, I am ESP 8266.", 21, 0, 0);
MQTT_Publish(client, "esp_8266/send", "I am now connected to AWS IoT.", 30, 0, 0);
}
static void ICACHE_FLASH_ATTR mqttConnectedCb(uint32_t *args)
{
DEBUG_PRINT("[MQTT]Connected\n");
MQTT_Client* client = (MQTT_Client*)args;
char aux[20];
os_sprintf(aux, "echo/%d", system_get_chip_id());
MQTT_Subscribe(client, aux, 0);
if (mqttConnected) mqttConnected(client);
}
void ICACHE_FLASH_ATTR mqttConnectedCb(uint32_t *args) {
char topic[100];
MQTT_Client* client = (MQTT_Client*) args;
mqttConnected = true;
INFOP("MQTT is Connected to %s:%d\n", sysCfg.mqtt_host, sysCfg.mqtt_port);
os_sprintf(topic, "/Raw/%s/set/#", sysCfg.device_id);
INFOP("Subscribe to: %s\n", topic);
MQTT_Subscribe(client, topic, 0);
os_sprintf(topic, "/Raw/%s/+/set/filter", sysCfg.device_id);
INFOP("Subscribe to: %s\n", topic);
MQTT_Subscribe(client, topic, 0);
MQTT_Subscribe(client, "/App/#", 0);
publishDeviceInfo(client);
publishData(client);
os_timer_disarm(&switch_timer);
os_timer_setfn(&switch_timer, (os_timer_func_t *) switchTimerCb, NULL);
os_timer_arm(&switch_timer, 100, true);
os_timer_disarm(&display_timer);
os_timer_setfn(&display_timer, (os_timer_func_t *) displayCb, NULL);
os_timer_arm(&display_timer, 2000, true);
os_timer_disarm(&date_timer);
os_timer_setfn(&date_timer, (os_timer_func_t *) dateTimerCb, NULL);
os_timer_arm(&date_timer, 10 * 60 * 1000, false); //10 minutes
os_timer_disarm(&transmit_timer);
os_timer_setfn(&transmit_timer, (os_timer_func_t *) transmitCb, (void *) client);
os_timer_arm(&transmit_timer, sysCfg.updates * 1000, true);
lightOff();
}
void ICACHE_FLASH_ATTR mqttConnectedCb(uint32_t *args)
{
MQTT_Client* client = (MQTT_Client*)args;
INFO("MQTT: Connected\r\n");
MQTT_Subscribe(&mqttClient, PIN_GPIO5_TOPIC, 0);
MQTT_Subscribe(&mqttClient, PIN_GPIO12_TOPIC, 0);
MQTT_Subscribe(&mqttClient, PIN_GPIO14_TOPIC, 0);
MQTT_Subscribe(&mqttClient, BR_BOILER_SET, 0);
MQTT_Subscribe(&mqttClient, BR_TEMP_ROOM_SET, 0);
MQTT_Subscribe(&mqttClient, BR_HUMIDITY_SET, 0);
MQTT_Subscribe(&mqttClient, BR_MODE, 0);/**/
dDEVICE_MODE=0;
INFO("Device MODE set to AUTO !\r\n");
}
void ICACHE_FLASH_ATTR object_connect_pool(uint32_t* _mqtt_client)
{
struct object* object;
const struct property_config* obj_prop;
struct property* property = (struct property*)os_zalloc(sizeof(struct property));
char *topic;
for(object=global_objects; object->config != NULL; ++object)
{
object->mqtt_client = (MQTT_Client*)_mqtt_client;
property->object = object;
// Subscribe to all properties (with MQTT_SUB)
for(obj_prop=object->config->properties; obj_prop->name != NULL; ++obj_prop)
{
if((obj_prop->flags & PROP_MQTT_SUB) != 0)
{
property->config = obj_prop;
property_create_topic(property, &topic);
MQTT_Subscribe((MQTT_Client*)_mqtt_client, topic, 0);
property_free_topic(&topic);
}
}
// Publish to all properties (with MQTT_PUB)
for(obj_prop=object->config->properties; obj_prop->name != NULL; ++obj_prop)
{
if((obj_prop->flags & PROP_MQTT_PUB) != 0)
{
property->config = obj_prop;
object_property_notify(property);
}
}
// Call the connect callback
if(object->config->connect != NULL)
object->config->connect(object);
}
os_free(property);
}
static void mqttConnectedCb(uint32_t *args)
{
MQTT_Client* client = (MQTT_Client*)args;
MQTT_DBG("MQTT: Connected");
int i;
for(i=0;i<relay_count();i++){
char * setTopic = (char *)os_zalloc(strlen(relays[i].topic)+strlen(MQTT_RELAY_SET_SUFIX)+1);
os_strcpy(setTopic,relays[i].topic);
os_strcat(setTopic,MQTT_RELAY_SET_SUFIX);
MQTT_Subscribe(client, setTopic, 1);
os_free(setTopic);
mqtt_relay_change_cb(i,-1); //force 1st publish
}
}
uint32_t ICACHE_FLASH_ATTR
MQTTCMD_Subscribe(CmdPacket *cmd) {
CmdRequest req;
CMD_Request(&req, cmd);
if (CMD_GetArgc(&req) != 3)
return 0;
// get mqtt client
uint32_t client_ptr;
CMD_PopArg(&req, (uint8_t*)&client_ptr, 4);
MQTT_Client* client = (MQTT_Client*)client_ptr;
#ifdef MQTTCMD_DBG
os_printf("MQTT: MQTTCMD_Subscribe client ptr=%p\n", (void*)client_ptr);
#endif
uint16_t len;
uint8_t* topic;
uint32_t qos = 0;
// get topic
len = CMD_ArgLen(&req);
if (len > 128) return 0; // safety check
topic = (uint8_t*)os_zalloc(len + 1);
CMD_PopArg(&req, topic, len);
topic[len] = 0;
// get qos
CMD_PopArg(&req, (uint8_t*)&qos, 4);
#ifdef MQTTCMD_DBG
os_printf("MQTT: MQTTCMD_Subscribe topic=%s, qos=%ld\n", topic, qos);
#endif
MQTT_Subscribe(client, (char*)topic, (uint8_t)qos);
os_free(topic);
return 1;
}
void ICACHE_FLASH_ATTR
mqttConnectedCb(uint32_t *args) {
MQTT_Client* client = (MQTT_Client*) args;
INFO("MQTT: Connected! will use %s as MQTT topic \n", clientid);
char *buf = " ";
int i = 0;
for (i=0; i<6; i++){
os_sprintf(buf, "/lcd%1d", i);
MQTT_Subscribe(client, buf, 0);
os_sprintf(buf, "%s/lcd%1d", clientid, i);
MQTT_Subscribe(client, buf, 0);
}
MQTT_Subscribe(client, "/lcd/clearscreen", 0);
os_sprintf(buf, "%s/clearscreen", clientid);
MQTT_Subscribe(client, buf, 0);
MQTT_Subscribe(client, "/lcd/contrast", 0);
os_sprintf(buf, "%s/contrast", clientid);
MQTT_Subscribe(client, buf, 0);
}
bool MQTT::subscribe(const String& topic, uint8_t qos)
{
return MQTT_Subscribe(&mqttClient, (char*)topic.c_str(), qos);
}
bool MQTT::subscribe(const char* topic, uint8_t qos)
{
return MQTT_Subscribe(&mqttClient, (char*)topic, qos);
}
void ICACHE_FLASH_ATTR mqttConnectedCb(uint32_t *args){
MQTT_Client* client = (MQTT_Client*)args;
INFO("MQTT: Connected\n");
MQTT_Subscribe(client, MQTT_TOPIC_NEXA_BRIDGE_SEND, 0);
}
void ICACHE_FLASH_ATTR mqttConnectedCb(uint32_t *args)
{
MQTT_Client* client = (MQTT_Client*)args;
INFO("MQTT: Connected\r\n");
MQTT_Subscribe(&mqttClient, PIN_GPIO4_TOPIC, 0);
}
static void on_mqtt_connected(uint32_t *args)
{
dmesg("Hello, world!");
MQTT_InitLWT(&mqtt_client, TOPIC_DMESG, "Goodbye, cruel world!", 0, 1);
MQTT_Subscribe(&mqtt_client, TOPIC_CONTROL, 0);
}
/*******************************************************************************
* Main
*
********************************************************************************/
int main(int argc, char** argv)
{
IoT_Error_t rc = NONE_ERROR;
int32_t i = 0;
int ret =0;
char rootCA[PATH_MAX + 1];
char clientCRT[PATH_MAX + 1];
char clientKey[PATH_MAX + 1];
char CurrentWD[PATH_MAX + 1];
char cafileName[] = "/rootCA.crt";
char clientCRTName[] = "/aws.crt";
char clientKeyName[] = "/aws.key";
char* thingID;
//
//Register ctrl-c handler
//
signal(SIGINT, CTRL_C_Handler);
//
//Parse Input-parameters
//
parseInputArgsForConnectParams(argc, argv);
//
// Get the ThingID/MachineID
//
thingID = GetMachineID();
//
// Export GPIO12 for LED output
//
ret = Export_GPIO(GPIO12); //Export GPIO12 for LED output
if (ret != 0) {
ERROR("Could not export LED GPIO");
}
//
//Register Event-handler for Vol+/- button
//
ret = RegisterEventHandler(VOL_UP_EVENT, On_VolUp_ButtonPress, (void*) thingID);
if (ret != 0) {
ERROR("Could not register EventHandler");
}
ret = RegisterEventHandler(VOL_DOWN_EVENT, On_VolDown_ButtonPress,(void*) thingID);
if (ret != 0) {
ERROR("Could not register EventHandler");
}
//
//Create the mainloop for polling the button events
//
loop = g_main_loop_new( NULL, false );
if(!loop) {
ERROR("Could not Create Main loop");
return -1;
}
//
//Setting path to private key and certificates
//
sprintf(rootCA, "%s%s", certDirectory, cafileName);
sprintf(clientCRT, "%s%s", certDirectory, clientCRTName);
sprintf(clientKey, "%s%s", certDirectory, clientKeyName);
INFO("ThingID: %s", thingID);
INFO("AWS IoT SDK: %d.%d.%d-%s", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, VERSION_TAG);
INFO("rootCA: %s", rootCA);
INFO("clientCRT: %s", clientCRT);
INFO("clientKey: %s\n", clientKey);
struct stat reqFileStat;
if (stat(rootCA, &reqFileStat) < 0 || stat(clientCRT, &reqFileStat) < 0 ||
stat(clientKey, &reqFileStat) < 0)
{
ERROR("Root certificate and client certificate and key MUST be present.");
exit(1);
}
//
// Connect MQTT client
//
INFO("Connecting to %s:%d", HostAddress, port);
rc = MQTT_Connect(HostAddress,port, thingID, rootCA, clientCRT, clientKey);
if (NONE_ERROR != rc) {
ERROR("Error[%d] connecting to %s:%d", rc, HostAddress, port);
}
//
// Subscribe to LED status-changes topic
//
char topic[512];
sprintf(topic, led_state_sub_topic, thingID);
INFO("Subscribing to topic:%s", topic);
rc = MQTT_Subscribe(topic, QOS_0, MQTTcallbackHandler);
if (NONE_ERROR != rc) {
ERROR("Error[%d] subscribing to topic: %s", rc, led_state_sub_topic);
}
//iot_mqtt_yield(1000); //TODO: clarify
//
//Hook in a function into main loop that calls iot_mqtt_yield in regular intervals
//
g_timeout_add(1000, timer_func, 0);
//
//start the main loop
//This call is blocking until the main loop is exited with a call to g_main_loop_quit(loop)
//from the CTRL-C handler;
INFO("Entering main-loop, please press ctrl-c to quit the demo-app:");
g_main_loop_run( loop );
INFO("Cleaning up application ...");
//Unsubscribe from Topics
//Disconnect MQTT connection
//Unregister GPIO-EventHandlers
//UnExport GPIO's
//Destroy main loop
if(loop)
g_main_loop_unref(loop);
return rc;
}
