IoT_Error_t aws_iot_mqtt_subscribe(MQTTSubscribeParams *pParams) { IoT_Error_t rc = NONE_ERROR; if (0 != MQTTSubscribe(&c, pParams->pTopic, (enum QoS)pParams->qos, pahoMessageCallback, (void (*)(void))(pParams->mHandler))) { rc = SUBSCRIBE_ERROR; } return rc; }
/** * Function used to subscribe to all commands. This function is by default called when in registered mode. * * @return int return code */ int subscribeCommands(Iotfclient *client) { int rc = -1; rc = MQTTSubscribe(&client->c, "iot-2/cmd/+/fmt/+", QOS0, messageArrived); return rc; }
int main(int argc, char** argv) { int rc = 0; unsigned char buf[1024]; unsigned char readbuf[1024]; Network n; Client c; signal(SIGINT, cfinish); signal(SIGTERM, cfinish); NewNetwork(&n); ConnectNetwork(&n, "eu.airvantage.net", 1883); MQTTClient(&c, &n, 1000, buf, 1024, readbuf, 1024); MQTTPacket_connectData data = MQTTPacket_connectData_initializer; data.willFlag = 0; data.MQTTVersion = 3; data.clientID.cstring = deviceId; data.username.cstring = "00000000B6AF4A9D"; data.password.cstring = "toto"; data.keepAliveInterval = 10000; data.cleansession = 1; printf("Connecting to %s %d\n", "tcp://eu.airvantage.net", 1883); rc = MQTTConnect(&c, &data); printf("Connected %d\n", rc); char* topic = malloc(strlen(deviceId)+13); sprintf(topic, "%s/tasks/json", deviceId); printf("Subscribing to %s\n", topic); rc = MQTTSubscribe(&c, topic, 0, messageArrived); printf("Subscribed %d\n", rc); int err1 = pthread_create(&reading_tid, NULL, &readMeasuresHandler, (void*)&c); int err2 = pthread_create(&uploading_tid, NULL, &uploadMeasuresHandler, (void*) &c); if(err1 != 0 || err2 != 0) printf("Can't create simulator (%s, %d)\n", strerror(err1), err2); else { while (!toStop) { MQTTYield(&c, 1000); } } printf("Stopping\n"); MQTTDisconnect(&c); n.disconnect(&n); return 0; }
static enum cmd_status cmd_mqtt_subscribe_exec(char *cmd) { int32_t cnt; uint32_t i; char *tmp; uint32_t qos; int rc; /* get param */ cnt = cmd_sscanf(cmd, "qos=%u", &qos); if ((tmp = cmd_strrchr(cmd, '\"')) == NULL) return CMD_STATUS_INVALID_ARG; *tmp = '\0'; if ((tmp = cmd_strchr(cmd, '\"')) == NULL) return CMD_STATUS_INVALID_ARG; tmp++; /* check param */ if (cnt != 1) { CMD_ERR("invalid param number %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (qos > 2) { CMD_ERR("invalid qos %d\n", qos); return CMD_STATUS_INVALID_ARG; } i = 0; while (sub_topic[i] != NULL) { i++; if (i >= MAX_SUB_TOPICS) { CMD_WRN("Subscribe topics is max\n"); return CMD_STATUS_FAIL; } } sub_topic[i] = cmd_malloc(cmd_strlen(tmp) + 1); cmd_memcpy(sub_topic[i], tmp, cmd_strlen(tmp) + 1); if (OS_MutexLock(&lock, 60000) == OS_E_TIMEOUT) return CMD_STATUS_FAIL; if ((rc = MQTTSubscribe(&client, sub_topic[i], qos, mqtt_msg_cb)) != 0) { CMD_ERR("Return code from MQTT subscribe is %d\n", rc); return CMD_STATUS_FAIL; } OS_MutexUnlock(&lock); return CMD_STATUS_OK; }
static void prvMQTTEchoTask(void *pvParameters) { /* connect to m2m.eclipse.org, subscribe to a topic, send and receive messages regularly every 1 sec */ MQTTClient client; Network network; unsigned char sendbuf[80], readbuf[80]; int rc = 0, count = 0; MQTTPacket_connectData connectData = MQTTPacket_connectData_initializer; pvParameters = 0; platform_network_init(&network); MQTTClientInit(&client, &network, 30000, sendbuf, sizeof(sendbuf), readbuf, sizeof(readbuf)); char* address = "iot.eclipse.org"; if ((rc = platform_network_connect(&network, address, 1883)) != 0) printf("Return code from network connect is %d\n", rc); #if defined(MQTT_TASK) if ((rc = MQTTStartTask(&client)) != pdPASS) printf("Return code from start tasks is %d\n", rc); #endif connectData.MQTTVersion = 3; connectData.clientID.cstring = "FreeRTOS_sample"; if ((rc = MQTTConnect(&client, &connectData)) != 0) printf("Return code from MQTT connect is %d\n", rc); else printf("MQTT Connected\n"); if ((rc = MQTTSubscribe(&client, "FreeRTOS/sample/#", 2, messageArrived)) != 0) printf("Return code from MQTT subscribe is %d\n", rc); while (++count) { MQTTMessage message; char payload[30]; message.qos = 1; message.retained = 0; message.payload = payload; sprintf(payload, "message number %d", count); message.payloadlen = strlen(payload); if ((rc = MQTTPublish(&client, "FreeRTOS/sample/a", &message)) != 0) printf("Return code from MQTT publish is %d\n", rc); #if !defined(MQTT_TASK) if ((rc = MQTTYield(&client, 1000)) != 0) printf("Return code from yield is %d\n", rc); #endif } /* do not return */ }
static inline void mqtt_task() { struct Network network; char client_id[20]; uint8_t mqtt_buf[100]; uint8_t mqtt_readbuf[100]; MQTTPacket_connectData data = MQTTPacket_connectData_initializer; NewNetwork( &network ); strcpy(client_id, "esp-gizmo-ir"); if (ConnectNetwork(&network, config_get_mqtt_host(), config_get_mqtt_port()) != 0) { printf("Connect to MQTT server failed\n"); return; } NewMQTTClient(&mqtt_client, &network, 5000, mqtt_buf, 100, mqtt_readbuf, 100); data.willFlag = 0; data.MQTTVersion = 3; data.clientID.cstring = client_id; data.username.cstring = NULL; data.password.cstring = NULL; data.keepAliveInterval = 10; data.cleansession = 0; printf("Send MQTT connect ... \n"); if (MQTTConnect(&mqtt_client, &data) != 0) { printf("MQTT connect failed\n"); return; } const char *topic = config_get_cmd_topic(); printf("Sibscribe to topic: %s\n", topic); if (MQTTSubscribe(&mqtt_client, topic, QOS1, topic_received) != 0) { printf("Subscription failed\n"); return; } while (MQTTYield(&mqtt_client, 1000) != DISCONNECTED) { printf("free heap: %d bytes\n", xPortGetFreeHeapSize()); uint16_t free_stack = uxTaskGetStackHighWaterMark(xTaskGetCurrentTaskHandle()); printf("minimum free stack: %d bytes\n", free_stack); }; printf("Connection dropped, request restart\n"); }
/* * Function used to subscribe to all commands. This function is by default called when in registered mode. * * @return int return code */ int subscribeCommands_dm() { int rc = -1; rc = subscribeCommands(&dmClient.deviceClient); if(rc >=0){ Client *c; c= &(dmClient.deviceClient.c); // Call back handles all the requests and responses received from the Watson IoT platform rc = MQTTSubscribe(c, "iotdm-1/#", QOS0, onMessage); printf("Actions subscription :%d\n",rc); }else{ printf("iotf subscribe failed "); } return rc; }
int Cpush_subscribing(unsigned int clientHandle, unsigned char* topic, unsigned char qos, int (*cb_fn)(struct Message*)) { if ((0 == clientHandle)||(NULL == topic)||(qos>2)) { return CPUSH_RET_ERROR_PARA; } Client* client = (Client*)clientHandle; int rc = MQTTSubscribe(client,(const char*)topic,qos,cb_fn); if (FAILURE == rc) { printf("Cpush_subscribing fail! ret:%d", rc); return CPUSH_RET_FAIL; } printf("Cpush_subscribing OK!"); return CPUSH_RET_OK; }
/* * Function used to subscribe to all commands. This function is by default called when in registered mode. * * @param client reference to the ManagedDevice * * @return int return code */ int subscribeCommands_dm(ManagedDevice *client) { int rc = -1; rc = subscribeCommands(&deviceClient); if(rc >=0){ Client *c; c= &(deviceClient.c); rc = MQTTSubscribe(c, "iotdm-1/response", QOS0, messageCame); rc = MQTTSubscribe(c, "iotdm-1/observe", QOS0, messageCame); rc = MQTTSubscribe(c, "iotdm-1/cancel", QOS0, messageCame); rc = MQTTSubscribe(c, "iotdm-1/mgmt/initiate/device/reboot", QOS0, messageCame); rc = MQTTSubscribe(c, "iotdm-1/mgmt/initiate/device/factory_reset", QOS0, messageCame); rc = MQTTSubscribe(c, "iotdm-1/mgmt/initiate/firmware/download", QOS0, messageCame); rc = MQTTSubscribe(c, "iotdm-1/mgmt/initiate/firmware/update", QOS0, messageCame); rc = MQTTSubscribe(c, "iotdm-1/device/update", QOS0, messageCame); }else{ printf("iotf subscribe faild "); } return rc; }
static void mqtt_client_thread(void *pvParameters) { char *payload = NULL; MQTTClient client; Network network; int rc = 0; char clientID[32] = {0}; uint32_t count = 0; ESP_LOGI(TAG, "ssid:%s passwd:%s sub:%s qos:%u pub:%s qos:%u pubinterval:%u payloadsize:%u", CONFIG_WIFI_SSID, CONFIG_WIFI_PASSWORD, CONFIG_MQTT_SUB_TOPIC, CONFIG_DEFAULT_MQTT_SUB_QOS, CONFIG_MQTT_PUB_TOPIC, CONFIG_DEFAULT_MQTT_PUB_QOS, CONFIG_MQTT_PUBLISH_INTERVAL, CONFIG_MQTT_PAYLOAD_BUFFER); ESP_LOGI(TAG, "ver:%u clientID:%s keepalive:%d username:%s passwd:%s session:%d level:%u", CONFIG_DEFAULT_MQTT_VERSION, CONFIG_MQTT_CLIENT_ID, CONFIG_MQTT_KEEP_ALIVE, CONFIG_MQTT_USERNAME, CONFIG_MQTT_PASSWORD, CONFIG_DEFAULT_MQTT_SESSION, CONFIG_DEFAULT_MQTT_SECURITY); ESP_LOGI(TAG, "broker:%s port:%u", CONFIG_MQTT_BROKER, CONFIG_MQTT_PORT); ESP_LOGI(TAG, "sendbuf:%u recvbuf:%u sendcycle:%u recvcycle:%u", CONFIG_MQTT_SEND_BUFFER, CONFIG_MQTT_RECV_BUFFER, CONFIG_MQTT_SEND_CYCLE, CONFIG_MQTT_RECV_CYCLE); MQTTPacket_connectData connectData = MQTTPacket_connectData_initializer; NetworkInit(&network); if (MQTTClientInit(&client, &network, 0, NULL, 0, NULL, 0) == false) { ESP_LOGE(TAG, "mqtt init err"); vTaskDelete(NULL); } payload = malloc(CONFIG_MQTT_PAYLOAD_BUFFER); if (!payload) { ESP_LOGE(TAG, "mqtt malloc err"); } else { memset(payload, 0x0, CONFIG_MQTT_PAYLOAD_BUFFER); } for (;;) { ESP_LOGI(TAG, "wait wifi connect..."); xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, false, true, portMAX_DELAY); if ((rc = NetworkConnect(&network, CONFIG_MQTT_BROKER, CONFIG_MQTT_PORT)) != 0) { ESP_LOGE(TAG, "Return code from network connect is %d", rc); continue; } connectData.MQTTVersion = CONFIG_DEFAULT_MQTT_VERSION; sprintf(clientID, "%s_%u", CONFIG_MQTT_CLIENT_ID, esp_random()); connectData.clientID.cstring = clientID; connectData.keepAliveInterval = CONFIG_MQTT_KEEP_ALIVE; connectData.username.cstring = CONFIG_MQTT_USERNAME; connectData.password.cstring = CONFIG_MQTT_PASSWORD; connectData.cleansession = CONFIG_DEFAULT_MQTT_SESSION; ESP_LOGI(TAG, "MQTT Connecting"); if ((rc = MQTTConnect(&client, &connectData)) != 0) { ESP_LOGE(TAG, "Return code from MQTT connect is %d", rc); network.disconnect(&network); continue; } ESP_LOGI(TAG, "MQTT Connected"); #if defined(MQTT_TASK) if ((rc = MQTTStartTask(&client)) != pdPASS) { ESP_LOGE(TAG, "Return code from start tasks is %d", rc); } else { ESP_LOGI(TAG, "Use MQTTStartTask"); } #endif if ((rc = MQTTSubscribe(&client, CONFIG_MQTT_SUB_TOPIC, CONFIG_DEFAULT_MQTT_SUB_QOS, messageArrived)) != 0) { ESP_LOGE(TAG, "Return code from MQTT subscribe is %d", rc); network.disconnect(&network); continue; } ESP_LOGI(TAG, "MQTT subscribe to topic %s OK", CONFIG_MQTT_SUB_TOPIC); for (;;) { MQTTMessage message; message.qos = CONFIG_DEFAULT_MQTT_PUB_QOS; message.retained = 0; message.payload = payload; sprintf(payload, "message number %d", ++count); message.payloadlen = strlen(payload); if ((rc = MQTTPublish(&client, CONFIG_MQTT_PUB_TOPIC, &message)) != 0) { ESP_LOGE(TAG, "Return code from MQTT publish is %d", rc); } else { ESP_LOGI(TAG, "MQTT published topic %s, len:%u heap:%u", CONFIG_MQTT_PUB_TOPIC, message.payloadlen, esp_get_free_heap_size()); } if (rc != 0) { break; } vTaskDelay(CONFIG_MQTT_PUBLISH_INTERVAL / portTICK_RATE_MS); } network.disconnect(&network); } ESP_LOGW(TAG, "mqtt_client_thread going to be deleted"); vTaskDelete(NULL); return; }
static void mqtt_task(void *pvParameters) { int ret = 0; struct Network network; MQTTClient client = DefaultClient; char mqtt_client_id[20]; uint8_t mqtt_buf[100]; uint8_t mqtt_readbuf[100]; MQTTPacket_connectData data = MQTTPacket_connectData_initializer; NewNetwork( &network ); memset(mqtt_client_id, 0, sizeof(mqtt_client_id)); strcpy(mqtt_client_id, "ESP-"); strcat(mqtt_client_id, get_my_id()); while(1) { xSemaphoreTake(wifi_alive, portMAX_DELAY); printf("%s: started\n\r", __func__); printf("%s: (Re)connecting to MQTT server %s ... ",__func__, MQTT_HOST); ret = ConnectNetwork(&network, MQTT_HOST, MQTT_PORT); if( ret ){ printf("error: %d\n\r", ret); taskYIELD(); continue; } printf("done\n\r"); NewMQTTClient(&client, &network, 5000, mqtt_buf, 100, mqtt_readbuf, 100); data.willFlag = 0; data.MQTTVersion = 3; data.clientID.cstring = mqtt_client_id; data.username.cstring = MQTT_USER; data.password.cstring = MQTT_PASS; data.keepAliveInterval = 10; data.cleansession = 0; printf("Send MQTT connect ... "); ret = MQTTConnect(&client, &data); if(ret){ printf("error: %d\n\r", ret); DisconnectNetwork(&network); taskYIELD(); continue; } printf("done\r\n"); MQTTSubscribe(&client, "/esptopic", QOS1, topic_received); xQueueReset(publish_queue); while(1){ char msg[PUB_MSG_LEN - 1] = "\0"; while(xQueueReceive(publish_queue, (void *)msg, 0) == pdTRUE){ printf("got message to publish\r\n"); MQTTMessage message; message.payload = msg; message.payloadlen = PUB_MSG_LEN; message.dup = 0; message.qos = QOS1; message.retained = 0; ret = MQTTPublish(&client, "/beat", &message); if (ret != SUCCESS ){ printf("error while publishing message: %d\n", ret ); break; } } ret = MQTTYield(&client, 1000); if (ret == DISCONNECTED) break; } printf("Connection dropped, request restart\n\r"); DisconnectNetwork(&network); taskYIELD(); } }
/* * Application's entry point dynamic schedule. Main is somewhat too large because of the MQTT stuff * allmighty whileloop */ int main(int argc, char** argv) { /* Stop WDT and initialize lcd, clcks, main interfaces */ stopWDT(); init_clocks(); //init clock for LCD init_lcd(); initClk(); //init clock for wifi Delay(5); init_main(); Delay(5); load_data(); int rc = 0; unsigned char buf[100]; unsigned char readbuf[100]; NewNetwork(&n); rc = ConnectNetwork(&n, MQTT_BROKER_SERVER, 1883); if (rc != 0) { CLI_Write(" Failed to connect to MQTT broker \n\r"); } MQTTClient(&hMQTTClient, &n, 1000, buf, 100, readbuf, 100); MQTTPacket_connectData cdata = MQTTPacket_connectData_initializer; cdata.MQTTVersion = 3; cdata.clientID.cstring = "daniel"; rc = MQTTConnect(&hMQTTClient, &cdata); if (rc != 0) { CLI_Write(" Failed to start MQTT client \n\r"); //LOOP_FOREVER(); } rc = MQTTSubscribe(&hMQTTClient, SUBSCRIBE_TOPIC, QOS0, messageArrived); if (rc != 0) { CLI_Write(" Failed to subscribe to /msp/cc3100/demo topic \n\r"); //LOOP_FOREVER(); } MQTTYield(&hMQTTClient, 10); int8_t buffer[2] = "on"; MQTTMessage msg; msg.dup = 0; msg.id = 0; msg.payload = buffer; msg.payloadlen = 8; msg.qos = QOS0; msg.retained = 0; MQTTPublish(&hMQTTClient, PUBLISH_TOPIC, &msg); Delay(20); backlight_off(); while(1) { MQTTYield(&hMQTTClient, 10); debounce++; if(send_goal_bool) { int8_t buffer2[15] = " "; sprintf(buffer2, "%d", goal_steps); msg; msg.dup = 0; msg.id = 0; msg.payload = buffer2; msg.payloadlen = 15; msg.qos = QOS0; msg.retained = 0; MQTTPublish(&hMQTTClient, PUBLISH_TOPIC, &msg); Delay(20); send_goal_bool = 0; }else if(send_on_bool) { int8_t buffer2[2] = "on"; msg; msg.dup = 0; msg.id = 0; msg.payload = buffer2; msg.payloadlen = 2; msg.qos = QOS0; msg.retained = 0; MQTTPublish(&hMQTTClient, PUBLISH_TOPIC, &msg); Delay(20); send_on_bool = 0; } else if( (P3IN & BIT5) == 0 && debounce > 20) { debounce = 0; menu_select(); } else if ( (P1IN & BIT4) == 0 && debounce > 10) { debounce = 0; menu(); } else if ( steps_taken >= goal_steps && active_bool == 1 ) { P1OUT &= ~BIT0; int8_t buffer2[1] = "g"; msg; msg.dup = 0; msg.id = 0; msg.payload = buffer2; msg.payloadlen = 1; msg.qos = QOS0; msg.retained = 0; MQTTPublish(&hMQTTClient, "on", &msg); Delay(20); MAP_Interrupt_disableInterrupt(INT_ADC14); active_bool = 0; view_goal_menu(); } } }
int cycle(Client* c, Timer* timer) { // read the socket, see what work is due int read_status; unsigned short packet_type; read_status = readPacket(c, timer); packet_type = (unsigned short )read_status; if(read_status == SOCKET_CLOSED) { MQTTReConnect(c); goto exit; } int len = 0, rc = SUCCESS; switch (packet_type) { case CONNACK: { { unsigned char connack_rc = 255; char sessionPresent = 0; if (MQTTDeserialize_connack((unsigned char*)&sessionPresent, &connack_rc, c->readbuf, c->readbuf_size) == 1) { c->isconnected = 1; //开cloud灯 system(SET_LIGHT_CLOUD); log_printf(LOG_NOTICE, "[MqttConnected]: recv connack\n"); //subtopics and pubtopics init sprintf(&subtopics[0][0], "%s%s", SUBTOPIC_PRE1, gateway_info.did); sprintf(&subtopics[1][0], "%s%s", SUBTOPIC_PRE2, gateway_info.productkey); sprintf(&subtopics[2][0], "%s%s/#", SUBTOPIC_PRE3, gateway_info.did); sprintf(&pubtopics[0][0], "%s%s", PUBTOPIC_PRE1, gateway_info.did); sprintf(&pubtopics[1][0], "%s%s", PUBTOPIC_PRE2, gateway_info.did); sprintf(&pubtopics[2][0], "%s%s/#", PUBTOPIC_PRE3, gateway_info.did); rc = MQTTSubscribe(c, subtopics[c->suborder], 0, mh[c->suborder]); //for test log_printf(LOG_NOTICE, "Subscribing to %s\n", subtopics[c->suborder]); c->suborder++; } } } break; case PUBACK: break; case SUBACK: { int count = 0, grantedQoS = -1; unsigned short mypacketid; if (MQTTDeserialize_suback(&mypacketid, 1, &count, &grantedQoS, c->readbuf, c->readbuf_size) == 1) rc = grantedQoS; // 0, 1, 2 or 0x80 if (rc != 0x80) { if(c->suborder <subscribe_over) { rc = MQTTSubscribe(c, subtopics[c->suborder], 0, mh[c->suborder]); log_printf(LOG_NOTICE, "Subscribing to %s\n",subtopics[c->suborder]); c->suborder++; } // int i; // for (i = 0; i < MAX_MESSAGE_HANDLERS; ++i) // { // if (c->messageHandlers[i].topicFilter == 0) // { // c->messageHandlers[i].topicFilter = mytopics[i]; // c->messageHandlers[i].fp = mh[i]; // rc = 0; // break; // } // } } else { log_printf(LOG_ERROR, "SUCACK FAILED\n"); //TODO: error handle } } break; case PUBLISH: { if(c->suborder != subscribe_over) { log_printf(LOG_ERROR, "[REC_MSG] rece publish msg but subcribe not over\n"); //TODO: error } MQTTString topicName = MQTTString_initializer; MQTTMessage msg; if (MQTTDeserialize_publish((unsigned char*)&msg.dup, (int*)&msg.qos, (unsigned char*)&msg.retained, (unsigned short*)&msg.id, &topicName, (unsigned char**)&msg.payload, (int*)&msg.payloadlen, c->readbuf, c->readbuf_size) != 1) goto exit; deliverMessage(c, &topicName, &msg); // MQTTPublish(c, "applerespond", &msg); //add by yaly for test if (msg.qos != QOS0) { if (msg.qos == QOS1) len = MQTTSerialize_ack(c->buf, c->buf_size, PUBACK, 0, msg.id); else if (msg.qos == QOS2) len = MQTTSerialize_ack(c->buf, c->buf_size, PUBREC, 0, msg.id); if (len <= 0) rc = FAILURE; else rc = sendPacket_ev(c, len); if (rc == FAILURE) goto exit; } } break; case PUBREC: { unsigned short mypacketid; unsigned char dup, type; if (MQTTDeserialize_ack(&type, &dup, &mypacketid, c->readbuf, c->readbuf_size) != 1) rc = FAILURE; else if ((len = MQTTSerialize_ack(c->buf, c->buf_size, PUBREL, 0, mypacketid)) <= 0) rc = FAILURE; else if ((rc = sendPacket_ev(c, len)) != SUCCESS) // send the PUBREL packet rc = FAILURE; if (rc == FAILURE) goto exit; break; } break; case PUBCOMP: break; case PINGRESP: log_printf(LOG_NOTICE, "[MqttPingResp]\n"); c->ping_outstanding = 0; break; } // keepalive(c); //modify by yanly exit: if (rc == SUCCESS) rc = packet_type; return rc; }
int main(int argc, char** argv) { int rc = 0; struct pando_buffer *bin_buf; uint16_t payload_type = 0; MQTTMessage msg; unsigned char buf[500]; unsigned char readbuf[500]; char payload_type_c[] = {'c', 'e', 'd'}; bin_buf = construct_data_package_to_server(&payload_type); decode_data(bin_buf, PAYLOAD_TYPE_DATA); /* command test, event is same as command except the type */ bin_buf = constuct_event_package_to_server(&payload_type); decode_command(bin_buf, PAYLOAD_TYPE_COMMAND); return 0; if (argc < 2) usage(); char* topic = argv[1]; getopts(argc, argv); if (strchr(topic, '#') || strchr(topic, '+')) opts.showtopics = 1; if (opts.showtopics) printf("topic is %s\n", topic); Network n; Client c; signal(SIGINT, cfinish); signal(SIGTERM, cfinish); NewNetwork(&n); ConnectNetwork(&n, opts.host, opts.port); MQTTClient(&c, &n, 1000, buf, 100, readbuf, 100); MQTTPacket_connectData data = MQTTPacket_connectData_initializer; data.willFlag = 0; data.MQTTVersion = 3; data.clientID.cstring = opts.clientid; data.username.cstring = opts.username; data.password.cstring = opts.password; data.keepAliveInterval = 10; data.cleansession = 1; printf("Connecting to %s %d\n", opts.host, opts.port); rc = MQTTConnect(&c, &data); printf("Connected %d\n", rc); printf("Subscribing to %s\n", topic); rc = MQTTSubscribe(&c, topic, opts.qos, messageArrived); printf("Subscribed %d\n", rc); while (!toStop) { MQTTYield(&c, 1000); if (toSend) { if (strstr(topic, "/d")) { /* data test */ bin_buf = construct_data_package_to_server(&payload_type); //decode_data(bin_buf, PAYLOAD_TYPE_DATA); } if (strstr(topic, "/e")) { /* command test */ bin_buf = constuct_event_package_to_server(&payload_type); //decode_command(bin_buf, PAYLOAD_TYPE_COMMAND); } msg.qos = opts.qos; msg.retained = 0; msg.dup = 0; msg.payload = bin_buf->buffer + bin_buf->offset; msg.payloadlen = bin_buf->buff_len - bin_buf->offset; /* before publish a message, you need to generate a topic with payload_type max device id is 8 bytes, hex to char need 8*2 bytes, '/' need 1 byte, type need 1 byte */ char publish_topic[8*2 + 1 + 1]; memset(publish_topic, 0, sizeof(publish_topic)); sprintf(publish_topic, "%s/%c", opts.clientid, payload_type_c[payload_type - 1]); printf(publish_topic); rc = MQTTPublish(&c, publish_topic, &msg); toSend = 0; pd_free(bin_buf); printf("published rc %d, len %d\n", rc, (int)msg.payloadlen); } } printf("Stopping\n"); MQTTDisconnect(&c); n.disconnect(&n); return 0; }