1 #ifndef FUNCTIONS_H
2 #define FUNCTIONS_H
3
4 #include <stdint.h>
5 #include <Arduino.h>
6
7 #include <ESP8266WiFi.h>
8
9 void setup_wifi();
10
11 #include <PubSubClient.h>
12
13 void setup_mqtt();
14
15 void MQTT_callback(char *topic, byte *payload, int length);
16 void MQTT_reconnect();
17 void MQTT_beacon();
18
19 void DOtheBloodyMQTT();
20
21 void setup();
22 void loop();
23
24 bool getTimer(unsigned long &timer, unsigned long interval);
25 void blinkLED(); // Just a little function to blink the LED for the beacon function.
26 void DoLights(char *WhatToDo); // Turn LED on/off
27 void DoAnswer(char *WhatToDo); // Send back text
28 void DoControl(char *WhatToDo); // Send MQTT to another device/topic
29
30 #endif // FUNCTIONS_H
1 #ifndef TOPSECRET_H
2 #define TOPSECRET_H
3
4 // WiFi
5 // Store your WiFi credentials here.
6 // Update these with values suitable for your network.
7
8 #define WAP 0
9 // Allow testing on the various networks at the lab...
10 #if WAP==0
11 const char* WiFi_ssid = "TinkerToys";
12 const char* WiFi_password = "password";
13 #elif WAP==1
14 const char* WiFi_ssid = "TinkerToysB";
15 const char* WiFi_password = "password";
16 #elif WAP==2
17 const char* WiFi_ssid = "vanneck";
18 const char* WiFi_password = "password";
19 #else
20 const char* WiFi_ssid = "VictoriaDrive2B";
21 const char* WiFi_password = "password";
22 #endif
23
24 const char* WiFi_ClientName = "GimmeAName";
25
26 // MQTT
27 // Store your MQTT credentials here.
28 // Update these with values suitable for your network.
29
30 // Set BrokerName OR BrokerIP, not both...
31 const char* MQTT_broker = "BROKER.DOMAIN.TLD";
32 // const int* MQTT_BrokerIP = { 192, 168, 0, 12 };
33
34 const char* MQTT_user = "";
35 const char* MQTT_pass = "";
36
37 const char* MQTT_ClientName = "GimmeAName";
38
39 #endif // TOPSECRET_H
1 #ifndef BOTSECRET_H
2 #define BOTSECRET_H
3
4 ////////////////////////////////////////////////////////////////
5 extern char* WiFi_ssid;
6 extern char* WiFi_password;
7 extern char* WiFi_ClientName;
8 ////////////////////////////////////////////////////////////////
9
10 ////////////////////////////////////////////////////////////////
11 extern char* MQTT_broker;
12 extern char* MQTT_user;
13 extern char* MQTT_pass;
14 extern char* MQTT_ClientName;
15 ////////////////////////////////////////////////////////////////
16
17 #endif // BOTSECRET_H
1 #ifndef MQTT_H
2 #define MQTT_H
3
4 #define MQTT_BUFFER_SIZE (50) // This number is arbitrary
5
6 char MQTT_outTopic[MQTT_BUFFER_SIZE];
7 char MQTT_inTopic[MQTT_BUFFER_SIZE];
8 char MQTT_teleTopic[MQTT_BUFFER_SIZE];
9 char MQTT_statTopic[MQTT_BUFFER_SIZE];
10
11 char MQTT_msg_out[MQTT_BUFFER_SIZE];
12
13 unsigned long beacon_timer = 0;
14 #define BEACON_INTERVAL 30000 // Timer interval for the "keep-alive" status beacon
15
16 #endif // MQTT_H
1 #include "TopSecret.h"
2 #include "functions.h"
3
4 ////////////////////////////////////////////////////////////////
5 //
6 // This version roughly based on principles from:
7 // https://community.platformio.org/t/tutorial-for-creating-multi-cpp-file-arduino-project/5830/43
8 //
9 // Need to look further into "extern"
10 // https://stackoverflow.com/questions/10422034/when-to-use-extern-in-c
11 //
12 ////////////////////////////////////////////////////////////////
13
14 void setup()
15 {
16 Serial.begin(115200);
17 delay(50); // Delay to let the ESP get booted before sending out serial data
18 Serial.printf("\n+---------------------------------------+\n");
19 Serial.printf("| ESP MQTT Testing |\n");
20 Serial.printf("+---------------------------------------+\n");
21
22 setup_wifi();
23
24 setup_mqtt();
25
26 pinMode(LED_BUILTIN, OUTPUT);
27 digitalWrite(LED_BUILTIN, HIGH);
28
29 }
30
31 void loop()
32 {
33 // put your main code here, to run repeatedly:
34 DOtheBloodyMQTT();
35 }
1 #include "functions.h"
2 #include "BotSecret.h"
3
4 ////////////////////////////////////////////////////////////////
5 // WiFi Functions
6 ////////////////////////////////////////////////////////////////
7
8 void setup_wifi()
9 {
10
11 // We start by connecting to a WiFi network
12 Serial.printf("| |\n");
13 Serial.printf("| Connecting to: %-22s |\n", WiFi_ssid);
14 Serial.printf("| ");
15
16 WiFi.mode(WIFI_STA); // Connecting as a STATION
17 WiFi.begin(WiFi_ssid, WiFi_password);
18
19 int dotcount = 0;
20 while (WiFi.status() != WL_CONNECTED) // Give it a bit of time to establish the WiFi connection...
21 {
22 dotcount++;
23 delay(500);
24 Serial.printf(".");
25 }
26
27 for (int i = 0; i < (38 - dotcount); i++)
28 {
29 Serial.printf(" ");
30 }
31 Serial.printf("|\n");
32
33 Serial.printf("| WiFi connected on Channel %-2d |\n", WiFi.channel());
34 // Serial.printf("|Channel: %d\n", WiFi.channel());
35 Serial.printf("| IP address: %-15s |\n", WiFi.localIP().toString().c_str());
36 Serial.printf("+---------------------------------------+\n");
37
38 #ifdef DEBUG0
39 WiFi.printDiag(Serial);
40 #endif
41 }
1 #include "functions.h"
2 #include "BotSecret.h"
3
4 #include "MQTT.h"
5
6 WiFiClient espClient;
7 PubSubClient MQTT_client(espClient);
8
9 void DOtheBloodyMQTT()
10 {
11 if (!MQTT_client.connected())
12 {
13 MQTT_reconnect();
14 }
15 MQTT_client.loop();
16 MQTT_beacon();
17 }
18
19 ////////////////////////////////////////////////////////////////
20 // MQTT Functions
21 ////////////////////////////////////////////////////////////////
22
23 void setup_mqtt()
24 {
25 MQTT_client.setServer(MQTT_broker, 1883);
26 MQTT_client.setCallback(MQTT_callback);
27
28 // Build the topic names
29 strcpy(MQTT_inTopic, "cmnd/"); // in - Commands
30 strcat(MQTT_inTopic, MQTT_ClientName);
31 strcat(MQTT_inTopic, "/#");
32 strcpy(MQTT_teleTopic, "tele/"); // out - Telemetry
33 strcat(MQTT_teleTopic, MQTT_ClientName);
34 strcpy(MQTT_statTopic, "stat/"); // out - Status
35 strcat(MQTT_statTopic, MQTT_ClientName);
36 strcpy(MQTT_outTopic, "noti/"); // out - Notifications
37 strcat(MQTT_outTopic, MQTT_ClientName);
38
39 MQTT_reconnect();
40 Serial.printf("+---------------------------------------+\n");
41 }
42
43 void MQTT_callback(char *topic, byte *payload, int length)
44 {
45
46 char MQTT_msg_in[MQTT_BUFFER_SIZE];
47 char *MQTT_command = strrchr(topic, '/');
48
49 #ifdef DEBUG
50 Serial.printf("| |\n");
51 Serial.printf("| Message arrived |\n");
52 Serial.printf("| Command: %28s |\n", MQTT_command);
53 #endif
54
55 if (length < MQTT_BUFFER_SIZE)
56 {
57 for (int i = 0; i < length; i++)
58 {
59 MQTT_msg_in[i] = (char)payload[i];
60 MQTT_msg_in[i + 1] = '\0';
61 }
62
63 #ifdef DEBUG
64 Serial.printf("| Message: %28s |\n", MQTT_msg_in);
65 #endif
66 /////////////////////////////////////////////////////
67 // Message handling goes here...
68 /////////////////////////////////////////////////////
69 if (strcmp(MQTT_command, "/lights") == 0)
70 {
71 DoLights(MQTT_msg_in);
72 }
73 else if (strcmp(MQTT_command, "/respond") == 0)
74 {
75 DoAnswer(MQTT_msg_in);
76 }
77 else if (strcmp(MQTT_command, "/control") == 0)
78 {
79 DoControl(MQTT_msg_in);
80 }
81 else
82 {
83 #ifdef DEBUG
84 Serial.printf("| Dunno Whatcha want... |\n");
85 #endif
86 }
87 }
88 else
89 {
90 #ifdef DEBUG
91 Serial.printf("| But, it's TOO Bloody Big! |\n");
92 #endif
93 }
94 }
95
96 void MQTT_reconnect()
97 {
98 // Loop until we're reconnected
99 while (!MQTT_client.connected())
100 {
101 Serial.printf("| |\n");
102 Serial.printf("| Attempting MQTT connection... |\n");
103 // Create a random client ID
104 String clientId = MQTT_ClientName;
105 clientId += String(random(0xffff), HEX);
106 // Attempt to connect
107 if (MQTT_client.connect(clientId.c_str()))
108 {
109 Serial.printf("| connected to %-24s |\n", MQTT_broker);
110 Serial.printf("| My Name: %-27s |\n", MQTT_ClientName);
111 // Once connected, publish an announcement...
112 MQTT_client.publish(MQTT_statTopic, "hello world");
113 // ... and resubscribe
114 MQTT_client.subscribe(MQTT_inTopic);
115 }
116 else
117 {
118 Serial.printf("| |\n");
119 Serial.printf("| failed, rc=%d |\n", MQTT_client.state());
120 Serial.printf("| trying again in 5 seconds |\n");
121 // Wait 5 seconds before retrying
122 delay(5000);
123 }
124 }
125 }
126
127 void MQTT_beacon()
128 {
129 /* Beacon signal published at set interval to indicate the device
130 * is still powered up and actively connected to MQTT...
131 * A keepalive of sorts
132 * also updates state within MQTT so it can be captured for
133 * indicator light elsewhere
134 */
135 if (getTimer(beacon_timer, BEACON_INTERVAL))
136 {
137 MQTT_client.publish(MQTT_teleTopic, "boop");
138 blinkLED();
139 }
140 }
141
142 ////////////////////////////////////////////////////////////////
143 // Random cmnd handlers for testing...
144 ////////////////////////////////////////////////////////////////
145
146 void DoLights(char *WhatToDo) // Turn LED on/off
147 {
148 Serial.printf("[- Lights - %3s -]\n", WhatToDo);
149 if (strcmp(WhatToDo, "ON") == 0)
150 digitalWrite(LED_BUILTIN, LOW);
151 if (strcmp(WhatToDo, "OFF") == 0)
152 digitalWrite(LED_BUILTIN, HIGH);
153 }
154
155 void DoAnswer(char *WhatToDo) // Send back text
156 {
157 Serial.printf("[- Responding: %-23s -]\n", WhatToDo);
158 MQTT_client.publish(MQTT_outTopic, WhatToDo);
159 }
160
161 void DoControl(char *WhatToDo) // Send MQTT to another device/topic
162 {
163 /*
164 Should be something along the lines of,
165
166 MQTT_client.publish(TopicFromMessage, MessageFromMessage);
167
168 Where
169 TopicFromMessage
170 is an MQTT topic for sending to another device
171 and
172 MessageFromMessage
173 is the message to publish to that topic...
174 */
175 }
1 #include "functions.h"
2
3 ////////////////////////////////////////////////////////////////
4 // Supplimentary Functions
5 ////////////////////////////////////////////////////////////////
6
7 bool getTimer(unsigned long &timer, unsigned long interval)
8 /* Global timer function, used a lot
9 *
10 * @param unsigned long time - The current timer
11 * @param unsigned long interval - Length of time to run timer
12 *
13 * @return bool True when timer is complete
14 * @return bool False when timer is counting
15 */
16 {
17
18 if (timer < 1)
19 {
20 timer = millis();
21 }
22
23 if (millis() - timer >= interval)
24 {
25 timer = 0;
26 return true;
27 }
28
29 return false;
30 }
31
32 void blinkLED() // Just a little function to blink the on-board LED for the beacon function.
33 {
34 digitalWrite(LED_BUILTIN, LOW);
35 delay(10);
36 digitalWrite(LED_BUILTIN, HIGH);
37 delay(10);
38 digitalWrite(LED_BUILTIN, LOW);
39 delay(10);
40 digitalWrite(LED_BUILTIN, HIGH);
41 }
1 [env:esp07]
2 platform = espressif8266
3 board = esp07
4 framework = arduino
5 monitor_speed = 115200
6 build_flags =
7 -D DEBUG
8
9 lib_deps =
10 PubSubClient
