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;
}
