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