Cannot find the correct MQTT broker server - amazon-web-services

Question

This is my first post so tell me where I go wrong.
Here is my setup.
I have a sensor connected via SCL and STA to a ESP8266 developer kit.
My language is arduino. This works, I can get it to put out the temperature and humidity into the serial monitor. I also have a raspberry pi (3?) that currently works as a wifi router. I used hostapd to do this. I have also signed up for amazon AWS, and have AWSIoT connected with the pi, which i have mosquitto running as the broker. My goal is to be able to leave the pi and esp with sensor in a location, pi connected with ethernet, and have the temperature and humidity come to kibana browser and I be able to see the data.
Here is my problem. mosquitto works with the mosquitto_sub and mosquitto_pub client. However, my arduino code cannot connect. I suspected that this was a problem with the IP address, so I consulted the internet, and got many test sites, but none told me where to find the IP to put as the mqtt broker server. I have included my code, and I live in japan, so don`t be frightened by the time settings. As you can see, I have been trying many different things that maybe could work :/.
#include "SparkFun_Si7021_Breakout_Library.h"
#include <Wire.h>
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <time.h>
#include <WiFiUdp.h>
float humidity = 0;
float tempf = 0;
const char* SSID = "ssid";
const char* PASSWORD = "password";
const int MQTTPORT = 1883;
I tried many different ips here, but none of them worked.
(Using the const char* format below)(The reason I exclude them is for security(right?))
//const char* MQTTSERVER = "mosquitto.service";
//const char* MQTTSERVER = "systemctl";
//const char* MQTTSERVER = "bridgeawsiot2";
const char* MQTTINITTOPIC = "/dev/init/msg/";
const char* MQTTSNTOPIC = "/ras-xdv2/Si7021";
const char* MQTTINITTOPICMSG = "{\"dev\"=\"Si7021\",\"msg\"=\"init\"}";
// APRIME
WiFiUDP ntpUDP;
const char* NTPSERVER = "ntp.nict.jp";
const int NTPTIMEOFFSET = 9 * 60 * 60;
WiFiClient espClient;
PubSubClient client(espClient);
//Create Instance of HTU21D or SI7021 temp and humidity sensor and MPL3115A2 barrometric sensor
Weather sensor;
//---------------------------------------------------------------
void setup_wifi() {
delay(10);
Serial.print("WiFi CONNECTION...");
Serial.println(SSID);
WiFi.begin(SSID, PASSWORD);
while (WiFi.status() != WL_CONNECTED){
delay(500);
Serial.print("Waiting...");
}
randomSeed(micros());
Serial.println(" ");
Serial.println("WiFi connected");
Serial.println("ESP8266 ip:");
Serial.println(WiFi.localIP());
}
//---------------------------------------------------------------
void mqttConnect() {
// client.setServer(MQTTSERVER, MQTTPORT);
while (!client.connected()) {
Serial.print("MQTT communications need more time...");
String clientId = "ESP8266-";
clientId += String(random(0xffff));
delay(3000);
if (client.connect(clientId.c_str())) {
Serial.println("MQTT communications online!");
client.publish(MQTTINITTOPIC, MQTTINITTOPICMSG);
} else {
Serial.print("MQTT communications unavailible, rc=");
Serial.print(client.state());
delay(2000);
Serial.println("Attempting connection in t-2 Seconds...");
delay(2000);
}
}
}
//---------------------------------------------------------------
void setup()
{
Serial.begin(115200);
sensor.begin();
setup_wifi();
client.setServer(MQTTSERVER, MQTTPORT);
delay(5000);
/*if (!sensor.begin()) {
Serial.print("sensor ded :(");
while (1);
}*/
configTime( NTPTIMEOFFSET, 0, NTPSERVER );
}
//---------------------------------------------------------------
void loop()
{
time_t t = time(NULL);
struct tm *tm;
tm = localtime(&t);
char dt[25];
sprintf(dt, "%04d-%02d-%02dT%02d:%02d:%02d+09:00", tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
Serial.printf(dt);
if(!client.connected()){
mqttConnect();
} else {
client.loop();
}
char pub_json[100];
//Get readings from all sensors
getWeather();
printInfo();
delay(10000);
char tempfbuf[4];
char humiditybuf[4];
sprintf(pub_json,"{\"Temperature\":%s,\"Humidity\": %s, \"#timestamp\": %s}]}",dtostrf(tempf, 4, 2, tempfbuf), dtostrf(humidity, 4, 2, humiditybuf), dt);
client.publish(MQTTSNTOPIC, pub_json);
Serial.println("TEMPERATURE BEING PUBLISHED...");
Serial.println(pub_json);
delay(60000 * 10);
}
//---------------------------------------------------------------
void getWeather()
{
// Measure Relative Humidity from the HTU21D or Si7021
humidity = sensor.getRH();
// Measure Temperature from the HTU21D or Si7021
tempf = sensor.getTemp();
// Temperature is measured every time RH is requested.
// It is faster, therefore, to read it from previous RH
// measurement with getTemp() instead with readTemp()
}
//---------------------------------------------------------------
void printInfo()
{
//This function prints the weather data out to the default Serial Port
Serial.print("Temp:");
Serial.print(tempf);
Serial.print("F, ");
Serial.print("Humidity:");
Serial.print(humidity);
Serial.println("%");
}
The mosquitto.conf file was nonexistant when I first downloaded mosquitto, so I created it and used this:
Please tell me if I posted sensitive information: I am new to this :)
c4message_size_limit 0
clientid bridgeawsiot2
persistence true
persistence_file mosquitto.db
persistence_location /var/mosquitto/
log_type all
connection_messages true
log_timestamp true
allow_anonymous true
password_file /etc/mosquitto/conf.d/users
allow_anonymous true
listener 9001 127.0.0.1
protocol websockets
connection_messages true
log_timestamp true
listener 1883
connection <awsiot>
address yl42kju76zjjodsbm6nfl4yycq.ap-northeast-1.es.amazonaws.com:8883
topic /esp8266/Si7021/slack out 1
cleansession true
notifications false
start_type automatic
bridge_cafile /etc/mosquitto/certs/root-CA.crt
bridge_certfile /etc/mosquitto/certs/RAS-XD.cert.pem
bridge_keyfile /etc/mosquitto/certs/RAS-XD.private.key
Maybe the problem is the websockets thing?
Any help is appreciated!
Literally any :)

Answer 1

I am doing some pretty good work with the esp8266 and mqtt using arduino IDE. I have mine logging on to my own mqtt broker I set up in a centos 7 box with encryption using x509 certs.
I use mosquitto-auth-plug to manage user access with a mysql database set up on the same machine
when you think about it the operating system is free, mosquitto broker is free, and mysql server is free.
the only expense to having your own setup is a fixed IP and fast enough connection. Which you could set up pretty cheap in a virtual machine on azure.
Anyhow when I first started a friend (the guy who sold me my first nodemcu .9 board). Hooked me up with this script and I have been able to get it all done using this as my example.
the part I liked was if you monitored your mqtt from a client like mqtt box or others. When the chip first starts it sends payload "Start" to topic "device_name/status". This way you can always tell when it's online.
I copied the notes he gave me they are located below.
good luck
/*
* Skeleton for ESPP based sensors.
* Supports:
* - OTA fw update via HTTP
* http://ipaddr/update
* - REST access
* http://ipaddr:8080/<id>
* - MQTT publish and subscribe
*/
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>
#include <ESP8266HTTPUpdateServer.h>
#include <aREST.h>
// Define device name
const char* device_name = "myHostName";
const char* ssid = "WiFiSSID";
const char* password = "wiFiPassword";
const char* mqtt_server = "mqtt_hostname.example.com";
char host[14];
int rest_test = 7467;
/* WiFi Client */
WiFiClient espClient;
/* MQTT Client */
PubSubClient client(espClient);
/* HTTP client, for remote updates */
ESP8266WebServer httpServer(80);
ESP8266HTTPUpdateServer httpUpdater;
/* Rest server */
aREST rest = aREST();
WiFiServer restServer(8080);
void setup() {
char topic[80];
Serial.begin(115200);
/* Start WiFi */
setup_wifi();
/* Setup MQTT client */
client.setServer(mqtt_server, 1883);
client.setCallback(mqtt_callback);
/* Start the HTTP update server */
MDNS.begin(host);
httpUpdater.setup(&httpServer);
httpServer.begin();
MDNS.addService("http", "tcp", 80);
/* Set REST variables */
rest.set_id("1");
rest.set_name(host);
rest.variable("test", &rest_test);
/*
rest.variable("temperature", &temp);
rest.variable("distance", &dist);
rest.variable("reset_count", &reset_count);
rest.set_id("1");
rest.set_name("esp8266");
*/
restServer.begin();
/* Connect to the MQTT broker */
reconnect();
client.subscribe("network/broadcast");
sprintf(topic, "network/%s", device_name);
client.subscribe(topic);
sprintf(topic, "%s/status", device_name);
client.publish(topic, "start");
Serial.print("Node ");
Serial.print(device_name);
Serial.println(" started.");
Serial.print("Hostname ");
Serial.println(host);
Serial.print("IP Address ");
Serial.println(WiFi.localIP());
}
void setup_wifi() {
uint8_t mac[6];
delay(10);
WiFi.begin(ssid, password);
WiFi.macAddress(mac);
sprintf(host, "esp-%02x%02x%02x", mac[3], mac[4], mac[5]);
WiFi.hostname(host);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
}
}
/* Handle incoming MQTT messages */
void mqtt_callback(char* topic, byte* payload, unsigned int length) {
char payloadStr[80];
if (length > 79) {
length = 79;
}
memcpy(payloadStr, payload, length);
payloadStr[length] = '\0';
if (strcmp(payloadStr, "discover") == 0) {
delay(random(10, 1000));
client.publish("network/presence", device_name);
}
if (strcmp(payloadStr, "refresh") == 0) {
/* Publish all sensor data */
}
}
/* Connect (or re-connect) to the MQTT broker */
void reconnect() {
// Loop until we're reconnected
while (!client.connected()) {
// Attempt to connect
/* TODO: Create this based on the MAC address */
if (client.connect(host)) {
} else {
// Wait 5 seconds before retrying
delay(5000);
}
}
}
void loop() {
WiFiClient restClient;
/* Check MQTT connection, reconnect if needed */
if (!client.connected()) {
reconnect();
}
/* Process MQTT tasks */
client.loop();
/* Process HTTP FW update requests */
httpServer.handleClient();
/* Process REST requests */
restClient = restServer.available();
if (restClient) {
while (!restClient.available()) {
delay(1);
}
rest.handle(restClient);
}
/* Insert normal sensor code here. */
/* Publish results with client.publish(topic, value); */
}
My code sets up it's own device name, subscribes to the MQTT topics "network/broadcast", "network/(device name)".
When it starts it sends "(device_name)/status" with a payload of "start".
When it gets a "network/broadcast" with a payload of "discover" it replies by publishing a "network/presence" and its name.
Basically, you sent MQTT events with client.publish(topic, payload).
You subscribe to events with client.subscribe(topic).
When an event is received that matches your subscription it will call mqtt_callback and give it the topic, the payload, and the length.
Hope that helps.