int main (int argc, char** argv) { puts("MQTT SUB Test Code"); if(argc > 1) { parse_options(argc, argv); } // mqtt_broker_handle_t *broker = mqtt_connect("default_sub","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); } int result = mqtt_subscribe(broker, topic, QoS0); if(result != 1) { puts("failed to Subscribe"); exit(1); } while(1) { mqtt_display_message(broker, &putchar); } return 0; }
/**@brief Timer callback used for connecting to Xively cloud. * * @param[in] p_context Pointer used for passing context. No context used in this application. */ static void app_xively_connect(void * p_context) { UNUSED_VARIABLE(p_context); uint32_t err_code; mqtt_client_init(&m_app_mqtt_id); static mqtt_username_t username; username.p_utf_str = (uint8_t *)m_user; username.utf_strlen = strlen(m_user); memcpy (m_app_mqtt_id.broker_addr.u8, m_broker_addr, IPV6_ADDR_SIZE); m_app_mqtt_id.broker_port = APP_MQTT_XIVELY_BROKER_PORT; m_app_mqtt_id.evt_cb = app_mqtt_evt_handler; m_app_mqtt_id.client_id.p_utf_str = (uint8_t *)m_device_id; m_app_mqtt_id.client_id.utf_strlen = strlen(m_device_id); m_app_mqtt_id.p_password = NULL; m_app_mqtt_id.p_user_name = (mqtt_username_t *)&username; m_app_mqtt_id.transport_type = MQTT_TRANSPORT_SECURE; m_app_mqtt_id.p_security_settings = &m_tls_keys; err_code = mqtt_connect(&m_app_mqtt_id); APP_ERROR_CHECK(err_code); }
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); }
// Connect to the MQTT broker. Call this function whenever connection needs // to be re-established. // returns: 0 - everything OK // -1 - packet error // -2 - failed to get connack int App_ConnectMqtt() { int packet_length; mqtt_init(&broker, WIO_CLIENTID); mqtt_init_auth(&broker, WIO_USERNAME, WIO_PASSWORD); mqtt_connect(&broker); // wait for CONNACK packet_length = mqtt_read_packet(6000); if(packet_length < 0) { DisplayLCD(LCD_LINE4, "MQTT packet error"); return -1; } if(MQTTParseMessageType(rxm.message) != MQTT_MSG_CONNACK) { return -2; } if(rxm.message[3] != 0x00) { return -2; } App_PrepareIncomingData(); AtLibGs_FlushIncomingMessage(); mqttConnected=1; return 0; }
void itc_mqtt_subscribe_unsubscribe_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_subscribe(g_mqtt_client_handle, ITC_MQTT_TOPIC, 0); TC_ASSERT_EQ_CLEANUP("mqtt_subscribe", res, 0, mqtt_disconnect(g_mqtt_client_handle); mqtt_deinit_client(g_mqtt_client_handle)); res = mqtt_unsubscribe(g_mqtt_client_handle, ITC_MQTT_TOPIC); TC_ASSERT_EQ_CLEANUP("mqtt_unsubscribe", res, 0, mqtt_disconnect(g_mqtt_client_handle); mqtt_deinit_client(g_mqtt_client_handle)); res = mqtt_disconnect(g_mqtt_client_handle); TC_ASSERT_EQ("mqtt_disconnect", res, 0); ITC_MQTT_WAIT_SIGNAL; res = mqtt_deinit_client(g_mqtt_client_handle); TC_ASSERT_EQ("mqtt_deinit_client", res, 0); TC_SUCCESS_RESULT(); }
/*********************************************************** * * return : 0 success ,1 error * *************************************************************/ int32 Mqtt_SendConnetPacket( mqtt_broker_handle_t *pstBroketHandle, int32 socketid,const int8* username,const int8* password ) { int32 ret; if( (username==NULL) || (password==NULL) )// 匿名登录 GAgent V4 will not runing this code. { return 1; } else // 用户登录 { mqtt_init( pstBroketHandle,username ); mqtt_init_auth(pstBroketHandle,username,password ); } mqtt_set_alive(pstBroketHandle, CLOUD_MQTT_SET_ALIVE); pstBroketHandle->socketid = socketid; pstBroketHandle->mqttsend = send_packet; ret = mqtt_connect(pstBroketHandle); if (ret != 0) { GAgent_Printf(GAGENT_WARNING,"mqtt send connect packet is failed with:%d", ret); return 1; } GAgent_Printf(GAGENT_INFO, "Mqtt_SendConnetPacket OK, write:%d", ret); return 0; }
bool MqttClient::connect(String clientName, String username, String password) { if (getConnectionState() != eTCS_Ready) { close(); debugf("MQTT closed previous connection"); } debugf("MQTT start connection"); mqtt_init(&broker, clientName.c_str()); if (clientName.length() > 0) mqtt_init_auth(&broker, username.c_str(), password.c_str()); if(server) { TcpClient::connect(server, port); } else { TcpClient::connect(serverIp, port); } mqtt_set_alive(&broker, keepAlive); broker.socket_info = (void*)this; broker.send = staticSendPacket; int res = mqtt_connect(&broker); setTimeOut(USHRT_MAX); return res > 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; }
bool thethingsio_connect_subscribe() { printf("connect subscribe"DEBUG_EOL); printf("mqtt broker: %s"DEBUG_EOL, main_mqtt_broker); mqtt_connect(&mqtt_inst, main_mqtt_broker); }
/** * \brief Callback to get the MQTT status update. * * \param[in] conn_id instance id of connection which is being used. * \param[in] type type of MQTT notification. Possible types are: * - [MQTT_CALLBACK_SOCK_CONNECTED](@ref MQTT_CALLBACK_SOCK_CONNECTED) * - [MQTT_CALLBACK_CONNECTED](@ref MQTT_CALLBACK_CONNECTED) * - [MQTT_CALLBACK_PUBLISHED](@ref MQTT_CALLBACK_PUBLISHED) * - [MQTT_CALLBACK_SUBSCRIBED](@ref MQTT_CALLBACK_SUBSCRIBED) * - [MQTT_CALLBACK_UNSUBSCRIBED](@ref MQTT_CALLBACK_UNSUBSCRIBED) * - [MQTT_CALLBACK_DISCONNECTED](@ref MQTT_CALLBACK_DISCONNECTED) * - [MQTT_CALLBACK_RECV_PUBLISH](@ref MQTT_CALLBACK_RECV_PUBLISH) * \param[in] data A structure contains notification informations. @ref mqtt_data */ static void mqtt_callback(struct mqtt_module *module_inst, int type, union mqtt_data *data) { switch (type) { case MQTT_CALLBACK_SOCK_CONNECTED: { /* * If connecting to broker server is complete successfully, Start sending CONNECT message of MQTT. * Or else retry to connect to broker server. */ if (data->sock_connected.result >= 0) { mqtt_connect_broker(module_inst, 1, NULL, NULL, mqtt_user, NULL, NULL, 0, 0, 0); } else { printf("Connect fail to server(%s)! retry it automatically.\r\n", main_mqtt_broker); mqtt_connect(module_inst, main_mqtt_broker); /* Retry that. */ } } break; case MQTT_CALLBACK_CONNECTED: if (data->connected.result == MQTT_CONN_RESULT_ACCEPT) { /* Subscribe chat topic. */ mqtt_subscribe(module_inst, MAIN_CHAT_TOPIC "#", 0); /* Enable USART receiving callback. */ usart_enable_callback(&cdc_uart_module, USART_CALLBACK_BUFFER_RECEIVED); printf("Preparation of the chat has been completed.\r\n"); } else { /* Cannot connect for some reason. */ printf("MQTT broker decline your access! error code %d\r\n", data->connected.result); } break; case MQTT_CALLBACK_RECV_PUBLISH: /* You received publish message which you had subscribed. */ if (data->recv_publish.topic != NULL && data->recv_publish.msg != NULL) { if (!strncmp(data->recv_publish.topic, MAIN_CHAT_TOPIC, strlen(MAIN_CHAT_TOPIC))) { /* Print user name and message */ for (int i = strlen(MAIN_CHAT_TOPIC); i < data->recv_publish.topic_size; i++) { printf("%c", data->recv_publish.topic[i]); } printf(" >> "); for (int i = 0; i < data->recv_publish.msg_size; i++) { printf("%c", data->recv_publish.msg[i]); } printf("\r\n"); } } break; case MQTT_CALLBACK_DISCONNECTED: /* Stop timer and USART callback. */ printf("MQTT disconnected\r\n"); usart_disable_callback(&cdc_uart_module, USART_CALLBACK_BUFFER_RECEIVED); break; } }
int main(int argc, char *argv[]){ if (mqtt_init("device2") != 0) { error("init error!\n"); goto main_error; } /** * @brief construct CONNECT message */ if (mqtt_connect(argv[1]) != 0) { error("connection error!\n"); goto main_error; } /** * @brief construct PUBLICH message */ if (mqtt_send_subscribe("device1/led_red") != 0) { error("publish error!\n"); goto main_error; } /* get data */ while (1) { /* transport_getdata() has a built-in 1 second timeout, your mileage will vary */ if (mqtt_read() == PUBLISH) { unsigned char dup; int qos; unsigned char retained; unsigned short msgid; int payloadlen_in; unsigned char* payload_in; int rc; MQTTString receivedTopic; rc = mqtt_read_publish(&dup, &qos, &retained, &msgid, &receivedTopic, &payload_in, &payloadlen_in); printf("message arrived %.*s\n", payloadlen_in, payload_in); /* send ping message to keep connect */ mqtt_pingreq(); } } /** * @brief construct DISCONNECT message */ if (mqtt_disconnect() != 0) { error("disconnect error!\n"); goto main_error; } return EXIT_SUCCESS; main_error: return EXIT_FAILURE; }
void itc_mqtt_connect_n_reconnect(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); // MQTT Connect 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; // MQTT re-Connect 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)); if (g_mqtt_client_handle != NULL) { TC_ASSERT_EQ_CLEANUP("mqtt_connect", g_mqtt_client_handle->state, MQTT_CLIENT_STATE_CONNECTED, mqtt_disconnect(g_mqtt_client_handle); mqtt_deinit_client(g_mqtt_client_handle)); }
/*---------------------------------------------------------------------------*/ static void connect_to_broker(void) { /* Connect to MQTT server */ mqtt_connect(&conn, conf->broker_ip, conf->broker_port, conf->pub_interval * 3); state = MQTT_CLIENT_STATE_CONNECTING; }
void mqtt_login_server(mqtt_broker_handle_t *broker) { broker->socket_info = (void*)&(g_mqtt_socket_para.fd); broker->send = mqtt_send_packet; if(mqtt_connect(broker)== -1) printf("Mqtt login server fail!\n"); else printf("Do mqtt login ...\n"); }
void init_mqtt(void) { mqtt_init(&broker, "client-id1"); mqtt_init_auth(&broker, "aleph201409", "al2014eph"); init_socket(&broker, keepalive); // >>>>> CONNECT mqtt_connect(&broker); read_packet(); }
PROCESS_THREAD(mqtt_client_process, ev, data) { static uip_ip6addr_t server_address; PROCESS_BEGIN(); /* Set the server address */ uip_ip6addr(&server_address, 0xbbbb, 0, 0, 0, 0, 0, 0, 0x001); /* connect to the broker */ mqtt_connect(&server_address, UIP_HTONS(1883), 1000); while(1) { PROCESS_WAIT_EVENT(); if (ev == mqtt_event) { mqtt_event_data_t *event_data = data; switch(event_data->type) { case MQTT_EVENT_TYPE_CONNECTED: printf("CONNECTED\n"); //mqtt_subscribe("test"); break; case MQTT_EVENT_TYPE_DISCONNECTED: printf("DISCONNECTED\n"); break; case MQTT_EVENT_TYPE_SUBSCRIBED: printf("SUBSCRIBED\n"); break; case MQTT_EVENT_TYPE_UNSUBSCRIBED: printf("UNSUBSCRIBED\n"); break; case MQTT_EVENT_TYPE_PUBLISHED: printf("PUBLISHED\n"); break; case MQTT_EVENT_TYPE_PUBLISH: printf("PUBLISH %s\n", event_data->data); break; default: break; } } } PROCESS_END(); }
// ------------------------------------------------------------------- // MQTT state management // // Call every time around loop() if connected to the WiFi // ------------------------------------------------------------------- void mqtt_loop() { if (!mqttclient.connected()) { long now = millis(); // try and reconnect continuously for first 5s then try again once every 10s if ( (now < 50000) || ((now - lastMqttReconnectAttempt) > 100000) ) { lastMqttReconnectAttempt = now; if (mqtt_connect()) { // Attempt to reconnect lastMqttReconnectAttempt = 0; } } } else { // if MQTT connected mqttclient.loop(); } }
int main(int argc, char *argv[]) { if (0 != parse_options(argc, argv)) { usage(); return 1; } if (!verbose) log_setlevel(LOGLEVEL_CRITICAL); memset(&g_srvctx, 0, sizeof(g_srvctx)); g_srvctx.loop = ev_default_loop(0); ev_set_userdata(g_srvctx.loop, &g_srvctx); if (NULL == (g_srvctx.timer_1hz = (struct ev_timer *)malloc(sizeof(struct ev_timer)))) LOG_CRITICAL("out of mem"); if (NULL == (g_srvctx.timer_10hz = (struct ev_timer *)malloc(sizeof(struct ev_timer)))) LOG_CRITICAL("out of mem"); if (NULL == (g_srvctx.idle_watcher = (struct ev_idle *)malloc(sizeof(struct ev_idle)))) LOG_CRITICAL("out of mem"); ev_timer_init(g_srvctx.timer_1hz, (void *)timeout_1hz_cb, 0, 1); ev_set_priority(g_srvctx.timer_1hz, EV_MAXPRI); ev_timer_start(g_srvctx.loop, g_srvctx.timer_1hz); ev_timer_init(g_srvctx.timer_10hz, (void *)timeout_10hz_cb, 0, 0.1); ev_set_priority(g_srvctx.timer_10hz, EV_MAXPRI); ev_timer_start(g_srvctx.loop, g_srvctx.timer_10hz); ev_idle_init(g_srvctx.idle_watcher, idle_cb); if (0 != serial_init(g_srvctx.loop, &(g_srvctx.serialctx), device_name)) { LOG_CRITICAL("Failed to open %s", device_name); } if (0 != mqtt_connect(&(g_srvctx.mqttctx), CLIENT_NAME, server, port)) { LOG_CRITICAL("failed to connect to server"); } while(1) { ev_loop(g_srvctx.loop, 0); } return 0; }
/**@brief Timer callback used for connecting to Xively cloud. * * @param[in] p_context Pointer used for passing context. No context used in this application. */ static void app_xively_connect(void * p_context) { UNUSED_VARIABLE(p_context); uint32_t err_code; mqtt_connect_t param; param.broker_addr = m_broker_addr; param.broker_port = APP_MQTT_XIVELY_BROKER_PORT; param.evt_cb = app_mqtt_evt_handler; param.device_id = m_device_id; param.p_password = NULL; param.p_user_name = m_user; err_code = mqtt_connect(&m_app_mqtt_id, ¶m); APP_ERROR_CHECK(err_code); }
void itc_mqtt_connect_disconnect_n(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); // MQTT Connect res = mqtt_connect(g_mqtt_client_handle, NULL, CONFIG_ITC_MQTT_BROKER_PORT, 0); TC_ASSERT_EQ("mqtt_connect", res, -1); //MQTT Disconnect res = mqtt_disconnect(g_mqtt_client_handle); TC_ASSERT_EQ_CLEANUP("mqtt_disconnect", res, 0, mqtt_deinit_client(g_mqtt_client_handle)); res = mqtt_deinit_client(g_mqtt_client_handle); TC_ASSERT_EQ("mqtt_deinit_client", res, 0); TC_SUCCESS_RESULT(); }
static void button_event_handler(uint8_t pin_no, uint8_t button_action) { if (button_action == APP_BUTTON_PUSH) { switch (pin_no) { case BSP_BUTTON_0: { if (m_connection_state == false) { mqtt_connect_t param; param.broker_addr = m_broker_addr; param.broker_port = APP_MQTT_BROKER_PORT; param.evt_cb = app_mqtt_evt_handler; param.device_id = m_device_id; param.p_password = NULL; param.p_user_name = NULL; UNUSED_VARIABLE(mqtt_connect(&m_app_mqtt_id, ¶m)); } break; } case BSP_BUTTON_1: { if (m_connection_state == true) { app_mqtt_publish(!m_led_state); } break; } case BSP_BUTTON_2: { if (m_connection_state == true) { UNUSED_VARIABLE(mqtt_disconnect(&m_app_mqtt_id)); } break; } default: break; } } }
void itc_mqtt_connect_disconnect_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); // MQTT Connect res = mqtt_connect(g_mqtt_client_handle, CONFIG_ITC_MQTT_BROKER_ADDR, CONFIG_ITC_MQTT_BROKER_PORT, 0); TC_ASSERT_EQ("mqtt_connect", res, 0); ITC_MQTT_WAIT_SIGNAL; //MQTT Disconnect res = mqtt_disconnect(g_mqtt_client_handle); TC_ASSERT_EQ("mqtt_disconnect", res, 0); ITC_MQTT_WAIT_SIGNAL; res = mqtt_deinit_client(g_mqtt_client_handle); TC_ASSERT_EQ("mqtt_deinit_client", res, 0); TC_SUCCESS_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(); }
/** * \brief Callback to get the Wi-Fi status update. * * \param[in] msg_type type of Wi-Fi notification. Possible types are: * - [M2M_WIFI_RESP_CURRENT_RSSI](@ref M2M_WIFI_RESP_CURRENT_RSSI) * - [M2M_WIFI_RESP_CON_STATE_CHANGED](@ref M2M_WIFI_RESP_CON_STATE_CHANGED) * - [M2M_WIFI_RESP_CONNTION_STATE](@ref M2M_WIFI_RESP_CONNTION_STATE) * - [M2M_WIFI_RESP_SCAN_DONE](@ref M2M_WIFI_RESP_SCAN_DONE) * - [M2M_WIFI_RESP_SCAN_RESULT](@ref M2M_WIFI_RESP_SCAN_RESULT) * - [M2M_WIFI_REQ_WPS](@ref M2M_WIFI_REQ_WPS) * - [M2M_WIFI_RESP_IP_CONFIGURED](@ref M2M_WIFI_RESP_IP_CONFIGURED) * - [M2M_WIFI_RESP_IP_CONFLICT](@ref M2M_WIFI_RESP_IP_CONFLICT) * - [M2M_WIFI_RESP_P2P](@ref M2M_WIFI_RESP_P2P) * - [M2M_WIFI_RESP_AP](@ref M2M_WIFI_RESP_AP) * - [M2M_WIFI_RESP_CLIENT_INFO](@ref M2M_WIFI_RESP_CLIENT_INFO) * \param[in] pvMsg A pointer to a buffer containing the notification parameters * (if any). It should be casted to the correct data type corresponding to the * notification type. Existing types are: * - tstrM2mWifiStateChanged * - tstrM2MWPSInfo * - tstrM2MP2pResp * - tstrM2MAPResp * - tstrM2mScanDone * - tstrM2mWifiscanResult */ static void wifi_callback(uint8 msg_type, void *msg_data) { tstrM2mWifiStateChanged *msg_wifi_state; uint8 *msg_ip_addr; switch (msg_type) { case M2M_WIFI_RESP_CON_STATE_CHANGED: msg_wifi_state = (tstrM2mWifiStateChanged *)msg_data; if (msg_wifi_state->u8CurrState == M2M_WIFI_CONNECTED) { /* If Wi-Fi is connected. */ printf("Wi-Fi connected\r\n"); m2m_wifi_request_dhcp_client(); } else if (msg_wifi_state->u8CurrState == M2M_WIFI_DISCONNECTED) { /* If Wi-Fi is disconnected. */ printf("Wi-Fi disconnected\r\n"); m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL); /* Disconnect from MQTT broker. */ /* Force close the MQTT connection, because cannot send a disconnect message to the broker when network is broken. */ mqtt_disconnect(&mqtt_inst, 1); } break; case M2M_WIFI_REQ_DHCP_CONF: msg_ip_addr = (uint8 *)msg_data; printf("Wi-Fi IP is %u.%u.%u.%u\r\n", msg_ip_addr[0], msg_ip_addr[1], msg_ip_addr[2], msg_ip_addr[3]); /* Try to connect to MQTT broker when Wi-Fi was connected. */ mqtt_connect(&mqtt_inst, main_mqtt_broker); break; default: break; } }
/** * Main routine * */ static int mqtt_sub(void) { int packet_length,socket_id; uint16_t msg_id, msg_id_rcv; mqtt_broker_handle_t broker; packet_buffer.len=BUFSIZE; broker.socket_info = (void *)&socket_id; mqtt_init(&broker, "MQTT_SUB"); //mqtt_init_auth(&broker, "quijote", "rocinante"); socket_id = init_socket(&broker); // >>>>> CONNECT mqtt_connect(&broker); // <<<<< CONNACK // unsigned long pubTaskHandle= getTaskHandle(SUB_TASKID); // vTaskPrioritySet( (xTaskHandle)&pubTaskHandle, PUB_TASK_PRIORITY); //to degrade sub_task priority to let it as the same of pub_task packet_length = read_packet(1,socket_id,(Tranmit_t *)&packet_buffer); if(packet_length < 0) { UART_PRINT("Error(%d) on read packet!\n\r"); return -1; } if(MQTTParseMessageType(packet_buffer.buffer) != MQTT_MSG_CONNACK) { UART_PRINT("CONNACK expected!\n\r"); return -2; } if(packet_buffer.buffer[3] != 0x00) { UART_PRINT("CONNACK failed!\n\r"); return -2; } UART_PRINT("Connected to broker!\n\r"); if(OSI_OK != osi_TaskCreate( taskPub, (const signed char*)"taskPub", 2048, NULL, PUB_TASK_PRIORITY, (OsiTaskHandle)&pubTaskHandle )) UART_PRINT("taskPub failed\n\r"); // Signals after connect MQTT //signal(SIGALRM, alive); //alarm(keepalive); //signal(SIGINT, term); // >>>>> SUBSCRIBE mqtt_subscribe(&broker, "helloword", &msg_id); // <<<<< SUBACK packet_length = read_packet(1,socket_id,(Tranmit_t *)&packet_buffer); if(packet_length < 0) { UART_PRINT("Error(%d) on read packet!\n\r"); return -1; } if(MQTTParseMessageType(packet_buffer.buffer) != MQTT_MSG_SUBACK) { UART_PRINT("SUBACK expected!\n\r"); return -2; } msg_id_rcv = mqtt_parse_msg_id(packet_buffer.buffer); if(msg_id != msg_id_rcv) { UART_PRINT("%d message id was expected, but %d message id was found!\n\r"); return -3; } while(1) { // <<<<< packet_length = read_packet(0,socket_id,(Tranmit_t *)&packet_buffer); if(packet_length == -1) { UART_PRINT("Error(%d) on read packet!\n\r"); return -1; } else if(packet_length > 0) { UART_PRINT("Packet Header: 0x%x...\n\r"); if(MQTTParseMessageType(packet_buffer.buffer) == MQTT_MSG_PUBLISH) { uint8_t topic[TOPIC_LEN_MAX], msg[MSG_LEN_MAX]; uint16_t len; len = mqtt_parse_pub_topic(packet_buffer.buffer, topic); topic[len] = '\0'; // for printf len = mqtt_parse_publish_msg(packet_buffer.buffer, msg); msg[len] = '\0'; // for printf //UART_PRINT("%s %s\n\r", topic, msg); UART_PRINT(topic); UART_PRINT("\n\r"); UART_PRINT(msg); UART_PRINT("\n\r"); } } } return 0; }
/**************************************************************************** * Public Functions ****************************************************************************/ int mqtt_client_sub_task(void *arg) { int result = -1; int ret = 0; int argc; char **argv; argc = ((struct mqtt_sub_input *)arg)->argc; argv = ((struct mqtt_sub_input *)arg)->argv; if (argc == 1) { print_usage(); return 0; } /* set the seed of a new sequence of random values */ mqtt_set_srand(); /* check options and set variables */ init_variables(); ret = process_options(argc, argv); if (ret != 0) { if (ret == 2) { print_usage(); result = 0; } goto done; } /* check and do options when a client is running */ ret = check_option_on_client_running(); if (ret == CHECK_OPTION_RESULT_CHECKED_OK) { result = 0; goto done; } else if (ret == CHECK_OPTION_RESULT_CHECKED_ERROR) { goto done; } /* make mqtt subscriber client config */ if (make_client_config() != 0) { goto done; } /* create mqtt subscriber client */ if (g_debug) { printf("initialize MQTT client context.\n"); } g_mqtt_client_handle = mqtt_init_client(&g_mqtt_client_config); if (g_mqtt_client_handle == NULL) { fprintf(stderr, "Error: mqtt_init_client() failed.\n"); clean_client_config(); goto done; } /* connect to a mqtt broker */ if (g_debug) { printf("connect to a MQTT broker (%s : %d).\n", g_host_addr, g_port); } if (mqtt_connect(g_mqtt_client_handle, g_host_addr, g_port, g_keepalive) != 0) { fprintf(stderr, "Error: mqtt_connect() failed.\n"); if (mqtt_deinit_client(g_mqtt_client_handle) != 0) { fprintf(stderr, "Error: mqtt_deinit_client() failed.\n"); } else { g_mqtt_client_handle = NULL; } clean_client_config(); goto done; } if (g_debug) { printf("MQTT subscriber has started successfully.\n"); } /* result is success */ result = 0; done: deinit_variables(); return result; }
/* 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(); }
static void publisher(void) { int i, rc; /* Set everything to 0 and later just assign the required fields. */ memset(&client_ctx, 0x00, sizeof(client_ctx)); /* connect, disconnect and malformed may be set to NULL */ client_ctx.mqtt_ctx.connect = connect_cb; client_ctx.mqtt_ctx.disconnect = disconnect_cb; client_ctx.mqtt_ctx.malformed = malformed_cb; client_ctx.mqtt_ctx.net_init_timeout = APP_NET_INIT_TIMEOUT; client_ctx.mqtt_ctx.net_timeout = APP_TX_RX_TIMEOUT; client_ctx.mqtt_ctx.peer_addr_str = SERVER_ADDR; client_ctx.mqtt_ctx.peer_port = SERVER_PORT; #if defined(CONFIG_MQTT_LIB_TLS) /** TLS setup */ client_ctx.mqtt_ctx.request_buf = tls_request_buf; client_ctx.mqtt_ctx.request_buf_len = TLS_REQUEST_BUF_SIZE; client_ctx.mqtt_ctx.personalization_data = TLS_PRIVATE_DATA; client_ctx.mqtt_ctx.personalization_data_len = strlen(TLS_PRIVATE_DATA); client_ctx.mqtt_ctx.cert_host = TLS_SNI_HOSTNAME; client_ctx.mqtt_ctx.tls_mem_pool = &tls_mem_pool; client_ctx.mqtt_ctx.tls_stack = tls_stack; client_ctx.mqtt_ctx.tls_stack_size = K_THREAD_STACK_SIZEOF(tls_stack); client_ctx.mqtt_ctx.cert_cb = setup_cert; client_ctx.mqtt_ctx.entropy_src_cb = NULL; #endif /* Publisher apps TX the MQTT PUBLISH msg */ client_ctx.mqtt_ctx.publish_tx = publish_cb; /* The connect message will be sent to the MQTT server (broker). * If clean_session here is 0, the mqtt_ctx clean_session variable * will be set to 0 also. Please don't do that, set always to 1. * Clean session = 0 is not yet supported. */ client_ctx.connect_msg.client_id = MQTT_CLIENTID; client_ctx.connect_msg.client_id_len = strlen(MQTT_CLIENTID); client_ctx.connect_msg.clean_session = 1; client_ctx.connect_data = "CONNECTED"; client_ctx.disconnect_data = "DISCONNECTED"; client_ctx.publish_data = "PUBLISH"; rc = network_setup(); PRINT_RESULT("network_setup", rc); if (rc < 0) { return; } rc = mqtt_init(&client_ctx.mqtt_ctx, MQTT_APP_PUBLISHER); PRINT_RESULT("mqtt_init", rc); if (rc != 0) { return; } for (i = 0; i < CONN_TRIES; i++) { rc = mqtt_connect(&client_ctx.mqtt_ctx); PRINT_RESULT("mqtt_connect", rc); if (!rc) { goto connected; } } goto exit_app; connected: rc = try_to_connect(&client_ctx); PRINT_RESULT("try_to_connect", rc); if (rc != 0) { goto exit_app; } i = 0; while (i++ < APP_MAX_ITERATIONS) { rc = mqtt_tx_pingreq(&client_ctx.mqtt_ctx); k_sleep(APP_SLEEP_MSECS); PRINT_RESULT("mqtt_tx_pingreq", rc); prepare_mqtt_publish_msg(&client_ctx.pub_msg, MQTT_QoS0); rc = mqtt_tx_publish(&client_ctx.mqtt_ctx, &client_ctx.pub_msg); k_sleep(APP_SLEEP_MSECS); PRINT_RESULT("mqtt_tx_publish", rc); prepare_mqtt_publish_msg(&client_ctx.pub_msg, MQTT_QoS1); rc = mqtt_tx_publish(&client_ctx.mqtt_ctx, &client_ctx.pub_msg); k_sleep(APP_SLEEP_MSECS); PRINT_RESULT("mqtt_tx_publish", rc); prepare_mqtt_publish_msg(&client_ctx.pub_msg, MQTT_QoS2); rc = mqtt_tx_publish(&client_ctx.mqtt_ctx, &client_ctx.pub_msg); k_sleep(APP_SLEEP_MSECS); PRINT_RESULT("mqtt_tx_publish", rc); } rc = mqtt_tx_disconnect(&client_ctx.mqtt_ctx); PRINT_RESULT("mqtt_tx_disconnect", rc); exit_app: mqtt_close(&client_ctx.mqtt_ctx); printk("\nBye!\n"); }
/** * Main routine * */ int main() { int packet_length; uint16_t msg_id, msg_id_rcv; mqtt_init(&broker, "client-id"); //mqtt_init_auth(&broker, "quijote", "rocinante"); init_socket(&broker, "107.22.188.194", 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; } // Signals after connect MQTT signal(SIGALRM, alive); alarm(keepalive); signal(SIGINT, term); // >>>>> SUBSCRIBE mqtt_subscribe(&broker, "public/test/topic", &msg_id); // <<<<< SUBACK 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_SUBACK) { fprintf(stderr, "SUBACK expected!\n"); return -2; } msg_id_rcv = mqtt_parse_msg_id(packet_buffer); 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; } while(1) { // <<<<< packet_length = read_packet(0); if(packet_length == -1) { fprintf(stderr, "Error(%d) on read packet!\n", packet_length); return -1; } else if(packet_length > 0) { printf("Packet Header: 0x%x...\n", packet_buffer[0]); if(MQTTParseMessageType(packet_buffer) == MQTT_MSG_PUBLISH) { uint8_t topic[255], msg[1000]; uint16_t len; len = mqtt_parse_pub_topic(packet_buffer, topic); topic[len] = '\0'; // for printf len = mqtt_parse_publish_msg(packet_buffer, msg); msg[len] = '\0'; // for printf printf("%s %s\n", topic, msg); } } } return 0; }
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; }