/***********************************************************
*
* 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;
}
static void configure_mqtt(void)
{
printf("configure mqtt"DEBUG_EOL);
struct mqtt_config mqtt_conf;
int result;
mqtt_get_config_defaults(&mqtt_conf);
/* To use the MQTT service, it is necessary to always set the buffer and the timer. */
mqtt_conf.timer_inst = &swt_module_mqtt_inst;
mqtt_conf.recv_buffer = mqtt_buffer;
mqtt_conf.recv_buffer_size = MAIN_MQTT_BUFFER_SIZE;
result = mqtt_init(&mqtt_inst, &mqtt_conf);
if (result < 0) {
printf("MQTT initialization failed. Error code is (%d)\r\n", result);
while (1) {
}
}
result = mqtt_register_callback(&mqtt_inst, mqtt_callback);
if (result < 0) {
printf("MQTT register callback failed. Error code is (%d)\r\n", result);
while (1) {
}
}
printf("end configure mqtt"DEBUG_EOL);
}
/*---------------------------------------------------------------------------*/
mqtt_status_t
mqtt_register(struct mqtt_connection *conn, struct process *app_process,
char *client_id, mqtt_event_callback_t event_callback,
uint16_t max_segment_size)
{
if(strlen(client_id) < 1) {
return MQTT_STATUS_INVALID_ARGS_ERROR;
}
/* Set defaults - Set all to zero to begin with */
memset(conn, 0, sizeof(struct mqtt_connection));
string_to_mqtt_string(&conn->client_id, client_id);
conn->event_callback = event_callback;
conn->app_process = app_process;
conn->auto_reconnect = 1;
conn->max_segment_size = max_segment_size;
reset_defaults(conn);
mqtt_init();
list_add(mqtt_conn_list, conn);
DBG("MQTT - Registered successfully\n");
return MQTT_STATUS_OK;
}
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;
}
// 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;
}
static void ICACHE_FLASH_ATTR MQTTLogonTimerCb(void *arg)
{
static int resetCnt=0;
if (allow_mqtt_init)
{
if (!logged_on_to_network)
{
int x=wifi_station_get_connect_status();
if (x==STATION_GOT_IP)
{
logged_on_to_network = 1;
if (!logged_on_to_mqtt)
{
INFO("\n\rNETWRK OK\n");
mqtt_init();
MQTT_Connect(&mqttClient);
INFO("MQTT OK\r\n");
logged_on_to_mqtt = 1;
}
}
else
{
if (logged_on_to_mqtt) // Disconnect and reconnect later
{
MQTT_Disconnect(&mqttClient);
INFO("Left MQTT\r\n");
logged_on_to_mqtt = 0;
}
}
}
}
}
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 init_mqtt(void)
{
mqtt_init(&broker, "client-id1");
mqtt_init_auth(&broker, "aleph201409", "al2014eph");
init_socket(&broker, keepalive);
// >>>>> CONNECT
mqtt_connect(&broker);
read_packet();
}
int main(int argc, char *argv[]) {
int opt;
int daemonize = FALSE;
int verbose_level = 2;
char *configfile = DEFAULT_CONFIG_FILE;
while((opt = getopt(argc, argv, "c:bd:")) != -1) {
switch(opt) {
case 'c':
configfile = optarg;
break;
case 'b':
daemonize = TRUE;
break;
case 'd':
verbose_level = atoi(optarg);
break;
default:
usage(argv[0]);
exit(EXIT_FAILURE);
break;
}
}
debug_level(verbose_level);
DEBUG("Loading config from %s", configfile);
if(cfg_load(configfile) == -1) {
ERROR("Error loading config. Aborting");
return EXIT_FAILURE;
}
cfg_dump();
DEBUG("Starting mqtt workers");
mqtt_init();
DEBUG("Starting receive thread");
if(!nrf24_recv_init()) {
ERROR("Error starting radio receiver. Abort");
exit(EXIT_FAILURE);
}
while(1) {
sleep(1);
}
nrf24_recv_deinit();
mqtt_deinit();
return(EXIT_SUCCESS);
}
/**@brief Function for initializing IP stack.
*
* @details Initialize the IP Stack and its driver.
*/
static void ip_stack_init(void)
{
uint32_t err_code = nrf51_sdk_mem_init();
APP_ERROR_CHECK(err_code);
//Initialize LwIP stack.
lwip_init();
//Initialize LwIP stack driver.
err_code = nrf51_driver_init();
APP_ERROR_CHECK(err_code);
mqtt_init();
}
void init(void)
{
servo_init();
door_init();
if (mqtt_init() != 0) {
printf("请检查您的网络！\n");
exit(-1);
}
debug_print("mqtt init over");
create_doorbell_sound_pipeline();
debug_print("create_doorbell_sound_pipeline");
create_receive_pipeline();
debug_print("create_receive_pipeline");
set_receive_pipeline_playing();
}
/*
* mqtt重连情况：服务器没有响应ping包，socket断开连接。
* */
int MQTTReConnect(Client *c)
{
sleep(1);
int rc = FAILURE;
client_para_reset(c);
log_printf(LOG_NOTICE, "reconnect count=%d\n", c->reconnect_count);
if(c->reconnect_count > RECONNECT_MAX_COUNT)
{
system(SET_DARK_CLOUD);
log_printf(LOG_ERROR, "[ReConnectExceedMax], exit\n");
exit(1);
} //超过重连次数退出程序
stop_watchers("mqtt");
mqtt_init();
rc =SUCCESS;
log_printf(LOG_NOTICE, "[ReConnectMqtt]\n");
return rc;
}
/**@brief Function for initializing IP stack.
*
* @details Initialize the IP Stack and its driver.
*/
static void ip_stack_init(void)
{
uint32_t err_code;
err_code = ipv6_medium_eui64_get(m_ipv6_medium.ipv6_medium_instance_id, \
&eui64_local_iid);
APP_ERROR_CHECK(err_code);
err_code = nrf_mem_init();
APP_ERROR_CHECK(err_code);
//Initialize LwIP stack.
lwip_init();
//Initialize LwIP stack driver.
err_code = nrf_driver_init();
APP_ERROR_CHECK(err_code);
err_code = mqtt_init();
APP_ERROR_CHECK(err_code);
}
void ICACHE_FLASH_ATTR
user_init(void)
{
uart_init(BIT_RATE_115200, BIT_RATE_115200);
INFO("\r\nSDK version: %s\n", system_get_sdk_version());
INFO("System init...\r\n");
system_set_os_print(1);
os_delay_us(1000000);
INFO("Load Config\n");
config_load();
INFO("GPIO Init\n");
gpio_init();
INFO("MQTT Init");
mqtt_init();
INFO("Connect wifi %s\n", config.sta_ssid);
WIFI_Connect(config.sta_ssid, config.sta_pwd, wifi_connect_cb);
//WIFI_Connect("Wirelessabata", "TaLi100305", wifi_connect_cb);
INFO("\r\nSystem started ...\r\n");
}
int main()
{
log_printf(LOG_VERBOSE, "[StartProgram]...........\n");
log_printf(LOG_VERBOSE, "[HW-VERSION]: %s\n", HW_VERSION);
log_printf(LOG_VERBOSE, "[SW_VERSION]: %s\n", SW_VERSION);
log_printf(LOG_NOTICE, "COMPILE_TIME[%s: %s]\n", __DATE__, __TIME__);
#ifdef USE_IN_ARM
sleep(10);
#endif
unsigned char buf[MQTT_PLAYLOADLEN];
unsigned char readbuf[MQTT_PLAYLOADLEN];
signal(SIGINT, cfinish);
signal(SIGTERM, cfinish);
global_loop = EV_DEFAULT;
global_ev_all.mainloop = global_loop;
Network n; //必须 //mqtt network实体
gateway_setting_init();
gwmsg_init();
devlist_gateway_msg_init();
// dev_init();
NewNetwork(&n);
MQTTClient(&global_ev_all.client, &n, KEEPALIVE_INTERVAL, buf, MQTT_PLAYLOADLEN, readbuf, MQTT_PLAYLOADLEN);
mqtt_init();
zigbee_init();
ev_run(global_ev_all.mainloop, 0); //run...
log_printf(LOG_ERROR, "[Stopping]...\n");
MQTTDisconnect(&global_ev_all.client);
n.disconnect(&n);
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, "avengalvon");
mqtt_init_auth(&broker, "cid", "campeador");
init_socket(&broker, "127.0.0.1", 1883);
// >>>>> 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, "hello/emqtt", "Example: QoS 0", 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;
}
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;
}
// >>>>> 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;
}
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;
}
// >>>>> 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;
}
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;
}
// >>>>> DISCONNECT
mqtt_disconnect(&broker);
close_socket(&broker);
return 0;
}
/* 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();
}
void app_mqtt_init(mqtt_broker_handle_t *broker)
{
mqtt_init(broker, "HF_mc300");
mqtt_init_auth(broker, NULL, NULL);
mqtt_set_alive(broker, MQTT_KEEPALIVE_SEC);
}
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");
}
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;
}
/**
* 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 server_connect(int doConnect)
{
int16_t packet_length;
char host[30]; // temp space for hostname string
serverConnected = 0;
if (doConnect)
{
sprintf(host, THINGFABRIC_BROKER_HOSTNAME);
char *hostname = host;
hostname_to_ip(hostname , broker_ip);
if ((broker_ip == NULL) || (broker_ip[0] == 0))
{
return 0;
}
printf("\n%s resolved to %s\n" , hostname , broker_ip);
sleep(5);
// now connect using user/password, publish sensor values on
// appropriate topic (<domain>/<device type>/<device id>
char clientIDStr[100];
sprintf(clientIDStr, "%s/%s", THINGFABRIC_DEVICE_TYPE, THINGFABRIC_DEVICE_ID);
mqtt_init(&broker, clientIDStr);
mqtt_init_auth(&broker, THINGFABRIC_USERNAME, THINGFABRIC_PASSWORD);
init_socket(&broker, broker_ip, THINGFABRIC_BROKER_PORT);
serverConnected = 1;
mqtt_connect(&broker);
// wait for CONNACK
packet_length = read_packet(1);
if(packet_length < 0)
{
fprintf(stderr, "Error(%d) on read packet!\n", packet_length);
serverConnected = 0;
}
if(MQTTParseMessageType(packet_buffer) != MQTT_MSG_CONNACK)
{
fprintf(stderr, "CONNACK expected!\n");
serverConnected = 0;
}
if(packet_buffer[3] != 0x00)
{
fprintf(stderr, "CONNACK failed!\n");
serverConnected = 0;
}
if (serverConnected)
{
sprintf(pubTopic, "%s/%s/%s", THINGFABRIC_DOMAIN, THINGFABRIC_DEVICE_TYPE, THINGFABRIC_DEVICE_ID);
printf("%s\n", pubTopic);
// configure the ping timer
signal(SIGALRM, alive);
alarm(keepalive);
}
else
{
fprintf(stderr, "Error connecting to MQTT server\n");
}
}
else
{
printf("Disconnecting from server\n");
mqtt_disconnect(&broker);
close_socket(&broker);
serverConnected = 0;
}
return serverConnected;
}
/**
* 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;
}
