web-engineering.info - Arduino

Seeeduino XIAO - A Tiny Arduino Zero Variation

mdiaconescu — Mon, 17 Aug 2020 10:02:49 +0000

You may like to check our other WoT/IoT related articles.

Another Arduino Compatible Board?

You probably asked yourself a few times: what, another Arduino compatible board? Why shall I choose this one over the other one? Is this "the one" for my project?

If you are not familiar with Arduino, you shall have a look at the Arduino official website. You may also be interested in reading our WoT with Arduino for Beginners tutorials.

A simple answer for all or each of these questions does not really exist. A few other questions must be answered first: which features do I really need for my project? Is it battery powered? How much $$$ do I want to spend (or do I have available) for the project? Where do I buy the board? Does it have a "real" community? ... and so on.

The expectations: a new Arduino "compatible" board is also a progress step, so at least in theory it must have "something" that makes it "better" or at least "different". Many of these boards have just (some) minor hardware changes when comparing them with the equivalent Arduino brother, but their price is the one of a coffee cup, thus making them attractive for the very beginner or for low cost projects - this is also the case of many "Arduino clone" boards. Other boards have relevant hardware improvements, but usually (at least at the release time) have a higher price. Such boards have for example a better MCU (higher speed, amount of RAM and FLASH) and usually a larger features pack, like I2C, SPI, UART, CAN, touch sensor interface, ADC, DAC, etc. Finally, a few of them combine most of the goodies in a (very) tiny board and have the price of two beers or coffee cups. In the former category, we also find the Seeeduino XIAO board.

While XIAO is not necessarily "the perfect Arduino compatible board", it is among the few ones that for around five bucks, comes in a very low size, has a MCU capable of coping with demanding tasks, requires just a little amount of power, has 11 GPIOs that can be either used for digital or analog operations and supports a lot of the standard protocols. The compatibility with the Arduino IDE and many of the existing libraries is also very good, and in practice this means that it can be a replacement for the Arduino Zero (or its smaller brothers) board in many projects.

Technical Description and Features

A brief description of the most important features and technical characteristics of the XIAO board are provided in Table 1.

Table 1: XIAO Technical Specs.
Feature	Description
MCU	32 Bit ARM Cortex-M0+ @48MHz
RAM	32KB SRAM
FLASH	256KB
GPIOs	11 analog/digital pins A0-A10 analog (-0.3 - 3.3V) D0-D10 digital (max. 7mA / pin)
DAC	pin D0/A0 10 Bit, 350ksps
ADC	pin A0-A10 12 Bit, 350ksps
UART	TX: pin A6/D6 RX: pin A7/D7
I2C	SDA: pin A4/D4 SCL: pin A5/D5
SPI	MOSI: pin A10/D10 MISO: pin A9/D9 SCK/SCLK: pin A8/D8 CS/SS: any GPIO but D8, D9, D10
IRQ	all GPIOs support interrupts, but GPIO A5/D5 and GPIO A7/D7 cannot be used at the same time
PWM	available on pins D1-D10
SWD	Serial Wire Debug (SWD) is available as exposed pads on the back of the board
RTC	32-bit Real Time Counter (RTC) with clock/calendar function but requires the board to be powered
Builtin LEDs	one green power led one yellow user led two blue serial port LEDs
Power Supply	Option 1: 5V via USB-C port Option 2: 4-6V via power pads Note: The power pads are on the back of the board (see Figure 3).
Reset	exposed reset pads on the front (See Figure 2) and on the back (See Figure 3) of the board
Size	20x17.5x3.5mm (See Figure 1)

Figure 1: XIAO Board Size.

Figure 2: XIAO Board Pinout.

Figure 3: the Back of the XIAO Board.

Benchmark Test

We performed a benchmark test on the XIAO Board, by using the Paul Stoffregen's CoreMark GitHub project. The Table 2 shows a comparison with a few other Arduino or Arduino compatible boards which we have available on our toolbox. The results were rounded up to the closest integer value.

Table 2: CoreMark Benchmark
Board	Result
Teensy 4.0 (ARM Cortex-M7 @600MHz)	2309
Teensy 3.2 (ARM Cortex-M4 @72MHz)	167
Arduino Due (AT91SAM3X8E @84MHz)	91
Arduino Zero (ATSAMD21G18 @48MHz)	53
Seeeduino XIAO (ATSAMD21G18 @48MhZ)	52
Arduino Mega (ATmega2560 @16MHz)	8

As expected, in terms of the CoreMark benchmark, the little XIAO board behaves very similar with Arduino Zero, which also uses the ATSAMD21G18, 32-Bit ARM Cortex M0+ chip familly.

Note: A CoreMark test with an Arduino UNO Rev 3 was not possible, due to its low amount RAM that causes instability problems, and as a result the board keeps restarting itself every a few seonds.

The Power Consumption

Not necessarily each WoT/IoT project is battery powered, nor require a very low power consumption. However, we still need to think on our "little and still green planet" and use the limited resources responsible. Believe it or not, but a few extra mW does really matter - as of 2020 over 30 billion IoT devices are estimated as being used all over the world and connected to the Internet. In addition, there are many other such devices not (yet) connected to the internet. Elementary math show us that even 1mW (milli watts!) extra power consumption, actually means 30MW (mega watts!), and this just for the IoT devices connected to the Internet. So, yes, it does really matter to keep the power consumption reduced at the minimum, at least when that is possible.

In our opinion, this little XIAO guy, was well designed, and the power consumption is quite low for what this board can do. The MCU plays a key role, since it takes most of the power juice, but the hardware design is also an important factor. Many other Arduino compatible boards, use additional components or modules (sometimes justified, sometimes not really), thus increasing the power consumption of the board. For example, various sensors or wireless communication modules (WiFi, Bluetooth, RF, etc) are incorporated in some boards. While this is not every time the case, and by this we mean "having the board filled up with as many goodies as possible" in terms of hardware features, such features are in fact underused. As a result, they don't only take additional space on the board and increase the price but also produce a bit more CO₂ using additional power when the board is powered, and of course at the time of being produced by the factory.

While we are really fans of the ESP8266, ESP32 and alike boards, they do not represent the answer to all our problem. Sure, it makes a lot of sense to use the powerful MCU and the included WiFi or Bluetooth features when needed, but for example these are a very bad replacement for a simple IoT temperature monitoring node, where an ATMega 328 MCU (e.g., Arduino Nano), a temperature / humidity sensor (e.g., DHT11 / DHT22) and a nRF24-based transmitter/receiver (e.g., nRF24L01+) make much more sense. Using the Arduino Nano, a nRF24L01+ module and a DHT11 / DHT22 sensor the power consumption will go around 30mA@5V (so, about 150mW). This can be reduced even more by using 3.3V instead of 5V and an efficient LDO, thus going down to about 40mA@3.3V (so about 132mW). The Arduino Nano can be successfully replaced with the XIAO board, and the power requirements do not increase, actually it can go down if your project is well designed. An ESP32 or ESP8266 will be less efficient by a few factors of magnitude, even with the WiFi and/or BT deactivated.

The XIAO Board uses the XC6206. According to the datasheet of this voltage regulator, the maximum input voltage is 6V, so this will also be the maximum voltage that it can be supplied to the board either via the contact pads located on the back of the board (see Figure 3) or via the USB-C connector (which normally shall provide about 5V). It can output a maximum of 200mA of current, but we do not recommend more than 150mA to avoid overheating it. Moreover, keep in mind that up to about 25mA may be used by the MCU and the other components (LEDs, voltage regulator, etc), so the conservative current available for the user, to power sensors and any other devices is about 120mA. Moreover, keep in mind that the GPIO pins can only supply a little amount of current. According with the specs, this can go up to 7mA (source) or 10mA (sink) per pin, but for this a special bit/flag shall be enabled, and this also comes with some other disadvantages. The real "by default" current for each GPIO pin is 2.5mA (sink) or 2mA (source) per pin.

Keep this in mind: you can easily burn up a GPIO or even destroy the MCU completely if the source or sink current is larger than 2.5mA (sink) or 2mA (source) even if this happens for very short amount of time. Something like half of a second is more than enough to destroy your MCU or GPIO if the current is exceeded. By setting the Output Driver Strength bit (DRVSTR) to 1 for a specific pin, a maximum of 10mA (sink) and 7mA (source) can be obtained. More details about this are available on the section 37.9 I/O Pin Characteristics of the SAMD21D datasheet document.

Using our digital multimeter UNI-T model UT71C we made some measurements to see how this board performs in terms of power requirements. In Table 3 we provide the obtained results.

Table 3: Power Consumption Measurements
Conditions	Results	Details
Input voltage via USB-C port: 4.95V Sketch: LED Blink every second Sketch	12.4mA@4.95V (61.38mW)	Measured when the blinking LED is ON.
Input voltage via USB-C port: 4.95V Sketch: the CoreMark benchmark	13.5mA@4.95V (66.82mW)	Measured during the benchmark runtime.
Input voltage via USB-C port: 4.95V Sketch: Sleep Mode with RTCZero Library	2.2mA@4.95V (10.89mW)	The MCU itself uses less than 1mA (the RTC and some other services are active). The rest is used by the power LED and the voltage regulator.

Get Started with the XIAO board and the Arduino IDE

The XIAO board can be programmed by using the Arduino IDE and the "Arduino Programming Language". Well, to be clear here, there is no such thing as "Arduino Programming Language", it is really just C/C++, but there is a trend to use this metaphor whenever the Arduino core and custom libraries are used. There following steps will guide you to get started with your first Arduino sketch and having the XIAO user controlled LED blinking.

Download the official Arduino IDE software if you didn't already. We also recommend to use the latest version available to avoid various issues caused by old bugs and to get access to the newest features.
Add Seeeduino to your Arduino IDE. For this, use the "File > Preference" menu item and copy/paste the following URL https://files.seeedstudio.com/arduino/package_seeeduino_boards_index.json into the "Additional Boards Manager URLs" input field.
Use the "Tools > Board > Boards Manager..." menu item, and in the new open window, search and install the "Seeed SAMD Boards". After this step we recommend to restart your Arduino IDE.
Open the Blink sketch by using the "File > Examples > 01.Basics > Blink" menu item.
Select the "Tools > Board > Seeed SAMD (32-bits ARM Cortex-M0+ and Cortex-M4) Boards > Seeeduino XIAO" menu item. This will instruct Arduino IDE what to do when you like to compile and upload a sketch.
Select the "Tools > Port > COMxx (Seeeduino XIAO)" menu item. COMxx represents the COM port to which the XIAO board connects too.
Now use the "Sketch > Upload" menu item to have the sketch compiled and uploaded to your board. It may take a up to one minute to complete this task, in particular when the sketch was not yet compiled and your PC is not the fastest one in the world.

If all went well, when the upload is completed your XIAO shall have the yellow user LED blinking once every second.

Note: in our experience, most of the time this board can't be switched to programming mode automatically. What you shall do is to use some tweezers or a conductive tool (e.g., a small flat head screwdriver) and to touch the two reset pins from the front of the board - these are located near the A0/D and A1/D2 GPIO pins (see Figure 2). Notice that you have to repeat this twice, in a short time (i.e., twice in about one second). After that, the board enters boot-loading mode (the green and yellow LEDs must be on at this point) and the uploading of your sketch will work as expected. Notice that this will also switch the used COM port, thus you have to select the new one by using the "Tools > Port > COMxx (Seeeduino XIAO)" menu item.

Some Final toughts

We played with the little XIAO for a few months by now and we have used it in a few of our projects already. It is for sure not perfect, and there are a few issues with it, like the need to manually enter boot-loading mode every time when it needs to be reprogrammed, the low amount of current available to each GPIO or the incompatibility with a few Arduino libraries. The 11 GPIO pins are also not enough for projects that requires more than just one or two sensors, a switch and eventually an I2C or SPI display. In many of our projects however, the board filled up the requirements and being so tiny, it fitted with ease in almost any case of the IoT/WoT nodes. Therefore, whenever we do not need WiFi / BT, a faster MCU or more GPIO pins, we do consider using XIAO before jumping further with our searches. The low price is also a big plus, in particular when you need a lot of such boards and the total price can rise up very fast.

Do we recommend the XIAO board? Yes, it is a very good candidate for many low power projects. It is also very small and very cheap, so you don't need to break the bank when you need a few of them for your project.

Is is perfect candidate for any project? No, unfortunately it is not. Among the reasons, an important one is the reduced number of GPIO pins. In this case, you either have to look further for another board, but then expect a larger sized board and very likely a higher price too, or you think on using a "GPIO multiplier", such as the MCP23017 IC, which will give you 8 I/O pins with 25mA per pin at the expense of the I2C pins of your board.

What's next?

The the "Green Balcony" project is work in progress. Among others, it makes use of a few Seeeduino XIAO boards, used to control the watering of the plants as well to monitor various aspects, such as the water tank level, temperature and to keep an eye on the light intensity variation. Since the balcony is populated with very different species of plants (blackberry, raspberry, a small fig tree and various flowers), it is important and interessant as well to observe the light variation. This will help to decide the optimal position for the plants, to have them as "happy" as possible, and get their smile when drinking the morning coffee in the green seven square meter mini-garden. Since only solar power is used for this project, keeping an eye on the light intensity provides also indications about the optimal positioning of the 10W solar panel used to collect the "free" energy from the sun.

Note: yes, we know that there is no such thing as free energy. We use here the term of free energy only as a metaphor, with the meaning of energy that is not taken from the grid. In term of costs, this actually means, the costs of the equipment used to collect it (solar panel, charge controller, battery, wires, etc) - theoretically no other costs are involved, practically, we'll see...

Stay tuned, a set of tutorials providing step-by-step implementation instructions of the "Green Balcony" project will be published soon!

PRODINo: Home Automation with ESP8266 based WiFi Control

mdiaconescu — Sun, 27 Nov 2016 14:30:39 +0000

What is PRODINo WiFi-ESP?

PRODINo is an industrial grade, ESP8266 based WiFi module (uses the WROOM-2 official ESP8266 module) that is designed and produced by KMP Electronics LTD, based in Bulgaria. The module contains four high power relays, allowing to control all kind of appliances, including some that require mains power. It opens the door for DIY (but not only) projects that otherwise would have been required careful design and good electronics knowledge, normally possible only for specialists or requiring a lot of time for design and implementation. Moreover, using ESP8266 allows not only for WiFi network connection, but also provides space for hacking and tweaking, using custom firmware if Arduino is not what you want to use, and even giving you access to your project from the Internet, which however comes with security risks and requires additional care.

Disclaimer: working with electricity is very dangerous! The module we are going to discuss uses 3.3-5VDC, as well as mains voltage (110 - 250V). Working with electricity can cause bad injuries and even death if not used with care. We cannot be held responsible for any caused damage or any harm brought to yourself! Do it at your own risk and/or ask help from an electronics engineer.

Hardware Specifications

The used relay specification (15A@125VAC, 15A@24VDC, 10A@250VAC) allows for up to 2500W for each output. In addition, it provides four optically isolated inputs (using the Toshiba TLP185 opto-coupler), meaning that it does not only allow to read data, e.g., from sensors, but also makes this operation (relatively) safe, allowing to connect 3-30V sources without killing the ESP8266 module or its GPIOs, since they are only up 3.3V tolerant. In Table 1 we show the complete electrical specs for this module:

Name	Min	Max	Unit
Size	-	70 x 32 x 92	mm
Module power supply	5	30	V
Module power supply @5V	150	400	mA
DC Input (opto-couplers)	3	30	V
Output AC (relay)	-	2500 (10A@250VAC) 1800 (15A@120VAC)	W
Output DC (relay)	-	360 (15A@24VDC)	W

The relays are not driven directly by using the ESP8266 GPIOs but with the help of an MCP23S08 IC (see Figure 2), that is an 8-bit, general purpose, parallel bidirectional I/O expansion for SPI (an I2C version of it, i.e., MCP23008, is also available). The optically isolated inputs use the same MCP23S08 IC (see Figure 2), which means that most of the ESP8266 GPIOs remains practically unused, and most of those I/O pins (including the analog one) are brought out via connectors (which unfortunately are not standard 2.54 male or female headers). To drive the relay coils (requires ~5V@72mA for each), the MCP23S08 is connected to an ULN2003A IC (see Figure 2), which is a 7 port Darlington Transistor Array, allowing an output of up to 50V@300mA per port. This may be a bit of an overkill for this design, but allows for some error margins and also some higher powered relays on future module releases, or...to be replaced by the DIY project author (we love hacking!).

Figure 1: PRODINo WROOM-02 Module Specs.

As visible on the product label, shown in Figure 1, the specified output per relay is only 5A, which at the highest voltage (250VAC) means 1250W. We are not sure if this is just a very conservative specification, with respect to the usage of this module, thus allowing for a large safety margin or simply because of some other design considerations that we are not aware of. From our perspective, both the relays (specified for 10A@250V) and the ULN2003A IC that drives the relay coil can easily handle a much higher output (lets say about 2000W, keeping some safety margins).

Figure 2: PRODINo WROOM-02 Module Board (Front).

Programming the PRODINo

Programming the module requires to use the included FTDI module. However, it is also possible to use a cheap (under 2 EUR) USB-TTL converter module, as long as it supports 3.3V output on its TX (UART transmit) line. Make sure that the FTDI module, that comes on the packet, has the voltage selection jumper set to 3.3V position, as shown in Figure 3. Make sure that you connect the FTDI module in the correct position (see Figure 3), otherwise you may kill the PRODUINo module.

Note: the "Auto-Flash" jumper located just on the right site if the UART connector (see Figure 2), below the "Flash" button, can be set, thus allowing to program the ESP8266 module (the brain of the PRODINo module) without your direct intervention: there is no need to ground the GPIO 0 or to push some sort of "Set to Flash Mode" button. The alternative is to use the "Flash" button, located above the "Auto-Flash" jumper, (see Figure 2). This makes sense when using an USB-TTL module that does not allow to ground the GPIO 0 pin of the ESP8266 module, for all the other cases, just enable the "Auto-Flash" jumper.

Figure 3: FTDI Programmer Connected to PRODINo WROOM-02 Module Board.

Use Arduino IDE to Program a PRODINo Module

It is fairly easy to program the PRODINo module, by simply using the Arduino IDE and Arduino code. Thus, if you ever used the Arduino IDE and wrote some code for one or more of the Arduino boards, you are ready to go with the PRODINo module.

First, you'll need to download the Arduino IDE from the official download page. Make sure that you download the correct version corresponding to your operating system. Also, specially when using UNIX/Linux systems, make sure that your user has the rights to use "COM" ports, that are required by the FTDI module when programming the PRODINo board.

Next, start the Arduino IDE and navigate to File > Preferences menu. In the section "Additional Boards Manager URLs", copy and paste the following URL: https://raw.githubusercontent.com/kmpelectronics/Arduino/master/ProDinoEsp8266/package_prodino-esp8266_index.json, used to indicate the location of the JSON which describes the PRODINo module and the additional Arduino libraries that it requires. Further, use the Tools > Board Manager menu, and from the list of the additional (custom) boards, select the "PRODINo WiFi board by KMP Electronics LTD" one, then click "Install". In a short amount of time the installation process is completed and we are ready to go with the programming of the PRODINo WiFi-ESP module.

Later, when you'll like to write your custom program to the PRODINo module, use the small arrow icon from the left-top of the Arduino IDE user interface or use the Sketch > upload menu (its keyboard shortcut is CTRL + U). Remember, you'll need to use the Tools menu to select the corresponding board (use: PRODINo WiFi-ESP WROOM-2) and COM port (this can be different from case to case, but usually is something like COM4, COM5, etc).

Controlling the Relays

The first feature we like to test is the control of the four relays. We'll write the most basic Arduino program that allows to switch ON or OFF any of the four relays, by simply using a HTML form. At first, lets write the HTML form, which sends a POST request to the PRODINo module. The full content of the index.html HTML file is shown below:

<!DOCTYPE html>
<html>
  <head>
    <title>PRODINo Relay Controller</title>
  </head>
  <body>
   <form method="POST" action="http://192.168.4.1/relay">
    <label>Select relay:
      <select name="relayId">
        <option value="0">Relay 1</option>
        <option value="1">Relay 2</option>
        <option value="2">Relay 3</option>
        <option value="3">Relay 4</option>
      </select>
    </label>
    <label>Select relay state:
      <select name="relayState">
        <option value="1">On</option>
        <option value="0">Off</option>
      </select>
    </label>
    <input type="submit" value="Save relay state" />
   </form>
  </body>
</html>

Pushing the "Save relay state" form submit button, a standard HTML POST request is made to http://192.168.4.1/relay. The request URL consists of: 1) the IP address of our PRODINo module (defaults to 192.168.4.1, but it can be changed if needed or wanted); 2) a custom path that handles the requests (we chose to use /relay).

Two HTML select elements are used for our form. The first one uses the name relayId (this is the parameter name received on the POST request) and allows to select the relay we'll like to control. Allowed values are from 0 (first relay from left to right when watching the relay connectors on the module) to 3 (the most right relay). The second HTML select uses the name, relayState, and allows to specify the state of the selected relay. We'll use 1 for enable (turn ON) and 0 for disable (turn OFF).

Let's now write the Arduino code that intercepts the HTTP post request and turn the corresponding relay ON or OFF based on our selection in the HTML form:

#include <KMPDinoWiFiESP.h>
#include <KMPCommon.h>
#include <ESP8266WebServer.h>

const char WIFI_PSK[] = "1a2b3c4d";
const char SSID[] = "Charlie's Home";
const uint8_t PORT = 80;
ESP8266WebServer webServer(PORT);

void setup(void) {
  // initialize the PRODINo board
  KMPDinoWiFiESP.init();
  // setup the WiFi module as AccesPoint (AP Mode).
  WiFi.mode(WIFI_AP);
  // set the SSID and Password for the AP
  WiFi.softAP(SSID, WIFI_PSK);
  // set the HTTP route for the relay control
  webServer.on("/relay", handleRelayRoute);
  // start the web server
  webServer.begin();
}

void loop(void) {
  webServer.handleClient();
}

void handleRelayRoute() {
  int8_t relayId = -1;
  bool relayState = 0;
  // incomming POST request (two expected params: relayId and relayState).
  if (webServer.method() == HTTP_POST && webServer.args() == 2) {
    for (uint8_t i = 0; i < webServer.args(); i++) {
      if (webServer.argName(i) == "relayId") {
        relayId = CharToInt(webServer.arg(i)[0]);
      } else if (webServer.argName(i) == "relayState") {
        relayState = CharToInt(webServer.arg(i)[0]);
      }
    }
    KMPDinoWiFiESP.SetRelayState(relayId, relayState);
    webServer.send(200, TEXT_HTML, "OK");
  } else {
    webServer.send(400, TEXT_HTML, "Bad request");
  }  
}

The set of #include directives allows to load the required libraries, which were automatically added when installing the new PRODINo board manager module. Further, for the WiFi name, the WiFi shared password and the server port, the corresponding SSID, WIFI_PSK and PORT constants are defined. Feel free to alter the SSID and WIFI_PSK values, but let the PORT value unchanged (port 80 is the HTTP port).

As part of the Arduino setup method, we initialize the module and set the WiFi in AP (access point) mode. Then, we register the /relay route (as used for the @action attribute of the HTML form element) and the corresponding handler method, i.e., handleRelayRoute. Last, we start the web server by calling its begin method.

The handleRelayRoute method, the handler for the /relay HTTP route, checks if the used HTTP request is of type POST and if there are exactly two parameters provided (recall, we expect the relayId and relayState parameters to be sent). If that is the case, then we extract the relay identifier and the desired relay state, then we change the relay to that state by using the KMPDinoWiFiESP.SetRelayState method and we respond with HTTP code 200, having the meaning "all went fine for the request". If the request type is not of type POST or there are more or less than two parameters, then a HTTP error code 400 is sent, which means "bad request - wrong parameters or request type!"

The Arduino loop method simply waits for requests, by using the ESP8266WebServer.handleClient method.

To test, upload the following code to the PRODINo board (as shown before in this tutorial), then connect to the WiFi network with the name set by the SSID variable. Open the index.html HTML page, and use the form to turn ON or OFF the relays you'll like to test.

Download the code

Reading the Inputs

The second important feature we like to test is the optically isolated inputs. For this, we'll write a simple Arduino program that is able to read the states of all four optically isolated inputs and return the result. A HTML GET request for the path /opto is used, i.e., http://192.168.4.1/opto. The response is plain text with the format I_x is HIGH | LOW;.

#include <KMPDinoWiFiESP.h>
#include <KMPCommon.h>
#include <ESP8266WebServer.h>

const char WIFI_PSK[] = "1a2b3c4d";
const char SSID[] = "Charlie's Home";
const uint8_t PORT = 80;
ESP8266WebServer webServer(PORT);

void setup(void) {
  // initialize the PRODINo board
  KMPDinoWiFiESP.init();
  // setup the WiFi module as AccesPoint (AP Mode).
  WiFi.mode(WIFI_AP);
  // set the SSID and Password for the AP
  WiFi.softAP(SSID, WIFI_PSK);
  // set the HTTP route for the DHT22 sensor readings
  webServer.on("/opto", handleOptoRoute);
  // start the web server
  webServer.begin();
}

void loop(void) {
  webServer.handleClient();
}

void handleOptoRoute() {
  bool optoState;
  String result = "";
  // incomming GET request (get the state of all opto-inputs)
  if (webServer.method() == HTTP_GET) {
    for (uint8_t i = 0; i < 4; i++) {
      optoState = KMPDinoWiFiESP.GetOptoInState(i);
      result.concat("I_");
      result.concat(i);
      result.concat(" is ");
      result.concat(optoState == true ? "HIGH" : "LOW");
      result.concat("; ");
    }
    webServer.send(200, TEXT_HTML, result);
  } else {
    webServer.send(400, TEXT_HTML, "Bad request");
  }  
}

Compared with the relays example, we have a few relevant differences. The first one is in the setup method, for which we register the new route, /opto and the new handler, handleOptoRoute. The second change is in the handleOptoRoute method, as part of the request method detection, where now we expect a HTTP GET type instead of POST. The last one is the reading of the optically isolated inputs, made with the help of the KMPDinoWiFiESP.GetOptoInState(inputId) method, which as as parameter the input number (0 to 3). A less significant change regards the creation of the GET response body, which consists of chain of "I_x is HIGH | LOW;" strings, one for each of the four inputs (response example: I_0 is LOW; I_1 is HIGH; I_2 is HIGH; I_3 is LOW;).

To test this example, write the Arduino program to your PRODINo board (as shown above in this tutorial), then connect to the WiFi network with the name set by the SSID constant. Open a Web Browser and navigate to http://192.168.4.1/opto. For this case we don't need a HTML form, since GET is the default request type you get by simply using the URL in the URL bar of a web browser.

Note: normally, you'll only see only "LOW" states for all the input pins. Also, notice that those inputs are actually in pair of two for each input, since they are practically diodes. You'll need to provide HIGH (more than 0.5VDC) or LOW (less than 0.5VDC) voltages at the corresponding diode end to achieve the expected results. The product cover has labels clearly showing which pin represents which end of the corresponding diode (see also Figure 1).

Homework: modify the above Arduino program so that the number (0 to 3) of the optically isolated input is provided as part of the HTML GET request, and the response is either "HIGH" or "LOW" depending on the state.

Download the code

More Examples for PRODINo

It looks that the PRODINo team had a busy time, so an impressive number of usage scenarios and examples are available and ready to use. You'll certainly want to check the Arduino IDE File > Examples > Examples for PRODINo WiFi-ESP menu and chose the one you'll like to test. The example set includes the use of PRODINo as server, access point and client, with the help of the WiFi module and also shows how to provide a HTML interface that allows to control the relays or to show the state of the optically isolated inputs by simply using a web browser, available on any PC or smart device, such as a smartphone, smartwatch or table.

Conclusions

After having quite some fun with the PRODINo WiFi-ESP WROOM-2 v1.0 module and taking a closer look at its hardware components and design, we found it to be user friendly and easy to use for DIY IoT projects, even for beginners. The quality of the board, its electrical design (also check the schematics) and the selection of the electronic components, sets the PRODINo device into the semi-professional category. The price range makes possible its usage for most of the DIY or professional projects / products. Below are the most relevant pros and cons we have found for this module:

Pros:

low-to-medium price: 40-47 EUR, exclusive shipping costs, but including the FTDI programmer;
DIY ready and user friendly: if you ever played with Arduino IDE and some Arduino boards, you are ready to go with PRODINo;
(almost) ready to use out of the box: it comes together with the FTDI FTD232R based programmer/debugger module, but notice that you'll need a 5-30V@400mA+ power supply (or an USB breakup cable) and a mini USB cable (for programming only).
allows to control four appliances with up to 2500W each: unfortunately, with the current design, it is not possible to directly parallel the outputs for even higher power;
isolated inputs: four optically isolated inputs are available, thus the ESP8266 module is safe, even when inputs are misused;
uses the official WROOM-02 ESP8266 module: ensures a good WiFi experience and allows for lots of hacks and software tweaks, including the use of JavaScript as the programming language, when the appropriate firmware is uploaded;
(almost) open source: its electrical schematics are made public and a module (and corresponding libs) is available for the Arduino IDE board manager, but it is unclear if you are allowed to improve the schematics and release them for public usage;
lots of usage examples: after installing the corresponding Arduino IDE module (via the board manager), more than sufficient examples are available (check the File > Examples > Examples for PRODINo menu in Arduino IDE).

Cons:

(somehow) limited number of inputs: only four (optically isolated) inputs are available, keeping in account that the MCP23S08 (8-bit, general purpose, parallel I/O expansion for I2C bus or SPI) is used, and the WROOM-2 module provides itself 9 GPIOs (including SPI and I2C ones);
hazard safety, while in general we found this module safe to be used, a better electrical isolation of the (possible mains connected) outputs would have helped to avoid electrical shocks, that can possibly cause injuries or even death (!). This is even more relevant, when the module is used for DIY projects implemented by amateurs. The plastic cover could have been extended over the output connections, thus making the (accidental) touching less probable.

Project Ideas

automatic home/garage door locker (and un-locker), based on the the location of your smartphone, and home monitoring by reading various available sensors, such as temperature, humidity, light intensity or air quality;
control the watering of your home plants or your backyard garden, by reading soil moisture sensors and enabling/disabling water pumps or water pipe connected electro-valves;
an alarm system that detects intrusion into a home (or perimeter) when we are in holidays, using PIR and capacitive touch sensors, allowing to trigger a high level alarm bugler and sending an e-mail to you whenever something suspicious is detected.

In further tutorials we'll show how to use JavaScript (Mongoose-IoT based firmware) code to program the PRODINo module. We'll also discuss how to write an Android App to control common used appliances from your house, such as unlocking the door and turning on the light when dark and you just reached the house after a hard work day.

WoT with Arduino for Beginners: Part 3 - Connecting to the Internet via WiFi

mdiaconescu — Wed, 20 Apr 2016 14:46:57 +0000

In this multi-part tutorial we show how to develop Arduino-based apps for the Web of Things (WoT). This third part shows how to set up a connection between an Arduino and the Internet via a WiFi network and use HTTP(S) to send data to a free cloud service like ThingSpeak. In the following parts of this tutorial, which will appear every 1-3 weeks, we discuss how to control actuators and connect them all together in a Web of Things (WoT) app. Using standard Web technologies, such as HTTP and Web Sockets, we can then access the data or provide commands to the WoT nodes. As a newbie, it is helpful if you already have some familiarity with C/C++ programming and Web technologies, such as HTML and JavaScript.

You may first want tor read the previous parts of this tutorial series:

This tutorial is part of our learning materials on the Web of Things published on web-engineeering.info.

Disclaimer: working with electricity is dangerous. For this project we'll use 5V, which is safe for the human body under any environment conditions. However, the low voltage may be obtained from a mains connected power brick, and therefore we highly recommend you to take safety precautions and to use a trustful brand for the power supply. We cannot be held responsible for any caused damage! Do it at your own risk and/or ask help from an electronics engineer. In case you are using the USB connector from your PC to power the Arduino board, be aware that short-circuits which may occur on the Arduino board may also have a negative impact on your PC!

Credits: some of the images from this tutorial are created by using Fritzing, a nice electronics modeling tool for beginners.

Arduino + ESP8266 = "I'm online, Mum!"

After we've managed to read data from the environment using sensors, we want to store the data for later use, such as statistical analysis or visualization. It would also be nice to if we could watch what's going on at the monitored site even when we are not around, by going to a website that provides access to the (current and historical) sensor data.

An Arduino can be connected to a network, and thus to the Internet, by using various networking modules, e.g., standard WiFi, wired Ethernet or Bluetooth, see Figure 1. Other custom solutions are also available, such as for example RF modules that communicate in the 315MHz-2.4GHz frequency range. However, such modules do not use the standard WiFi protocols, therefore you can't use them for directly connecting your Arduino to the Internet by simply using your WiFi router or repeater.

Figure 1: Network Connection Modules for Arduino.

A simple solution for having an Arduino connected to a WiFi network, and thus to the Internet, is to use an ESP8266 module. These modules are now widely available, with prices in the range of 2-8 EUR, including postage to the EU. Such a module is what we are going to use in this tutorial, and we intend to provide you with a guide on how to chose one, since multiple variants are available, how to update its firmware, since new versions are available almost every month, and how to use it to transmit and receive data by using standard Web technologies, such as HTTP(S).

Choosing an ESP8266 Module Version

Multiple versions of the ESP8266 WiFi module are available, we are aware about 12 of them, as shown in Figure 2.

Figure 2: Variants of the ESP8266 WiFi Module.

These modules use the 802.11b/g/n standard, operating at 2.4 GHz. This means, we can connect to a standard WiFi network, such as the one most of us have at home, provided by an WiFi router or access point (AP).

Having multiple variants of ESP8266 module, comes the question: "which one should I use ?". There is no perfect answer for this question, and it highly depends on what you are using the WiFi module for. These modules are not only a "blind" WiFi communication module, but are based on a MCU, which can be programmed and which have I/O pins, therefore it can do tasks similar with the ones available for the Arduino boards. Even more, the Arduino IDE supports ESP8266 programming, but details about this topic we'll discus in another tutorial. Regarding our question, there are three main reasons to consider when choosing an ESP8266 module:

usability on a breadboard: most of the times we prototype on a breadboard, therefore we should be able to connect these modules to such a board. Some of the modules, such as ESP02, ESP03 and ESP05 (see Figure 2) are breadboard friendly, having a pitch of 2.54mm (the distance between two pins). Other modules, such as ESP07 or ESP08 have a pitch of 1.27mm, thus you'll only be able to use them with a breadboard when using an adapter. Last, other modules, such as ESP01 have a pitch of 2.54mm, but they have a two-row header, which makes it impossible to use it with a breadboard, because the implied short-circuit between the pins. Notice that some of the breadboard friendly modules have only a half-way pin connections, see ESP02 module from Figure 2. Such connections are somehow harder to solder, specially for a beginner. Our tip: plug the pin headers into a breadboard, align the module on top of them, then solder.
flash memory size: this is very important to consider when choosing an ESP8266 module, because they come with permanent flash memory, which is usually in the range of 4MBit (512KB) up to 16MBit (2MB), but can go up to 128MBit (16MB). Starting with the firmware version 1.1.0 (released on June 2015), you'll need a module with at least 8MBit (1MB) flash size to burn the new firmware. Thus, pay attention when buy the module and be sure that you get one that has at least 8Mbit (1MB) flash size. In term of RAM and MCU frequency, they are mostly the same, so no need to worry about it. There are ways to improve the flash capacity, but for this you'll need good soldering skills to remove the old flash IC and solder the new one, and usually the price of the flash IC bought in small quantities is more than half of the ESP8266 module price, thus defeating the purpose. Excepting for the ESP06, ESP07, ESP08 and ESP12 modules, which have a metallic (hard to remove) cover over the CPU and flash IC, you can simply detect the flash size by reading the text on the 8 pin black IC soldered near the MCU (which is the square black IC with pins on all four sides). If the number on the flash IC starts with 25Q80 then you have a 8MBit sized one, while if it starts with 25Q40 then you have a 4MBit sized one.
MCU features: these modules are driven by a low power 32-bit RISC CPU (Tensilica Xtensa LX106) running at 80 MHz. It has 64 KB of instruction RAM, 96 KB of data RAM and supports external QSPI flash - 512 KB to 4 MB (up to 16MB is supported). I has 16 I/O pins, from which one has 10Bit ADC capabilities, and supports I2C, I2S, SPI and UART communication protocols. All these features are quite important if you are using the ESP8266 module as standalone controller board. However, if the ESP8266 module is used as WiFi interface only, then you'll not need these features, and you can chose the cheapest and board with suits your needs.

Based on the above considerations, we chose to use ESP02 module, because it is small, breadboard friendly (even if is not very easy to solder the pin header) and it has a connector for a 2.4GHz WiFi antenna, thus allowing for a good WiFi range, even when used indoors.

Update the ESP8266 Firmware

Disclaimer: perform the tasks shown on this section on your own risk. If something goes wrong, it may be possible to have a "bricked" module, which can't be used anymore or requires special tools to repair.

Normally, after buying an ESP8266 module, the first task is to ensure that it has the latest firmware, thus being able to use the latest features and having fixed various software related problems. But how do we know if the last firmware is burned into our ESP8266 module? To answer this question we need to connect the module to a computer by using a TTL module and a software, which allows us to communicate with the module and perform queries or provide commands. A TTL module (e.g. see Figure 3), see is a communication device that connects to an USB port of the computer and allows to map Serial protocol via the USB port. Its TX and RX pins connects to the RX and respective TX pins of the ESP8266 module (pay attention, the pins connection is twisted!). Such modules are quite cheap, having an approximate cost of about 2-3 EUR postage included in EU.

Figure 3: USB-TTL UART Module.

In Figure 4 and Figure 5 are shown the breadboard connection and the schematics of the circuit which allows us to have the ESP02 module communicating with a computer by using the serial port (UART communcation). A breadboard friendly power supply is used to provide the required 3.3V for the ESP8266 module. This specific one allows inputs in the range 5-12V and produce a steady 3.3V or 5V (a switch allows the selection) output, with a maximum current of 0.5A.

In addition, we need a software which allows us to have a user interface so we can send commands (or queries) to the module and see the module answer. While there are multiple software available for this purpose, we found Realterm as being very stable, free of charge and easy to use. Further in this tutorial we refer to Realterm when providing examples or screen shots related to this topic, but you are free to use others if you like, such as for example Putty.

Figure 4: ESP8266 PC USB Connection via TTL Module on a Breadboard.

Figure 5: Schematics of ESP8266 PC USB Connection via TTL Module.

It may be observed that two of the ESP8266 module pins are connected to VCC (3.3V) via 3.3kΩ resistors. This is required, because the RST (reset) and CH_PD (power down) pins must stay high during the normal operation of this module. One can use Arduino I/O pins to control the state of these pins, thus having reset and power down features for a project that implies to use the ESP8266 module, and allowing for lower energy consumption when WiFi transmission is not required. The ESP8266 module is able to recover very fast from a "power down" state, the wake-up time being in the order of milliseconds. However, after resetting the module, may take up to two seconds to have the module booted and a few other seconds until WiFi line is ready to be used.

Important: the connection between the GPIO0 of the ESP8266 module and GND (see the blue wire in Figure 4) is required when the firmware needs to be updated. In all the other case, you should remove this connection, otherwise your module will not communicate via the UART port (RX/TX lines). Removing or connecting GPIO0 pin to GND should be done ONLY when the module receives no power, so first turn OFF the power supply connected to module, then connect or disconnect the wire (or jumper) between the GPIO0 to GND.

The USB-TTL module we use has a 3.3V UART interface, therefore is no need to have an additional voltage LC (level converter) module. Before doing the connections, check if your module has already this feature, by measuring (using a voltmeter) the voltage between the GND and TX pins of the USB-TTL module. If you read a voltage value under 3.5V, then it is safe to connect the RX and TX pins of the USB-TTL module directly to the ESP8266 TX and RX pins. If you read more than 3.5V then you need to use a LC module to convert the 5V to 3.3V and back between the RX and TX lines of the ESP8266 module and the USB-TTL module. Ignoring this advice may result in a broken ESP8266 module, so do it at your own risk!

Note: it is strongly recommended to use a stable 3.3V power supply, which is able to provide current in excess of 500mA (0.5A). The ESP8266 module is in general power efficient, but during the data transmission, it may have peaks of up to 500mA. Powering it from the 3.3V rail of the Aruino board or from the 3.3V rail available for some USB-TTL module is NOT recommended and will very likely result in destroying the 3.3V voltage regulator of your Arduino board or of the USB-TTL board. We use a breadboard friendly power supply, able to provide 3.3V and 5V (a switch allow the selection) at up to 500mA (see Figure 4). This specific power supply cab be found very cheap, having prices of about 1-3 EUR postage in EU included.

After you have downloaded and installed Realterm, start it and select the baud rate (normally this defaults to 115200 for most of the ESP8266 modules we bought over the last 6 months) and the COM port (which in our case is 38, but may be different for you, so better check). Last, push the "Open" button, to create a Serial (UART) connection. If the "Open" button was already pushed, then push it again to its OFF state it and push it back to its ON state. Also, check Figure 6 for additional information.

Note: Realterm is highly configurable via command line parameters. Check the command line configuration parameters documentation for making your settings permanent (e.g., to have the program started with the COM port and baud-rate already set to whatever you like) or for having various other configurations.

Figure 6: Realterm Port and Baud-rate configuation.

At this moment we are ready to communicate with the ESP8266 module. First operation we like to perform is a reset, so we are able to see that the module reacts to our commands. For this, go to "Send" tab in Realterm UI and write "AT+RST" on the first text input box. Please check the "+CR" and "+LF" boxes located on the right of the first text input box, thus allowing to send a CR and LF chars at the end of the command, allowing the ESP8266 module to detect a "command end" limiter. You should see a result similar with the one shown in Figure 7, but some of the response text may differ in your case because of different firmware versions.

Figure 7: Sending Reset Command to ESP8266 Module.

Our initial purpose was to check if we have (or not) the latest firmware burned int our ESP8266 module. For this, following the same procedure as for "AT+RST" command, we send the "AT+GMR" command. Tee result we obtain is shown in Figure 8 but you may have a different one, because of a different firmware version burned into your module.

Figure 8: Sending 'Get Version' Command to ESP8266 Module.

As shown in Figure 8, the SDK firmware version of our module 1.3.0 and the AT version is 0.40.0, which are quite old (see also the date, is 8 August 2015!). Check if there is any available firmware update by navigating to http://bbs.espressif.com/ and look at the "SDK" section. We found that the current available firmware update is SDK version 1.5.3 and the current AT version is 1.1.0 (dated 16 April 2016).

Download the firmware following the links provided in the SDK download page, then unzip the archive somewhere on your PC hard drive. Open the ESP8266Flasher tool, available as download in the archive attached to this tutorial. Now follow the instructions shown in Figure 9, Figure 10 and Figure 11 to configure the tool for firmware update. Notice that in Figure 10, we have selected 1MB because our ESP02 module has a 8MBit (1MB) flash IC, but you should do the appropriate selection for your module if the flash IC is different. However, a flash IC with a size smaller than 1MB will not work, since the current firmware version is to big to fit. Such a module cannot be upgraded to a firmware version greater than 1.1.0 (which is quite old and misses a lot of features, so go and break your piggy bank and buy an appropriate ESP8266 module!).

Note: the ESP8266 firmware update tool, as well as the current version of the ESP8266 firmware is part of the download archive we provide with this article. However, new firmware versions may be released at anytime, so better check the http://bbs.espressif.com/ for being sure that you get the latest version.

Figure 9: Select Firmware Update Binaries.

Figure 10: Select Flash Size and Baudrate for Firmware Update.

Figure 11: Select COM Port for Firmware Update.

Last, start the firmware update by pushing the "Flash" button, shown in Figure 11. If all was correctly configure, you should see now the "AP MAC" and "STA MAC" fields (shown in Figure 11) filled in with values (as shown in Figure 12), and the blue bar starts to fill in, showing the progress (see Figure 12).

Figure 12: Firmware Update in Progress.

The update may take about a minute or two, and at the end, the ESP8266Flasher UI should look similar with Figure 13.

Figure 13: Firmware Update Completed.

At this point, you'll need to power down the ESP8266 module (disconnect the power supply), and remove the connection between the GPIO0 pin and GND, so the module does not enter firmware upgrade mode when powered up. Missing this step results in a non communicative module, therefore not responding to commands and looking as a broken one, software wise.

Start the Realterm, make the port configurations (discussed earlier in this section) and run the "AT+RST" command and then the "AT+GMR" command and check the results. If all went well, you should see results similar with the ones shown in Figure 14 and Figure 15.

Figure 14: Sending Reset Command to ESP8266 Module.

Figure 15: Sending 'Get Version' Command to ESP8266 Module.

Note: the "Display" tab of the Realterm UI provides useful settings for selecting how the data is displayed. Normally, you'll want to select "Ascii" or "Ansi" as the value of the "Display As" parameter. In addition to normal characters, from the ASCII table, the "Ascii" mode shows also the special chars, such as CR and LF, which are important when using Realterm to debug or control ESP8266 module.

Use Arduino and HTTP(S) to Access Online Services via an WiFi Network

In this section we are going to use Arduino UNO, ESP02 WiFi module (remember, we chose to use this specific one out of all existing variations) and the DHT22 temperature and humidity sensor. With the ESP02 module we are going to connect to a WiFi network, thus gaining access to internet. Using a free thingspeak.com account, we store the temperature and humidity values, with the purpose of having charts that shows the evolution over time. We send a sample every 15 seconds, since it is highly improbable to have changes of temperature and humidity values faster than this, which also provides a lower power consumption, since the ESP8266 modules are quite power efficient in "stand-by" mode, but this changes a lot when data is transmitted over WiFi.

It may be useful to have also a USB-TTL module near you, so in case of the case that your ESP8266 module seems irresponsible, you can try to provide commands directly via Realterm software, as discussed earlier in this tutorial.

Hardware Configuration

As shown in Figure 16 and Figure 17, for this project we need the following components:

An Arduino UNO board, but you can use almost any Arduino board, with minimal or no modifications.
An ESP02 WiFi module, but you can also use any of the 12 available versions, just remember to update the firmware.
A DHT22 temperature and humidity sensor, but if you like, DHT11/21 or LM35 are as good, you'll just need to adapt your code related to sensor reading.
A voltage LC module, that allows the communication between Arduino and ESP02 module, but you can skip this in case you are using a 3.3V Arduino board (e.g., Arduino DUE).
A voltage regulator module, that uses USB or a power brick to provide the 3.3V@500mA required by the ESP02, and most of the other ESP modules.
Three 10k resistors, used to PULL UP the DHT22 data pin and the RST and CH_PD pins of the ESP02 module.

In addition, an USB-TTL module may be useful for debugging, but this is not required for the functionality of the circuit. Notice that the connection between GPIO0 pin of the ESP8266 module and GND is dropped, that being only required for the firmware update. If you still have that connection, now is the case to disable it, because your module needs to boot up, and that is not the case as long as GPIO0 is connected to GND. You should let GPIO0 pin floating (not connected).

Figure 16: ESP8266 WiFi Module Connected to an Arduino UNO Board.

Figure 17: Circuit Diagram of an ESP8266 WiFi Module Connected to an Arduino UNO Board.

SoftwareConfiguration

In this section we'll learn how to use the AT commands set for being able to connect to a WiFi network, then using TCP connect to a live server, and last, send the temperature and humidity values to thingspeak.com for being stored and having displayed them as a chart.

Note: all the source code, including the required libraries are included in the zip archive available for download as part of this article (check the article head), but we encourage you to visit our github.com project page where you can download the latest changes, updates and fixes for this code and much more.

First, you'll need to setup a free account at thingspeak.com. Then, in the "Channel Settings" menu enable "Field 1" and "Field 2", and give them some human readable names, such as "DHT-Temperature" and "DHT-Humidity". Then, navigate to "Api Keys" menu and copy the "Write API Key" value and paste it on the ESP8266_DHT22.ino as the value of DATA_SERVER_API_KEY constant. The file ESP8266_DHT22.ino is located under under examples/ESP8266/ESP8266_DHT22 folder. Remember to replace also WIFI_SSID and WIFI_PASSWORD constants values with your own WiFi network credentials.

Second, you'll need to copy the DHTxx and ESP8266 folders, located under libraries sub-folder, into your libraries sub-folder of the Arduino IDE software. This is required because we'll use these two libraries with our example code.

Lets have now a look at the example code, part of the examples/ESP8266/ESP8266_DHT22/ESP8266_DHT22.ino Arduino sketch. Like with any Arduino porgram, we'll need to include the library headers, in our case these are DHTxx.h and ESP8266.h. We also define a constant for the I/O pin used to communicate with the DHT22 sensor, and a set of constants that stores the WiFi credentials (SSID and password), thingspeak.com server address (api.thingspeak.com), the TCP port used for connection, the request path and the thingspeak.com "Write API Key" (required for being able to write data).

#include <dhtxx.h>
#include <esp8266.h>
#define DHT_PIN 7

// WiFi authentication data
const char* WIFI_SSID = "your-wifi-ssid";
const char* WIFI_PASSWORD = "your-wifi-password";

// data server address and port
const char* DATA_SERVER_ADDRESS = "api.thingspeak.com"
const uint8_t DATA_SERVER_PORT = 80;

// data to be sent to the server
const char* DATA_SERVER_API_KEY = "your-thingspeak-write-api-key";
char* DATA_SERVER_PATH = "/update";

Further, we have to create the Dht and ESP8266 objects, responsible for the communication with the DHT22 sensor and ESP8266 WiFi module.

Dht dht(DHT_PIN, Dht::TypeEL::DHT22);
ESP8266 esp(Serial);

The Arduino board and the ESP8266 module communicates via the serial port, thus we use the Serial object as the middle-ware. The Serial global object, which is Arduino specific, is provided as parameter to the ESP8266 object and used internally to read and write data, as well as to deal with the incoming data streams and extract the relevant information.

The setup method takes care of the Serial port initialization (communication is made at 115200bps). In addition, it creates a loop while trying to connect the ESP8266 module to the specified WiFi network (credentials are provided by the WIFI_SSID and WIFI_PASSWORD constants).

void setup() {  
  Serial.begin(115200);
  esp.atCwmode(ESP8266::WiFiMode::STA);
  while (esp.atCwjap(WIFI_SSID, WIFI_PASSWORD) != ESP8266::Error::NONE);
};

The atCwjap method, part of the ESP8266 library, is responsible with the WiFi connection for the specified WiFi network. This method is the equivalent of AT+CWJAP="wifi-ssid","wifi-password" command, which we can send to the ESP8266 module, e.g., by using Realterm. The library we are using, contains a set of methods, most of them being a one-to-one mapping of a specific AT command, and the method name is the AT command name (e.g., AT+CWJAP has the equivalent method atCwjap). However, notice that this library does not covers the complete set of available AT commands.

It is important to know that the ESP8266 module may work in three different modes: client (STA), access point (AP) and both combined (AP+STA). The AT+CWMODE command allows to set one of these modes, and the used values are: 1 for STA, 2 for AP and 3 for AP+STA. E.g., AT+CWMODE=1 sets the module in client (station) mode. Our ESP8266 library has an equivalent method, atCwmode for this command. It takes as parameter an enumeration literal value, ESP8266::WiFiMode::xxx, where xxx = {STA, AP, AP_STA}. Since we use the WiFi module to connect to a network, she STA mode is the most appropriate, and we set this in the setup method. It will also work if AP+STA mode is used, but this have some security implications, because the WiFi module becomes also an WiFi access point that has internet access, and unless you know exactly what you are doing, it may open serious security back-doors in your network.

In the loop method (remember, this method executes again, and again as long as the Arduino receives power) we check if we have a WiFi connection, and if that is true, we perform a DHT22 sensor reading and sent it to thingspeak.com by using the sendDataToServer method, that we'll discuss further. We do this with a periodicity of 15 seconds, thus the delay(15000) call. Notice that the real time between sending data is larger, since various other delays occurs in the code, such as for the TCP connection, data sending, and so on.

void loop() {
  if (!checkWiFi()) return;
  Dht::Result result = dht.read();
  if (result.status == Dht::StatusEL::OK) 
    sendDataToServer(result.temperature, result.humidity);
  delay(5000);
};

The checkWifi method simply sends an AT command and waits for an OK, which the ESP8266 module normally sends as response. This command is not really supposed to do something, but just to have a simple way to detect if a serial communication with the module exists or not.

boolean checkWiFi() {
  if( esp.at() == ESP8266::Error::NONE) return true; 
  return false;
};

The sendDataToServer method is responsible with four operations:

creates the HTTP request, by using a template, discussed later in this tutorial;
opens a TCP connection on port 80, with the specified server (see the DATA_SERVER_ADDRESS constant);
sends a GET request to the data server;
finally, closes the TCP connection.

void sendDataToServer(float temperature, float humidity) {
  char data[64] = {0};
  char *pData = data;
  createDataFromTemplate(pData, temperature, humidity);
  esp.atCipstartTcp(DATA_SERVER_ADDRESS, 80);
  esp.atCipsendHttpGet(DATA_SERVER_PATH, data);
  esp.atCipclose();
};

An example of a HTTP GET request that we like to submit looks as follows:

GET /update?api_key=22.7&field1=%s&field2=35.5 HTTP/1.0

We see that some static parts are used (the HTTP method name, the request path /update and the HTTP version specification), but also some parts that are changing, such as the values of field1 and field2 parameters, corresponding to temperature and humidity values. We'll turn the parameter part of the request into a template, where the dynamic values are replaced at the request time with specific temperature and humidity quantities. For this, we define a template char pointer (you can thing on it like being a string).

const char DATA_TEMPLATE[] PROGMEM = "?api_key=%s&field1=%s&field2=%s";

Some magic happens here, because of the keyword PROGMEM. That is not really related to the template, but to the way on which the "template string" is stored by the Arduino MCU. Normally, all strings are stored in the RAM, thus keeping the RAM occupied with data that is only rarely used. The PROGMEM variable modifier informs the compiler that we like to store this value in FLASH (remember, we have FLASH sizes with an order of magnitude greater than RAM!). The problem is now, that we can't just simply read the variable and expect to have the value there, because what it really stores is the start address of the FLASH memory where the data was stored. For this reason, we created the getPMData (get program memory data) method to extract the real data from FLASH. Notice that this method comes with the ESP8266 library and is used intensively to deal with the static strings involved by the communication with the ESP8266 module. This method takes three parameters: 1) the defined PROGMEM variable; 2) a char pointer with sufficient allocated memory to store the data you need to read; and 3) a reference to an uint8_t variable that will be set to a value representing the length of the data that was read from FLASH.

In the createDataFromTemplate method, we take care to replace the parameters, represented by %s (denoting a string parameter), into real values.

void createDataFromTemplate( char *&data, float temperature, float humidity) {
  char buffTemp[6] = {0}, buffHum[5] = {0}, tmpl[32] = {0};
  char *pTmpl = tmpl;
  uint8_t templateLen = -1;
  // read template from PROGMEM
  getPMData( DATA_TEMPLATE, pTmpl, templateLen);
  // create data string from template by replacing
  // parameters with their actual values from sensors
  sprintf( data, pTmpl, DATA_SERVER_API_KEY,
    dtostrf( temperature, 0, 1, buffTemp),
    dtostrf( humidity, 0, 1, buffHum));
};

Using the getPMData method we read the template from FLASH. Further, using sprintf we replace the specified parameters (i.e., which starts with the % symbol) with concrete values. The dtostrf method allows to transform the float values that we have for temperature and humidity into strings, used then to fill the template variables. Notice, that sprintf is able to deal directly with numeric variables, but unfortunately its version available for the Arduino sketches lacks this functionality, thus we also need to use dtostrf.

Replace the constant values (i.e., WIFI_SSID, WIFI_PASSWORD, DATA_SERVER_API_KEY and so on) with your own values, then write the sketch into your Arduino. If all went fine, you should now check your account and access the "Private View" tab of your thingspeak.com account. In our case, for a small set of values, we obtain the charts shown in Figure 18. Remember, that we only set data once every 15 seconds, meaning that it can take a while until you'll see something on your thingspeak.com chart.

Figure 18: Temperature and Humidity Value Charts at thingspeak.com.

Some Points of Attention

It is important to use a good quality power supply, both for your Arduino board (if not powered via USB) and the ESP8266 module. A low quality power supply may have unknown effects, and may produce behaviors like unwanted resets of the devices. If your ESP8266 module seems to be unstable, i.e., often resets by itself, then it is very likely that you have an issue with the 3.3V rail provided to the module. You can try to add a 1000µF electrolytic capacitor in parallel with an 0.1µF ceramic capacitor to the 3.3V rail. If this does not improve the module behavior, then try to replace your power supply. If an oscilloscope is available, you can observe the behavior of the 3.3V rail.

When using the ESP8266 module with a device that runs the UART communication on 5V rail (e.g., Arduino UNO and most of the other Arduino boards), then you need to use a voltage LC (level converter) between the RX and TX lines of the ESP8266 modules and the TX and RX lines of the paired device. Also, remember, the RX and TX lines are twisted between the two devices implied in the UART communication.

While the ESP8266 is a really nice and cheap module, the current version is not rock solid in terms of stability, thus you may observe strange behaviors sometimes. It may help to reset the software configuration to its default state, by using the "AT+RESTORE" command. After that, you should configure the module again, with respect to all parameters you've been set before the reset (e.g., WiFi connection, client or AP mode, etc). If your module still misbehaves, then a better power supply may help. Also, be sure that you didn't wrote a firmware with a version over 1.1.0 on a module that only has 4Mbit (or less) flash size, because you may completely brick your module.

Sometimes, TCP or UDP connections made via this module are not stable or you may even get connection refused errors. In this case, you should try a few more times to be sure that it is really a problem, since in multiple cases this is just a temporarily problem and can be solved by retrying, resetting or power cycling the module.

Periodically check the temperature of your ESP8266 module, simply by putting your finger on the CPU IC. If it feels hot when touched, then something may be wrong. Usually a hot CPU on the ESP8266 module means that the module receives more than the 3.3V required on the power line or on the RX and/or TX lines. Check the voltage, and make sure that this is not the case. If this is not the case, the high temperature may be due to high WiFi activity. While this is not unusual for these modules, make sure that the module is on a place with environment temperature under 30°C to avoid overheating and damaging the CPU.

When using the module in AP (access point) or STA+AP (station and access point) modes (that is, AT+CWMODE=2 or AT+CWMODE=3), make sure that you set a good password, otherwise you may have "spy eyes" on your network and may even result in security breach of your entire enterprise network! To check if you are in either AP or STA+AP mode, run the "AT+CWMODE?" command and check which value it returns (+CWMODE:1 means STA mode, +CWMODE:2 means AP mode and +CWMODE:3 means STA+AP mode).

Next Tutorial: Part 4 - Control the Environment by Using Actuators

In this tutorial we'll learn how to use Arduino to produce environment changes. Specifically, we'll use relays to turn ON/OF lights, miniature water pumps to ensure the correct soil moisture for our beloved room plants and a DIY PWM actuator to adjust the intensity of a dimmable LED strip, used to produce ambient light on a room.

The release date of the 4th part is: before 24 May 2016.

web-engineering.info - Arduino

Seeeduino XIAO - A Tiny Arduino Zero Variation

Another Arduino Compatible Board?

Technical Description and Features

Benchmark Test

The Power Consumption

Get Started with the XIAO board and the Arduino IDE

Some Final toughts

What's next?

Category:

PRODINo: Home Automation with ESP8266 based WiFi Control

What is PRODINo WiFi-ESP?

Hardware Specifications

Programming the PRODINo

Use Arduino IDE to Program a PRODINo Module

Controlling the Relays

Reading the Inputs

More Examples for PRODINo

Conclusions

Project Ideas

Category:

WoT with Arduino for Beginners: Part 3 - Connecting to the Internet via WiFi

Arduino + ESP8266 = "I'm online, Mum!"

Choosing an ESP8266 Module Version

Update the ESP8266 Firmware

Use Arduino and HTTP(S) to Access Online Services via an WiFi Network

Hardware Configuration

SoftwareConfiguration

Some Points of Attention

Next Tutorial: Part 4 - Control the Environment by Using Actuators

Category: