void signal_usr(int sd, struct mosquitto *mosq) { struct device *dev; if (user_signal == MODULES_BRIDGE_SIGUSR1) { if (config.remap_usr1_dev) { dev = bridge_get_device(&bridge, config.remap_usr1_dev); if (dev) { snprintf(gbuf, GBUF_SIZE, "%s%s,%s,%d,%s,%d", SERIAL_INIT_CONFIG, dev->id, bridge.bridge_dev->id, PROTOCOL_MD_OPTIONS, config.remap_usr1_md, config.remap_usr1_md_code); serialport_send(sd, gbuf); } } else if (connected) { snprintf(gbuf, GBUF_SIZE, "%d,%s,%d", PROTOCOL_MD_OPTIONS, MODULES_BRIDGE_ID, MODULES_BRIDGE_SIGUSR1); mqtt_publish(mosq, bridge.bridge_dev->status_topic, gbuf); } } if (user_signal == MODULES_BRIDGE_SIGUSR2) { if (config.remap_usr2_dev) { dev = bridge_get_device(&bridge, config.remap_usr2_dev); if (dev) { snprintf(gbuf, GBUF_SIZE, "%s%s,%s,%d,%s,%d", SERIAL_INIT_CONFIG, dev->id, bridge.bridge_dev->id, PROTOCOL_MD_OPTIONS, config.remap_usr2_md, config.remap_usr2_md_code); serialport_send(sd, gbuf); } } else if (connected) { snprintf(gbuf, GBUF_SIZE, "%d,%s,%d", PROTOCOL_MD_OPTIONS, MODULES_BRIDGE_ID, MODULES_BRIDGE_SIGUSR2); mqtt_publish(mosq, bridge.bridge_dev->status_topic, gbuf); } } user_signal = 0; }
/** * \brief Checking the USART buffer. * * Finding the new line character(\n or \r\n) in the USART buffer. * If buffer was overflowed, Sending the buffer. */ static void check_usart_buffer(char *topic) { int i; /* Publish the input string when newline was received or input string is bigger than buffer size limit. */ if (uart_buffer_written >= MAIN_CHAT_BUFFER_SIZE) { mqtt_publish(&mqtt_inst, topic, uart_buffer, MAIN_CHAT_BUFFER_SIZE, 0, 0); uart_buffer_written = 0; } else { for (i = 0; i < uart_buffer_written; i++) { /* Find newline character ('\n' or '\r\n') and publish the previous string . */ if (uart_buffer[i] == '\n') { mqtt_publish(&mqtt_inst, topic, uart_buffer, (i > 0 && uart_buffer[i - 1] == '\r') ? i - 1 : i, 0, 0); /* Move remain data to start of the buffer. */ if (uart_buffer_written > i + 1) { memmove(uart_buffer, uart_buffer + i + 1, uart_buffer_written - i - 1); uart_buffer_written = uart_buffer_written - i - 1; } else { uart_buffer_written = 0; } break; } } } }
/**@brief Publishes LED state to MQTT broker. * * @param[in] led_state LED state being published. */ static void app_mqtt_publish(bool led_state) { mqtt_topic_t topic; mqtt_data_t data; char topic_desc[] = "led/state"; topic.p_topic = (uint8_t *)topic_desc; topic.topic_len = strlen(topic_desc); data.data_len = 1; data.p_data = (uint8_t *)&led_state; uint32_t err_code = mqtt_publish(&m_app_mqtt_id,&topic, &data); APPL_LOG("[APPL]: mqtt_publish result 0x%08lx\r\n", err_code); if (err_code == MQTT_SUCCESS) { LEDS_INVERT(LED_FOUR); m_led_state = !m_led_state; } else { // Flash LED_THREE if error occurs. LEDS_ON(LED_THREE); err_code = app_timer_start(m_led_blink_timer, LED_BLINK_INTERVAL, NULL); APP_ERROR_CHECK(err_code); } }
void send_alive(struct mosquitto *mosq) { static unsigned int beacon_num = 1; snprintf(gbuf, GBUF_SIZE, "%d,%d,%d,%d", PROTOCOL_ALIVE, bridge.bridge_dev->modules, beacon_num, 30); if (mqtt_publish(mosq, bridge.bridge_dev->status_topic, gbuf)) beacon_num++; }
int main (int argc, char** argv) { puts("MQTT PUB Test Code"); if(argc > 1) { parse_options(argc, argv); } // mqtt_broker_handle_t *broker = mqtt_connect("default_pub","127.0.0.1", 1883); mqtt_broker_handle_t *broker = mqtt_connect(client_name, ip_addr, port); if(broker == 0) { puts("Failed to connect"); exit(1); } char msg[128]; for(int i = 1; i <= count; ++i) { sprintf(msg, "Message number %d", i); if(mqtt_publish(broker, topic, msg, QoS1) == -1) { printf("publish failed\n"); } else { printf("Sent %d messages\n", i); } sleep(1); } mqtt_disconnect(broker); }
void handleMotor(ArduinoCustom_motor motor, char* originator) { unsigned int len = 0; memset(buffer,0,300); if (len = sw_acknowledge(hardwareId, "motor received.", buffer, sizeof(buffer), originator)) { mqtt_publish(&broker_mqtt,outbound,(char*)buffer,len,0); } }
static void *mqtt_pub_thread(void *param) { MQTTPacket_connectData condata = MQTTPacket_connectData_initializer; int rc; unsigned char rbuf[64]; unsigned char wbuf[64]; DEBUG("pub thread start\n"); /* */ _cpub.rbuf = rbuf; _cpub.rbuflen = sizeof(rbuf); _cpub.wbuf = wbuf; _cpub.wbuflen = sizeof(wbuf); _cpub.getfn = pub_read; if ((_cpub.sockfd = mqtt_netconnect(HOSTNAME, HOSTPORT)) < 0) { DEBUG("pub netconnet fail\n"); return 0; } DEBUG("pub connect to: %s %d\n", HOSTNAME, HOSTPORT); condata.clientID.cstring = "mqttpub"; condata.keepAliveInterval = KEEPALIVE_INTERVAL; condata.cleansession = 1; condata.username.cstring = USERNAME; condata.password.cstring = PASSWORD; rc = mqtt_connect(&_cpub, &condata); if (rc < 0) goto exit; DEBUG("pub connect ok\n"); mqtt_ping_start(&_cpub.sockfd); while (rc == 0) { mqtt_msg_t msg; SLEEP(5); msg.dup = 0; msg.id = 0; msg.qos = 0; msg.retained = 0; msg.payload = (unsigned char*)"RT-Thread"; msg.payloadlen = strlen((const char*)msg.payload); rc = mqtt_publish(&_cpub, TOPIC, &msg); } exit: mqtt_netdisconnect(&_cpub.sockfd); DEBUG("pub thread exit\n"); return 0; }
void example_publish(mqtt_client_t *client, void *arg) { const char *pub_payload= "PubSubHubLubJub"; err_t err; u8_t qos = 2; /* 0 1 or 2, see MQTT specification */ u8_t retain = 0; /* No don't retain such crappy payload... */ err = mqtt_publish(client, "pub_topic", pub_payload, strlen(pub_payload), qos, retain, mqtt_pub_request_cb, arg); if(err != ERR_OK) { printf("Publish err: %d\n", err); } }
static void mqtt_service_event(input_event_t *event, void *priv_data) { if (event->type != EV_SYS) { return; } if (event->code != CODE_SYS_ON_MQTT_READ) { return; } LOG("mqtt_service_event!"); mqtt_publish(priv_data); }
/** Handle the 'serialPrintln' command */ void handleSerialPrintln(ArduinoCustom_serialPrintln serialPrintln,char* originator) { unsigned int len = 0; memset(buffer,0,300); OLED_Init(); char oled_show_line[OLED_DISPLAY_MAX_CHAR_PER_ROW+1] = {'\0'}; baseEvents_log("%s",serialPrintln.message); snprintf(oled_show_line, OLED_DISPLAY_MAX_CHAR_PER_ROW+1, "%s",serialPrintln.message); OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_3, (uint8_t*)oled_show_line); if (len = sw_acknowledge(hardwareId, "Message sent to Serial.println().", buffer, sizeof(buffer), originator)) { mqtt_publish(&broker_mqtt,outbound,(char*)buffer,len,0); } }
void serial_hang(struct mosquitto *mosq) { struct module *md; bridge.serial_ready = false; bridge.serial_alive = 0; if (connected) { md = device_get_module(&bridge, MODULE_SERIAL_ID); if (md) { mqtt_publish(mosq, md->topic, "0"); // Serial is down message } } }
void serial_hang(struct mosquitto *mosq) { struct module *md; bridge.serial_ready = false; bridge.serial_alive = 0; if (connected) { md = bridge_get_module(bridge.bridge_dev, MODULES_SERIAL_ID); if (md) { snprintf(gbuf, GBUF_SIZE, "%d", MODULES_SERIAL_ERROR); mqtt_publish(mosq, md->topic, gbuf); } } }
static void mqtt_trigger_notify(class trigger *trig, bool state) { class output_trigger *out = static_cast<class output_trigger *>(trig); struct mqtt_trigger_data *data; data = (struct mqtt_trigger_data *)out->data; if (!data) { Serial.printf("%s: no data for trigger\n", __func__); return; } if (true) { Serial.printf("trigger %p state %d\n", trig, state); Serial.printf("trigger topic %s state %d\n", data->topic, state); } mqtt_publish(data->topic, state ? "1" : "0"); }
/* * Subscribe the topic: IOT_MQTT_Subscribe(pclient, TOPIC_DATA, IOTX_MQTT_QOS1, _demo_message_arrive, NULL); * Publish the topic: IOT_MQTT_Publish(pclient, TOPIC_DATA, &topic_msg); */ static void mqtt_work(void *parms) { int rc = -1; if (is_subscribed == 0) { /* Subscribe the specific topic */ rc = mqtt_subscribe(TOPIC_GET, mqtt_sub_callback, NULL); if (rc < 0) { // IOT_MQTT_Destroy(&pclient); LOG("IOT_MQTT_Subscribe() failed, rc = %d", rc); } is_subscribed = 1; aos_schedule_call(ota_init, NULL); } #ifndef MQTT_PRESS_TEST else { /* Generate topic message */ int msg_len = snprintf(msg_pub, sizeof(msg_pub), "{\"attr_name\":\"temperature\", \"attr_value\":\"%d\"}", cnt); if (msg_len < 0) { LOG("Error occur! Exit program"); } rc = mqtt_publish(TOPIC_UPDATE, IOTX_MQTT_QOS1, msg_pub, msg_len); if (rc < 0) { LOG("error occur when publish"); } LOG("packet-id=%u, publish topic msg=%s", (uint32_t)rc, msg_pub); } cnt++; if (cnt < 200) { aos_post_delayed_action(3000, mqtt_work, NULL); } else { aos_cancel_delayed_action(3000, mqtt_work, NULL); mqtt_unsubscribe(TOPIC_GET); aos_msleep(200); mqtt_deinit_instance(); is_subscribed = 0; cnt = 0; } #endif }
int mqtt_publish_bandwidth(struct mosquitto *mosq, char *topic) { int payload_len; char *payload; if (!topic) return 1; if (config.debug > 1) printf("down: %f - up: %f\n", downspeed, upspeed); payload_len = snprintf(NULL, 0, "%.0f,%.0f", upspeed, downspeed); if ((payload = (char *)malloc((payload_len + 1)* (sizeof(char)))) == NULL) { fprintf(stderr, "Error: No memory left.\n"); return -1; } snprintf(payload, payload_len + 1, "%.0f,%.0f", upspeed, downspeed); mqtt_publish(mosq, topic, payload); free(payload); return 0; }
/** Handle the 'testEvents' command */ void handleTestEvents(ArduinoCustom_testData testEvents, char* originator) { unsigned int len = 0; memset(buffer,0,300); memset(cmdd,0,sizeof(cmdd)); cmdd[0].engine.temp="humidity"; cmdd[0].engine.value = testEvents.humidity; cmdd[1].engine.temp="temperature"; cmdd[1].engine.value = testEvents.temperature; cmdd[2].engine.temp="infrared"; cmdd[2].engine.value = testEvents.infrared; cmdd[3].engine.temp="light"; cmdd[3].engine.value = testEvents.light; if (len = sw_measurement(hardwareId,&cmdd[0],4,NULL, buffer, sizeof(buffer), originator)) { mqtt_publish(&broker_mqtt,outbound,(char*)buffer,len,0); } }
void on_mqtt_connect(struct mosquitto *mosq, void *obj, int result) { int rc; if (!result) { connected = true; if(config.debug != 0) printf("MQTT Connected.\n"); rc = mosquitto_subscribe(mosq, NULL, bridge.config_topic, config.mqtt_qos); if (rc) { fprintf(stderr, "MQTT - Subscribe ERROR: %s\n", mosquitto_strerror(rc)); run = 0; return; } snprintf(gbuf, GBUF_SIZE, "%d,%d", PROTO_ST_ALIVE, bridge.modules_len); mqtt_publish(mosq, bridge.status_topic, gbuf); return; } else { fprintf(stderr, "MQTT - Failed to connect: %s\n", mosquitto_connack_string(result)); } }
void itc_mqtt_publish_p(void) { int res; g_mqtt_client_handle = mqtt_init_client(&g_mqtt_client_config); TC_ASSERT_NEQ("mqtt_init_client", g_mqtt_client_handle, NULL); res = mqtt_connect(g_mqtt_client_handle, CONFIG_ITC_MQTT_BROKER_ADDR, CONFIG_ITC_MQTT_BROKER_PORT, 0); TC_ASSERT_EQ_CLEANUP("mqtt_connect", res, 0, mqtt_deinit_client(g_mqtt_client_handle)); ITC_MQTT_WAIT_SIGNAL; res = mqtt_publish(g_mqtt_client_handle, ITC_MQTT_TOPIC, g_mqtt_msg, sizeof(g_mqtt_msg), 0, 0); TC_ASSERT_EQ_CLEANUP("mqtt_publish", res, 0, mqtt_disconnect(g_mqtt_client_handle); mqtt_deinit_client(g_mqtt_client_handle)); ITC_MQTT_WAIT_SIGNAL; res = mqtt_disconnect(g_mqtt_client_handle); TC_ASSERT_EQ_CLEANUP("mqtt_disconnect", res, 0, mqtt_deinit_client(g_mqtt_client_handle)); ITC_MQTT_WAIT_SIGNAL; res = mqtt_deinit_client(g_mqtt_client_handle); TC_ASSERT_EQ("mqtt_deinit_client", res, 0); TC_SUCCESS_RESULT(); }
void signal_usr(int sd, struct mosquitto *mosq) { struct device *md_dev; struct module *md; char md_id[DEVICE_MD_ID_SIZE + 1]; if (user_signal == MODULE_SIGUSR1) { if (config.remap_usr1) strcpy(md_id, config.remap_usr1); else strcpy(md_id, MODULE_SIGUSR1_ID); } else if (user_signal == MODULE_SIGUSR2) { if (config.remap_usr2) strcpy(md_id, config.remap_usr2); else strcpy(md_id, MODULE_SIGUSR2_ID); } md = device_get_module(&bridge, md_id); if (md) { md_dev = device_get(&bridge, md->device); if (!md_dev) { fprintf(stderr, "Error: Orphan module.\n"); device_remove_module(&bridge, md_id); user_signal = 0; return; } if (md_dev->md_deps->type == MODULE_SERIAL && bridge.serial_ready) { snprintf(gbuf, GBUF_SIZE, "%s%s,%d,%s", SERIAL_INIT_MSG, md_dev->id, PROTO_MD_RAW, md->id); serialport_printlf(sd, gbuf); } if (connected) mqtt_publish(mosq, md->topic, "1"); } user_signal = 0; }
void publish_temp(int temp) { int retCode = 0; if (serverConnected == 0) { server_connect(1); } // construct message initJsonMsg(pubMsgStr); addIntValToMsg("t", temp, pubMsgStr); finishJsonMsg(pubMsgStr); // publish message printf("Publish: %s\n", pubMsgStr); retCode = mqtt_publish(&broker, pubTopic, pubMsgStr, 0); if (retCode < 0) { printf("Failed to publish data!\n"); } }
static void mqtt_sub_callback(char *topic, int topic_len, void *payload, int payload_len, void *ctx) { LOG("----"); LOG("Topic: '%.*s' (Length: %d)", topic_len, topic, topic_len); LOG("Payload: '%.*s' (Length: %d)", payload_len, (char *)payload, payload_len); LOG("----"); #ifdef MQTT_PRESS_TEST sub_counter++; int rc = mqtt_publish(TOPIC_UPDATE, IOTX_MQTT_QOS1, payload, payload_len); if (rc < 0) { LOG("IOT_MQTT_Publish fail, ret=%d", rc); } else { pub_counter++; } LOG("RECV=%d, SEND=%d", sub_counter, pub_counter); #endif MQTT_PRESS_TEST }
/* Implementation of the client process */ PROCESS_THREAD(rako_bridge_process, ev, data) { static uint8_t in_buffer[64]; static uint8_t out_buffer[64]; static char topic[64]; static uip_ip6addr_t* address; static mqtt_connect_info_t connect_info = { .client_id = "contiki", .username = NULL, .password = NULL, .will_topic = NULL, .will_message = NULL, .keepalive = 60, .will_qos = 0, .will_retain = 0, .clean_session = 1, }; PROCESS_BEGIN(); PRINTF("Myha started\n"); if(ev == PROCESS_EVENT_INIT) { address = myha_get_mqtt_address(); rako_init(); mqtt_init(in_buffer, sizeof(in_buffer), out_buffer, sizeof(out_buffer)); mqtt_connect(address, UIP_HTONS(1883), 1, &connect_info); } for(;;) { PROCESS_WAIT_EVENT(); if(ev == PROCESS_EVENT_EXIT) { mqtt_disconnect(); } else if(ev == mqtt_event) { if(mqtt_event_is_connected(data)) { PRINTF("Myha: MQTT connected\n"); sprintf_P(topic, PSTR("%s/name"), myha_get_node_id()); mqtt_publish(topic, "Rako Bridge", 0, 0); PROCESS_WAIT_EVENT_UNTIL(ev == mqtt_event); sprintf_P(topic, PSTR("%s/+/set/+"), myha_get_node_id()); PRINTF("Myha: subscribing: %s...\n", topic); mqtt_subscribe(topic); PROCESS_WAIT_EVENT_UNTIL(ev == mqtt_event); PRINTF(" done.\n"); } else if(mqtt_event_is_disconnected(data)) { PRINTF("Myha: MQTT disconnected\n"); } else if(mqtt_event_is_publish(data)) { int house, room, channel; char* name; const char* topic = mqtt_event_get_topic(data); const char* message = mqtt_event_get_data(data); PRINTF("Myha: got publish: %s = %s\n", topic, message); if(split_set_topic(topic, &house, &room, &channel, &name) == 0) { if(strcmp_P(name, PSTR("set/level")) == 0) { int level = atoi(message); rako_send_level(house, room, channel, level); PRINTF("Myha: sending level: %u\n", level); PROCESS_WAIT_EVENT_UNTIL(ev == rako_sent_event); PRINTF("Myha: done\n"); } else if(strcmp_P(name, PSTR("set/scene")) == 0) { int scene = atoi(message); if(scene == 0) rako_send_off(house, room, channel); else rako_send_scene(house, room, channel, scene); PRINTF("Myha: sending rako scene command, house: %u, room: %u, channel: %u\n", house, room, channel); PROCESS_WAIT_EVENT_UNTIL(ev == rako_sent_event); PRINTF("Myha: done\n"); } else PRINTF("Myha: not level: %s\n", name); } else PRINTF("Myha: split failed\n"); } } else if(ev == rako_cmd_event) { rako_cmd_t* cmd = (rako_cmd_t*)data; if(cmd->command == RAKO_CMD_SCENE_SET) { char message[4]; get_device_topic(topic, cmd->house, cmd->room, 0, "scene"); sprintf(message, "%u", cmd->data); mqtt_publish(topic, message, 0, 0); } else if(cmd->command == RAKO_CMD_OFF) { get_device_topic(topic, cmd->house, cmd->room, 0, "scene"); mqtt_publish(topic, "0", 0, 0); } } else if(ev == rako_recv_event) { rako_msg_t* msg = (rako_msg_t*)data; PRINTF("RAKO: received: raw: %08lx, house: %u, room: %u\n", msg->raw, msg->command.house, msg->command.room); } else if(ev == rako_sent_event) { PRINTF("RAKO: sent\n"); } } PROCESS_END(); }
bool MqttClient::publish(String topic, String message, bool retained /* = false*/) { int res = mqtt_publish(&broker, topic.c_str(), message.c_str(), retained); return res > 0; }
void app_parse_mqttmsg(uint8_t *packet_buffer) { uint8_t msg_type = 0; uint16_t msg_id_rcv = 0; char topic_name[56]={0}; char msg[128]={0}; msg_type = MQTTParseMessageType(packet_buffer); //printf("-----> parse:0x%02X\n", msg_type); switch(msg_type) { case MQTT_MSG_CONNACK: if(packet_buffer[3] == 0) { printf("Mqtt login server success\n"); /* subscribe */ init_topic(&g_sub_topic, sub_topic_name, sizeof(sub_topic_name)); mqtt_subscribe(&g_stMQTTBroker, g_sub_topic->name, &(g_sub_topic->msg_id)); /* publish msg with Qos 0 */ //step1:>>>publish init_topic(&g_pub_topic1, pub_topic_name1, sizeof(pub_topic_name1)); mqtt_publish(&g_stMQTTBroker, g_pub_topic1->name, pub_msg1, 0); printf("APP publish msg[%s] with Qos 0\n", pub_msg1); deinit_topic(&g_pub_topic1); /* publish msg with Qos 1 */ //step1:>>>publish //step2:<<<puback init_topic(&g_pub_topic2, pub_topic_name2, sizeof(pub_topic_name2)); mqtt_publish_with_qos(&g_stMQTTBroker, g_pub_topic2->name, pub_msg2, 0, 1, &(g_pub_topic2->msg_id)); } else printf("Mqtt login server fail!\n"); break; case MQTT_MSG_SUBACK: msg_id_rcv = mqtt_parse_msg_id(packet_buffer); if(g_sub_topic && msg_id_rcv == g_sub_topic->msg_id) printf("Subcribe topic[%s] success\n", g_sub_topic->name); break; case MQTT_MSG_PUBLISH: mqtt_parse_pub_topic(packet_buffer, topic_name); mqtt_parse_publish_msg(packet_buffer, msg); printf("****** Topic[%s] recv msg: *****\n%s\n",topic_name, msg); /* unsubscribe */ if(!strcmp(g_sub_topic->name, topic_name)) mqtt_unsubscribe(&g_stMQTTBroker, g_sub_topic->name, &(g_sub_topic->msg_id)); break; case MQTT_MSG_UNSUBACK: msg_id_rcv = mqtt_parse_msg_id(packet_buffer); if(g_sub_topic && msg_id_rcv == g_sub_topic->msg_id) { printf("Unsubcribe topic[%s] success\n", g_sub_topic->name); deinit_topic(&g_sub_topic); } break; case MQTT_MSG_PUBACK://Qos1 msg_id_rcv = mqtt_parse_msg_id(packet_buffer); if(g_pub_topic2 && msg_id_rcv == g_pub_topic2->msg_id) { printf("APP publish msg[%s] with Qos 1\n", pub_msg2); deinit_topic(&g_pub_topic2); /* publish msg with Qos 2 */ //step1:>>>publish //step2:<<<pubrec //step3:>>>pubrel //step4:<<<pubcomp init_topic(&g_pub_topic3, pub_topic_name3, sizeof(pub_topic_name3)); mqtt_publish_with_qos(&g_stMQTTBroker, g_pub_topic3->name, pub_msg3, 1, 2, &(g_pub_topic3->msg_id)); } break; case MQTT_MSG_PUBREC://Qos2 msg_id_rcv = mqtt_parse_msg_id(packet_buffer); if(g_pub_topic3 && msg_id_rcv == g_pub_topic3->msg_id) mqtt_pubrel(&g_stMQTTBroker, g_pub_topic3->msg_id); break; case MQTT_MSG_PUBCOMP://Qos2 msg_id_rcv = mqtt_parse_msg_id(packet_buffer); if(g_pub_topic3 && msg_id_rcv == g_pub_topic3->msg_id) { printf("APP publish msg[%s] with Qos 2\n", pub_msg3); deinit_topic(&g_pub_topic3); } break; default: printf("Unknow mqtt msg type\n"); break; } }
/**@brief Timer callback used for publishing simulated temperature periodically. * */ static void app_xively_publish_callback(iot_timer_time_in_ms_t wall_clock_value) { UNUSED_PARAMETER(wall_clock_value); uint32_t err_code; // Check if data transfer is enabled. if (m_do_publication == false) { return; } // Check if connection has been established. if (m_connection_state == false) { return; } // Reset temperature to initial state. if (m_temperature == APP_DATA_MAXIMUM_TEMPERATURE) { m_temperature = APP_DATA_INITIAL_TEMPERATURE; } // Prepare data in JSON format. sprintf(m_data_body, APP_MQTT_XIVELY_DATA_FORMAT, m_temperature); mqtt_publish_param_t param; param.message.topic.qos = MQTT_QoS_0_AT_MOST_ONCE; param.message.topic.topic.p_utf_str = (uint8_t *)APP_MQTT_XIVELY_API_URL; param.message.topic.topic.utf_strlen = strlen(APP_MQTT_XIVELY_API_URL); param.message.payload.p_bin_str = (uint8_t *)m_data_body; param.message.payload.bin_strlen = strlen(m_data_body); param.message_id = m_message_counter; param.dup_flag = 0; param.retain_flag = 0; APPL_LOG("[APPL]: Publishing value of %02d.00\r\n", m_temperature); // Publish data. err_code = mqtt_publish(&m_app_mqtt_id, ¶m); // Check if there is no pending transaction. if(err_code != (NRF_ERROR_BUSY | IOT_MQTT_ERR_BASE)) { APP_ERROR_CHECK(err_code); m_message_counter += 2; } // Change leds to indicate actual data that has been sent. switch(m_temperature % 4) { case 0: LEDS_OFF(LED_THREE | LED_FOUR); break; case 1: LEDS_ON(LED_FOUR); LEDS_OFF(LED_THREE); break; case 2: LEDS_ON(LED_THREE); LEDS_OFF(LED_FOUR); break; case 3: LEDS_ON(LED_THREE | LED_FOUR); break; } // Increase temperature value. m_temperature++; APPL_LOG("[APPL]: mqtt_publish result 0x%08lx\r\n", err_code); }
/**@brief Timer callback used for publishing simulated temperature periodically. * */ static void app_xively_publish_callback(iot_timer_time_in_ms_t wall_clock_value) { UNUSED_PARAMETER(wall_clock_value); uint32_t err_code; // Check if data transfer is enabled. if (m_do_publication == false) { return; } // Check if connection has been established. if (m_connection_state == false) { return; } // Reset temperature to initial state. if (m_temperature == APP_DATA_MAXIMUM_TEMPERATURE) { m_temperature = APP_DATA_INITIAL_TEMPERATURE; } // Prepare data in JSON format. sprintf(m_data_body, APP_MQTT_XIVELY_DATA_FORMAT, m_temperature); // Create MQTT topic. mqtt_topic_t topic; topic.p_topic = (uint8_t *)APP_MQTT_XIVELY_API_URL; topic.topic_len = strlen(APP_MQTT_XIVELY_API_URL); // Create MQTT data. mqtt_data_t data; data.p_data = (uint8_t *)m_data_body; data.data_len = strlen(m_data_body); APPL_LOG("[APPL]: Publishing value of %02d.00\r\n", m_temperature); // Publish data. err_code = mqtt_publish(&m_app_mqtt_id, &topic, &data); // Check if there is no pending transaction. if(err_code != MQTT_ERR_BUSY) { APP_ERROR_CHECK(err_code); } // Change leds to indicate actual data that has been sent. switch(m_temperature % 4) { case 0: LEDS_OFF(LED_THREE | LED_FOUR); break; case 1: LEDS_ON(LED_FOUR); LEDS_OFF(LED_THREE); break; case 2: LEDS_ON(LED_THREE); LEDS_OFF(LED_FOUR); break; case 3: LEDS_ON(LED_THREE | LED_FOUR); break; } // Increase temperature value. m_temperature++; APPL_LOG("[APPL]: mqtt_publish result 0x%08lx\r\n", err_code); }
/*---------------------------------------------------------------------------*/ static void publish(void) { /* Publish MQTT topic in IBM quickstart format */ int len; int remaining = APP_BUFFER_SIZE; seq_nr_value++; buf_ptr = app_buffer; len = snprintf(buf_ptr, remaining, "{\"nb\":%d,\"t\":%lu,\"rssi\":%d", seq_nr_value, clock_seconds(), def_rt_rssi); if(len < 0 || len >= remaining) { printf("Buffer too short. Have %d, need %d + \\0\n", remaining, len); return; } remaining -= len; buf_ptr += len; /* Put our Default route's string representation in a buffer char def_rt_str[64]; memset(def_rt_str, 0, sizeof(def_rt_str)); cc26xx_web_demo_ipaddr_sprintf(def_rt_str, sizeof(def_rt_str), uip_ds6_defrt_choose()); len = snprintf(buf_ptr, remaining, ",\"Def Route\":\"%s\"", def_rt_str); if(len < 0 || len >= remaining) { printf("Buffer too short. Have %d, need %d + \\0\n", remaining, len); return; } remaining -= len; buf_ptr += len; memcpy(&def_route, uip_ds6_defrt_choose(), sizeof(uip_ip6addr_t)); */ for(reading = cc26xx_web_demo_sensor_first(); reading != NULL; reading = reading->next) { if(reading->publish && reading->raw != CC26XX_SENSOR_READING_ERROR) { len = snprintf(buf_ptr, remaining, ",\"%s\":%s", reading->form_field, reading->converted); if(len < 0 || len >= remaining) { printf("Buffer too short. Have %d, need %d + \\0\n", remaining, len); return; } remaining -= len; buf_ptr += len; } } len = snprintf(buf_ptr, remaining, "}"); if(len < 0 || len >= remaining) { printf("Buffer too short. Have %d, need %d + \\0\n", remaining, len); return; } mqtt_publish(&conn, NULL, pub_topic, (uint8_t *)app_buffer, strlen(app_buffer), MQTT_QOS_LEVEL_0, MQTT_RETAIN_OFF); DBG("APP - Publish!\n"); }
int main(int argc, char* argv[]) { int packet_length; uint16_t msg_id, msg_id_rcv; mqtt_broker_handle_t broker; mqtt_init(&broker, "sancho"); mqtt_init_auth(&broker, "quijote", "rocinante"); init_socket(&broker, "192.168.10.40", 1883, keepalive); // >>>>> CONNECT mqtt_connect(&broker); // <<<<< CONNACK packet_length = read_packet(1); if(packet_length < 0) { fprintf(stderr, "Error(%d) on read packet!\n", packet_length); return -1; } if(MQTTParseMessageType(packet_buffer) != MQTT_MSG_CONNACK) { fprintf(stderr, "CONNACK expected!\n"); return -2; } if(packet_buffer[3] != 0x00) { fprintf(stderr, "CONNACK failed!\n"); return -2; } // >>>>> PUBLISH QoS 0 printf("Publish: QoS 0\n"); mqtt_publish(&broker, "public/myexample/example", "Test libemqtt message.", 0); // >>>>> PUBLISH QoS 1 printf("Publish: QoS 1\n"); mqtt_publish_with_qos(&broker, "hello/emqtt", "Example: QoS 1", 0, 1, &msg_id); // <<<<< PUBACK packet_length = read_packet(1); if(packet_length < 0) { fprintf(stderr, "Error(%d) on read packet!\n", packet_length); return -1; } if(MQTTParseMessageType(packet_buffer) != MQTT_MSG_PUBACK) { fprintf(stderr, "PUBACK expected!\n"); return -2; } MQTTParseMessageId(packet_buffer, msg_id_rcv); if(msg_id != msg_id_rcv) { fprintf(stderr, "%d message id was expected, but %d message id was found!\n", msg_id, msg_id_rcv); return -3; } // >>>>> PUBLISH QoS 2 printf("Publish: QoS 2\n"); mqtt_publish_with_qos(&broker, "hello/emqtt", "Example: QoS 2", 1, 2, &msg_id); // Retain // <<<<< PUBREC packet_length = read_packet(1); if(packet_length < 0) { fprintf(stderr, "Error(%d) on read packet!\n", packet_length); return -1; } if(MQTTParseMessageType(packet_buffer) != MQTT_MSG_PUBREC) { fprintf(stderr, "PUBREC expected!\n"); return -2; } MQTTParseMessageId(packet_buffer, msg_id_rcv); if(msg_id != msg_id_rcv) { fprintf(stderr, "%d message id was expected, but %d message id was found!\n", msg_id, msg_id_rcv); return -3; } // >>>>> PUBREL mqtt_pubrel(&broker, msg_id); // <<<<< PUBCOMP packet_length = read_packet(1); if(packet_length < 0) { fprintf(stderr, "Error(%d) on read packet!\n", packet_length); return -1; } if(MQTTParseMessageType(packet_buffer) != MQTT_MSG_PUBCOMP) { fprintf(stderr, "PUBCOMP expected!\n"); return -2; } MQTTParseMessageId(packet_buffer, msg_id_rcv); if(msg_id != msg_id_rcv) { fprintf(stderr, "%d message id was expected, but %d message id was found!\n", msg_id, msg_id_rcv); return -3; } // >>>>> DISCONNECT mqtt_disconnect(&broker); close_socket(&broker); return 0; }
//--------------------------------------------------------------------------- void send(char *str1, char *str2) { mqtt_publish(str1, str2, strlen(str2), 1 /* (retain) */); }
void App_WhiskerGW() { char pubTopic[100]; char pubMsg[250]; unsigned char msgType; int counter=0; char cntStr[20]; char commandBuffer[64]; int commandBufferPointer=0; led_all_off(); // Give the unit a little time to start up // (300 ms for GS1011 and 1000 ms for GS1500) MSTimerDelay(1000); NVSettingsLoad(&GNV_Setting); led_on(4); WIFI_init(1); // Show MAC address and Version led_on(5); WIFI_Associate(); led_on(6); DisplayLCD(LCD_LINE8, "Demo starting."); DisplayLCD(LCD_LINE3, (const uint8_t *)WifiMAC); // UART if(spiUartInitialize()!=0) { DisplayLCD(LCD_LINE7, "!! SPIUART_ERROR !!"); while(1) { led_all_on(); MSTimerDelay(250); led_all_off(); MSTimerDelay(250); } } while (1) { // Do we need to connect to the AP? if (!AtLibGs_IsNodeAssociated()) { led_off(6); WIFI_Associate(); led_on(6); } else { if(mqttConnected==0) App_ConnectMqtt(); int charCount = spiUartRxBytesAvailable(); while(charCount>0) { commandBuffer[commandBufferPointer++] = spiUartGetByte(); charCount--; if(charCount==0) commandBufferPointer=0; if(commandBufferPointer>4) { if(strstr(commandBuffer,"RMPU")==commandBuffer) { if(commandBufferPointer>24) { // process response char macStr[9]; char lenStr[5]; memcpy(macStr,&commandBuffer[6],8); macStr[8] = 0; memcpy(lenStr,&commandBuffer[4],2); lenStr[2]=0; int len = (int)strtol(lenStr,0,16); unsigned long mac = strtoul(macStr,NULL,16); WhiskerModule *wm = findModule(mac); if(wm!=0) { if(commandBufferPointer>len+16) { char rssiStr[3]; memcpy(rssiStr,&commandBuffer[commandBufferPointer-3],2); rssiStr[2]=0; int rssi = (int)strtol(rssiStr,0,16); if((rssi & 0x80) == 0x80) rssi-=256; int puMsgPointer=14; mqtt_initJsonMsg(pubMsg); mqtt_addStringValToMsg("Name",wm->Name,pubMsg,0); mqtt_addStringValToMsg("Mac",macStr,pubMsg,1); char rstr[8]; sprintf(rstr,"%d dbm",rssi); mqtt_addStringValToMsg("Rssi",rstr,pubMsg,1); sprintf(pubMsg+strlen(pubMsg),",\"Values\":{"); puMsgPointer=14; int comma=0; while(puMsgPointer < (commandBufferPointer-3)) { char cidStr[3]; memcpy(cidStr,&commandBuffer[puMsgPointer],2); puMsgPointer+=2; cidStr[2]=0; unsigned char cid=(unsigned char)strtol(cidStr,0,16); unsigned char channel = cid & 0x1f; char valStr[9]; long valInt; switch(cid) { case 0x21: //digital input memcpy(valStr,&commandBuffer[puMsgPointer],2); valStr[2]=0; puMsgPointer+=2; valInt = (int)strtol(valStr,0,16); if(valInt) mqtt_addStringValToMsg("DIN1","True",pubMsg,comma); else mqtt_addStringValToMsg("DIN1","False",pubMsg,comma); break; case 0x22: //digital input memcpy(valStr,&commandBuffer[puMsgPointer],2); valStr[2]=0; puMsgPointer+=2; valInt = (int)strtol(valStr,0,16); if(valInt) mqtt_addStringValToMsg("DIN2","True",pubMsg,comma); else mqtt_addStringValToMsg("DIN2","False",pubMsg,comma); break; case 0x43: //battery analog in memcpy(valStr,&commandBuffer[puMsgPointer],4); valStr[4]=0; puMsgPointer+=4; valInt = (int)strtol(valStr,0,16); mqtt_addIntValToMsg("Battery",valInt,pubMsg,comma); break; case 0x44: //battery analog in memcpy(valStr,&commandBuffer[puMsgPointer],4); valStr[4]=0; puMsgPointer+=4; valInt = (int)strtol(valStr,0,16); mqtt_addIntValToMsg("Temperature",valInt,pubMsg,comma); break; case 0x45: //battery analog in memcpy(valStr,&commandBuffer[puMsgPointer],4); valStr[4]=0; puMsgPointer+=4; valInt = (int)strtol(valStr,0,16); mqtt_addIntValToMsg("RH",valInt,pubMsg,comma); break; case 0x5d: //internal temperature memcpy(valStr,&commandBuffer[puMsgPointer],4); valStr[4]=0; puMsgPointer+=4; valInt = (int)strtol(valStr,0,16); mqtt_addIntValToMsg("IntTemp",valInt,pubMsg,comma); break; case 0x57: //air quality memcpy(valStr,&commandBuffer[puMsgPointer],4); valStr[4]=0; puMsgPointer+=4; valInt = (int)strtol(valStr,0,16); mqtt_addIntValToMsg("AirQual",valInt,pubMsg,comma); break; case 0x58: //air quality memcpy(valStr,&commandBuffer[puMsgPointer],4); valStr[4]=0; puMsgPointer+=4; valInt = (int)strtol(valStr,0,16); mqtt_addIntValToMsg("AirQual",valInt,pubMsg,comma); break; case 0x61: // digital counter input memcpy(valStr,&commandBuffer[puMsgPointer],4); valStr[4]=0; puMsgPointer+=4; valInt = (int)strtol(valStr,0,16); mqtt_addIntValToMsg("Count1",valInt,pubMsg,comma); break; case 0x62: // digital counter input memcpy(valStr,&commandBuffer[puMsgPointer],4); valStr[4]=0; puMsgPointer+=4; valInt = (int)strtol(valStr,0,16); mqtt_addIntValToMsg("Count2",valInt,pubMsg,comma); break; } comma=1; } sprintf(pubMsg+strlen(pubMsg),"}"); mqtt_finishJsonMsg(pubMsg); sprintf(pubTopic, "%s/%s", WIO_DOMAIN, macStr); int res=mqtt_publish(&broker, pubTopic, pubMsg,0)<0; if(res<0) mqttConnected=0; led_on(8); //spiUartResetFIFO(); } } } } } } // Send data if RSSIReading(); AtLibGs_WaitForTCPMessage(1000); led_off(7); led_off(8); if(G_receivedCount>0) { AtLibGs_ParseTCPData(G_received,G_receivedCount,&rxm); msgType = MQTTParseMessageType(rxm.message); switch(msgType) { case MQTT_MSG_SUBACK: // todo: display subscription acknowledgement break; case MQTT_MSG_PUBLISH: App_MQTTMsgPublished(); break; case MQTT_MSG_PUBACK: // todo: display publish acknowledgement break; default: break; } } counter++; sprintf(cntStr,"Counter=%d",counter); DisplayLCD(LCD_LINE6,cntStr); if(counter>30) { counter=0; sprintf(pubTopic, "%s/%s", WIO_DOMAIN, WifiMAC); mqtt_initJsonMsg(pubMsg); mqtt_addStringValToMsg("msg","status ok",pubMsg,0); mqtt_finishJsonMsg(pubMsg); int res1=mqtt_publish(&broker, pubTopic, pubMsg,0)<0; if(res1<0) mqttConnected=0; led_on(7); } } // Send data if END } }