Docs
ExamplesGet started with popular boardsGet started with our kits

In this article

AllThingsTalk + NodeMCU: Getting Started in Less Than 15 Minutes

A guide that will show you how easy it is to integrate your NodeMCU with AllThingsTalk interactively without any additional hardware.
This guide will also work with any ESP8266 based device with minimal modifications.

Things you’ll do

After following this guide, you’ll have your NodeMCU sending values from its analog pin to your AllThingsTalk Maker page.

If you’d like to go a step further, you’ll be able to do so at the end of this guide where you’ll be challenged to set a counter that’s triggered once you touch the analog port of your NodeMCU, increasing the number of the counter by one and uploading the number to the platform! (Don’t worry, we got your back if you need help)

What you’ll need

  • AllThingsTalk Maker Account (Free)
  • NodeMCU Board

Steps you’ll go through

  • Installing Arduino IDE
  • Setting up NodeMCU Board Support
  • Installing Libraries
  • Create a Device in AllThingsTalk Maker
  • Configuring the Example Sketch
  • Uploading the Example Sketch
  • Testing it
  • [For the more curious]

Installing Arduino IDE

The Arduino Integrated Development Environment (IDE) is an open source, cross-platform application that’s used for programming Arduino boards! It runs on Windows, Mac OS X, and Linux.

Download the Arduino IDE here

Setting up NodeMCU Board Support

Some Arduino compatible boards (such as our NodeMCU) require board support to be installed additionally inside the Arduino IDE. It’s a simple step, so let’s get on with it!

Note: If you already have ESP8266 support installed, skip this step and go straight to Installing Libraries.

In the Arduino IDE, Go to File > Preferences for Windows and Arduino > Preferences on MacOS and add the following URL to Additional Board Manager URLs:

1
http://arduino.esp8266.com/stable/package_esp8266com_index.json
  • Confirm by clicking OK
  • Open the Board Manager via Tools > Board > Board Manager
  • Search for, select and install the “esp8266” by the ESP8266 Community. Once done, click Close

Installing Libraries

We’ll need a few libraries that the example sketch relies on, so let’s install them:

  • In Arduino IDE, go to Sketch > Include Library > Manage Libraries
  • Search for “pubsubclient” and install “PubSubClient” by Nick O’Leary
  • Search for “ArduinoJson” and install “ArudinoJson” by Benoit Blanchon
  • Click Close. Done!

Create a Device in AllThingsTalk Maker

To create a new device in AllThingsTalk maker, do the following:

  • Sign in/up to maker.allthingstalk.com
  • Select your Ground (every new account has an automatically created “Playground” ground)
  • Create a new device by clicking “+ New Device”
  • Select the Arduino tile and name your device
  • Click on your newly created device
  • Click “Create Asset”
  • Select “Sensor” as kind, enter “Analog” as name (or choose your own name), and select “Integer” as type:

Configuring the Example Sketch

Now we’re going to program our NodeMCU board using the sketch (program) below.
To do this, download the following code below and open it in Arduino IDE, or just copy/paste it into your Arduino IDE:

Download (.ino) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

const char*     WIFI_SSID          = "Your_WiFi";                                           // Your WiFi Network Name (SSID)
const char*     WIFI_PASSWORD      = "Your_WiFi_Password";                                  // Your WiFi Network Password
const char*     WIFI_HOSTNAME      = "ATTalk-NodeMCU-Analog";                               // Hostname of this NodeMCU that'll be presented on your local network

const char*     MQTT_CLIENT_ID     = "ATTalk-NodeMCU-Analog";                               // Name of the device that'll be presented to the MQTT broker
const char*     MQTT_SERVER_IP     = "api.allthingstalk.io";                                // MQTT/Platform Server Address
const uint16_t  MQTT_SERVER_PORT   = 1883;                                                  // MQTT/Platform Server Port
const char*     MQTT_USER          = "Your_Device_Token";                                   // MQTT Username (Go to AllThingsTalk > Devices > Your Device > Settings > Authentication > Device Tokens to get yours)
const char*     DEVICE_ID          = "Your_Device_ID";                                      // Go to AllThingsTalk > Devices > Your Device > Settings > Authentication > Device ID to get your Device ID
const char*     ASSET_NAME         = "Your_Asset_Name";                                     // Replace this with the name of your Asset

unsigned long startMillis;
unsigned long currentMillis;
const long    period               = 2000;            // Change this to change how many milliseconds you want between analog port readings
int           analogButton         = 0;               // Variable that will store the value of the analog port

WiFiClient wifiClient;
PubSubClient client(wifiClient);

void setup() {                                         // setup() is always called at boot
  Serial.begin(9600);                                  // Starts the Serial port for user debugging
  delay(500);                                          // A little bit of delay so none of the first messages get cut off
  Serial.print("Connecting to WiFi: ");                // Prints to Serial port
  WiFi.mode(WIFI_STA);                                 // Sets the NodeMCU into WiFi Station mode (client)
  Serial.print(WIFI_SSID);                             // Prints the WiFi Connection name on Serial port
  WiFi.hostname(WIFI_HOSTNAME);                        // Sets the NodeMCU's Hostname that'll be shown in local network
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);                // Connects to WiFi using the credentials entered above
  while (WiFi.status() != WL_CONNECTED) {              // Checks if WiFi connection has been made. If not,-
    delay(500);                                        // it waits 500ms and-
    Serial.print(".");                                 // prints a dot via Serial port and tries again.
  }
  Serial.println();                                    // Adds a new text row in Serial port
  Serial.print("WiFi Connected with IP Address: ");    // Prints this to Serial port
  Serial.println(WiFi.localIP());                      // Prints the current IP assigned to NodeMCU via Serial port
  client.setServer(MQTT_SERVER_IP, MQTT_SERVER_PORT);  // Sets the MQTT server and server port
  startMillis = millis();                              // Saves the initial millis value at boot to startMillis variable
}

void analogCheck() {                                   // This is the main function that checks the value of analog port
  currentMillis = millis();                            // Saves the value of "millis()" at the time of execution of this line
  if (currentMillis - startMillis >= period) {         // If current time minus the last saved startMillis time is bigger than the period defined above, it'll run the code below
    analogButton = analogRead(A0);                     // Reads the analog port A0 of NodeMCU and saves it to "analogButton" variable
    Serial.print("Current Analog Value: ");            // Prints to Serial port
    Serial.println(analogButton);                      // Prints to Serial port
    publishData(analogButton, DEVICE_ID, ASSET_NAME);  // Calls the function below, which publishes the data to AllThingsTalk
    startMillis = currentMillis;                       // Resets the startMillis by assigning it the value of currentMillis
  }
}

void publishData(int data, const char* device, const char* asset) {   // Accepts data (payload) as input as well as the ATTalk Device ID and Asset Name
  Serial.println("Now publishing data to AllThingsTalk...");          // Prints to Serial port
  char topic[128];                                                    // Creates a char buffer for the MQTT topic we're about to built
  snprintf(topic, sizeof topic, "%s%s%s%s%s", "device/", device, "/asset/", asset, "/state");     // Builds the MQTT Topic
  StaticJsonDocument<100> doc;                                        // Creates a buffer for Json
  char JSONmessageBuffer[100];                                        // Variable in a fromat that pubSubClient supports and in which arduinoJson will print in
  doc["value"] = data;                                                // Creates one entity in the Json message and assigns it the value of "data", which is the first input of this function
  serializeJson(doc, JSONmessageBuffer);                              // Serializes the message and prints it to our variable JSONmessageBuffer we created
  client.publish(topic, JSONmessageBuffer, false);                    // Once the Json message has been built, this line publishes it to AllThingsTalk
}

void reconnect() {                                                        // Function used to connect/reconnect to AllThingsTalk MQTT
  while (!client.connected()) {                                           // Do the things below if MQTT isn't connected
    Serial.println("Attempting to connect to AllThingsTalk via MQTT..."); // Prints to Serial port
    if (client.connect(MQTT_CLIENT_ID, MQTT_USER, "arbitrary")) {         // Tries to connect to AllThingsTalk with values defined at the beggining of this example. The "arbitrary" is the password. It's not required for connecting in this case. 
      Serial.println("Success! Connected to AllThingsTalk via MQTT!");    // Prints to Serial port
    } else {                                                              // If it fails, it runs the code below
      Serial.print("MQTT Connection Failed. Trying in 5 seconds. rc=");   // Prints to Serial port
      Serial.println(client.state());                                     // Prints the MQTT error to Serial port
      delay(5000);                                                        // Waits 5 seconds and then retries the whole process
    }
  }
}

void loop() {                  // Main code that'll be run in loop all the time
  if (!client.connected()) {   // Constantly checks if the device is connected to AllThingsTalk MQTT
    reconnect();               // Runs the "reconnect" function above if it isn't
  }
  client.loop();               // Keeps the MQTT connection alive
  analogCheck();               // Runs our "analogCheck" function, which checks the value of analog port and publishes it
}

As you may have noticed, the code has a lot of comments (shown after each “//”).
There’s a reason for that. If you’re curious on how the program works, you’ll be delighted to see that the purpose of every line of code was explained so you could understand what’s going on and hopefully play with it and change it in your own way!
However, if you’re eager to see the whole thing in action, let’s jump straight into it and configure the code!

  • Change _“YourWiFi” to your WiFi Network’s name
  • Change _“Your_WiFiPassword” to your WiFi Network’s Password
  • Change _“Your_DeviceToken” to your device’s token on AllThingsTalk.
  • To get this value, go to your device on AllThingsTalk, click “Settings”, then click “Authentication” and copy the device token from “Device Tokens”
  • Change the _“Your_DeviceID” to your Device ID.
    To get _“Your_DeviceID” go to your AllThingsTalk devices, select the Arduino device we created, click “Settings”, then choose “Authentication” and copy the Device ID value.
  • Change the “Your_Asset_Name” to your Asset’s name.
    If you followed the guide strictly, it should be “Analog”.

Once done, yours should look a little something like this:

Now comes the part where we upload the program to our NodeMCU board!

Uploading the Example Sketch

Now you’re going to upload the sketch you just configured onto your NodeMCU:

  • Plug your NodeMCU to your computer via USB
  • Go to Tools > Board > NodeMCU 1.0 (ESP-12E Module)
  • In Arduino IDE, go to Tools > Ports and choose the port that the device is on (should be the only one you can see)
  • Click Sketch > Upload or just click CTRL+U

In the bottom part of the Arduino IDE, you should see a message “Compiling sketch” and it should start uploading it to your NodeMCU right after that.
Once you see “Done Uploading.”, the code has been uploaded to your NodeMCU and you’re all set!
You can now go to Tools > Serial Monitor to actually see what’s happening on your NodeMCU. We suggest giving your NodeMCU a reset (by pressing the RST button on your NodeMCU) once you actually enter the Serial Monitor, just so you could see what’s going on from the beginning:

If your NodeMCU has connected to the internet and if you see the “Now publishing data to AllThingsTalk” in your Serial Monitor, it means you’re good to go!

Testing it

Go to your AllThingsTalk device page and you should see the Analog asset show you the value of your NodeMCU’s Analog pin!
And now, for the real trick, try touching the Analog pin (marked as “A0” on your NodeMCU) and see the value of your Asset on AllThingsTalk update in real-time!

Congratulations!
You’ve just successfully integrated your NodeMCU with the platform. And yes, it’s that easy!
Now, this is barely scratching the surface of what’s possible with our platform and the device in front of you, so if you’re curious, we suggest you start poking through the code and try to make it do something different!

For the more curious

Could you make a counter that would increment every time you touch the analog pin of your NodeMCU and upload the current number to your AllThingsTalk device page?
Don’t be discouraged, it may sound hard, but it’s actually very easy and doesn’t require a whole lot of stuff to make it happen. Oh, and you also have the comments on the code to help you understand what’s going on!
Give it a try and if you get stuck, we’ve already wrote the code for you to help you out, and you can use it if you need it (don’t cheat!). Happy making!

Download (.ino) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

const char*     WIFI_SSID          = "Your_WiFi";                                           // Your WiFi Network Name (SSID)
const char*     WIFI_PASSWORD      = "Your_WiFi_Password";                                  // Your WiFi Network Password
const char*     WIFI_HOSTNAME      = "ATTalk-NodeMCU-Analog";                               // Hostname of this NodeMCU that'll be presented on your local network

const char*     MQTT_CLIENT_ID     = "ATTalk-NodeMCU-Analog";                               // Name of the device that'll be presented to the MQTT broker
const char*     MQTT_SERVER_IP     = "api.allthingstalk.io";                                // MQTT/Platform Server Address
const uint16_t  MQTT_SERVER_PORT   = 1883;                                                  // MQTT/Platform Server Port
const char*     MQTT_USER          = "Your_Device_Token";                                   // MQTT Username (Go to AllThingsTalk > Devices > Your Device > Settings > Authentication > Device Tokens to get yours)
const char*     DEVICE_ID          = "Your_Device_ID";                                      // Go to AllThingsTalk > Devices > Your Device > Settings > Authentication > Device ID to get your Device ID
const char*     ANALOG_ASSET_NAME  = "Your_Analog_Asset_Name";                              // Replace this with the name of your Analog Asset
const char*     COUNTER_ASSET_NAME = "Your_Counter_Asset_Name";                             // Replace this with the name of your Counter Asset

unsigned long startMillis;
unsigned long currentMillis;
const long    period               = 2000;           // Change this to change how many milliseconds you want between analog port readings
int           analogTrigger        = 50;             // If exceeded, it's considered a touch and the counter increments. Change this to "calibrate" it
int           counterMax           = 10;             // Maximum value the counter can reach before resetting itself
int           analogButton         = 0;              // Variable that will store the value of the analog port
int           analogCounter        = 1;              // Initial value of the counter

WiFiClient wifiClient;
PubSubClient client(wifiClient);

void setup() {                                         // setup() is always called at boot
  Serial.begin(9600);                                  // Starts the Serial port for user debugging
  delay(500);                                          // A little bit of delay so none of the first messages get cut off
  Serial.print("Connecting to WiFi: ");                // Prints to Serial port
  WiFi.mode(WIFI_STA);                                 // Sets the NodeMCU into WiFi Station mode (client)
  Serial.print(WIFI_SSID);                             // Prints the WiFi Connection name on Serial port
  WiFi.hostname(WIFI_HOSTNAME);                        // Sets the NodeMCU's Hostname that'll be shown in local network
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);                // Connects to WiFi using the credentials entered above
  while (WiFi.status() != WL_CONNECTED) {              // Checks if WiFi connection has been made. If not,-
    delay(500);                                        // it waits 500ms and-
    Serial.print(".");                                 // prints a dot via Serial port and tries again.
  }
  Serial.println();                                    // Adds a new text row in Serial port
  Serial.print("WiFi Connected with IP Address: ");    // Prints this to Serial port
  Serial.println(WiFi.localIP());                      // Prints the current IP assigned to NodeMCU via Serial port
  client.setServer(MQTT_SERVER_IP, MQTT_SERVER_PORT);  // Sets the MQTT server and server port
  startMillis = millis();                              // Saves the initial millis value at boot to startMillis variable
}

void analogCheck() {                                              // This is the main function that checks the value of analog port
  currentMillis = millis();                                       // Saves the value of "millis()" at the time of execution of this line
  if (currentMillis - startMillis >= period) {                    // If current time minus the last saved startMillis time is bigger than the period defined above, it'll run the code below
    analogButton = analogRead(A0);                                // Reads the analog port A0 of NodeMCU and saves it to "analogButton" variable
    Serial.print("Current Analog Value: ");                       // Prints to Serial port
    Serial.println(analogButton);                                 // Prints to Serial port
    if (analogButton >= analogTrigger) {                          // Checks if the current analog port value is bigger than the threshold we've set for trigger
      Serial.println("Counter triggered! Incrementing...");       // Prints to Serial port
      analogCounter++;                                            // If it is, increment the analogCounter value
      if (analogCounter > counterMax) {                           // Checks if the current analogCounter value is bigger than the maximim we've set
        analogCounter = 1;                                        // If it is, reset the counter to 1
        Serial.println("Counter has been reset!");                // Prints to Serial port
      }
      publishData(analogCounter, DEVICE_ID, COUNTER_ASSET_NAME);  // Publish the analogCounter value
      Serial.print("Published counter value: ");                  // Prints to Serial port
      Serial.println(analogCounter);                              // Prints the current counter number to Serial port
      delay(1000);                                                // Creates a 1 second dalay between this and next message being sent
    }
    publishData(analogButton, DEVICE_ID, ANALOG_ASSET_NAME);      // Calls the function below, which publishes the data to AllThingsTalk
    startMillis = currentMillis;                                  // Resets the startMillis by assigning it the value of currentMillis
  }
}

void publishData(int data, const char* device, const char* asset) {   // Accepts data (payload) as input as well as the ATTalk Device ID and Asset Name
  Serial.println("Now publishing data to AllThingsTalk...");          // Prints to Serial port
  char topic[128];                                                    // Creates a char buffer for the MQTT topic we're about to built
  snprintf(topic, sizeof topic, "%s%s%s%s%s", "device/", device, "/asset/", asset, "/state");     // Builds the MQTT Topic
  StaticJsonDocument<100> doc;                                        // Creates a buffer for Json
  char JSONmessageBuffer[100];                                        // Variable in a fromat that pubSubClient supports and in which arduinoJson will print in
  doc["value"] = data;                                                // Creates one entity in the Json message and assigns it the value of "data", which is the first input of this function
  serializeJson(doc, JSONmessageBuffer);                              // Serializes the message and prints it to our variable JSONmessageBuffer we created
  client.publish(topic, JSONmessageBuffer, false);                    // Once the Json message has been built, this line publishes it to AllThingsTalk
}

void reconnect() {                                                        // Function used to connect/reconnect to AllThingsTalk MQTT
  while (!client.connected()) {                                           // Do the things below if MQTT isn't connected
    Serial.println("Attempting to connect to AllThingsTalk via MQTT..."); // Prints to Serial port
    if (client.connect(MQTT_CLIENT_ID, MQTT_USER, "arbitrary")) {         // Tries to connect to AllThingsTalk with values defined at the beggining of this example. The "arbitrary" is the password. It's not required for connecting in this case. 
      Serial.println("Success! Connected to AllThingsTalk via MQTT!");    // Prints to Serial port
    } else {                                                              // If it fails, it runs the code below
      Serial.print("MQTT Connection Failed. Trying in 5 seconds. rc=");   // Prints to Serial port
      Serial.println(client.state());                                     // Prints the MQTT error to Serial port
      delay(5000);                                                        // Waits 5 seconds and then retries the whole process
    }
  }
}

void loop() {                  // Main code that'll be run in loop all the time
  if (!client.connected()) {   // Constantly checks if the device is connected to AllThingsTalk MQTT
    reconnect();               // Runs the "reconnect" function above if it isn't
  }
  client.loop();               // Keeps the MQTT connection alive
  analogCheck();               // Runs our "analogCheck" function, which checks the value of analog port and publishes it
}