Our sensor node is powered by a regulated [email protected] power brick. The Arduino Pro Mini board and most of components can directly use the 5V rail comming from the power brick. The regulation down to 3.3V, required by the ESP8266 WiFi module, is obtained by using the LM317T IC, an adjustable step-down linear voltage regulator. It only requires a few additional components: two resistors and two capacitors. It is able to provide up to 1.5A current, with appropriate cooling. However, for our example cooling is not needed, the average current being under 250mA (going up to 500mA but only for very short amounts of time, when the ESP8266 module transmits data). Figure 3 shows the 3.3V power supply built on a breadboard, and Figure 4 shows the corresponding electronics schematic..

The values of the R1 and R2 resistors are chosen according with the following rules:

• the value of R1 must be in the range 100 - 1000Ω, as specified in the LM317 IC datasheet;
• both, R1 and R2 are standard resistor values, so easily available in any electronics shop;
• the equation, provided by the LM317 IC datasheet, Vout = 1.25 ( 1 + R2 / R1) is verified, when Vout ~= 3.3.

The real output voltage, for R1 = 330Ω and R2 = 560Ω is Vout ~= 3.37V, so the maximum ±5% error is within specifications. C1 is a ceramic capacitor with a value of 0.1µF ( 100nF), being used to filter high frequency spikes and to prevent internal oscillation for the LM317T IC. C2 is an electrolytic capacitor with a value of 1µF (higher values, up to about 1000µF can be used), and its purpose is to smooth the output voltage (3.3V line). The designed voltage of C2 must be higher than 3.3V, and it is very important to mount the capacitor with the correct polarity. Electrolytic capacitors are very prone to small explosions if missused, such as mounting them in reverse polarity or use them with voltages over their specification.

Note: instead of the fixed value R2 resistor, a 1KΩ potentiometer can be used. In this case, a more precise output voltage is obtained if (and when) really needed. This way you can also use a lower value for R1, and a good choice is 240Ω, as recommended in the LM317 datasheet.

Arduino Pro Mini board is powered by a 5V power supply, so it allows to use 5V on the UART RX and TX communication lines. ESP8266 Wifi module on the other hand uses 3.3V power supply, and it is not 5V tolerant for the VCC, RX, TX or any of its other available I/O lines. Therefore a direct connection between the RX/TX lines of the Arduino board and the RX/TX lines of the ESP8266 module is not possible, and ignoring this warning may very likely result in damaging the ESP8266 module. A simple solution for this case is to use a readily available logic converter module. Its provides 3.3V lines (some also allows 1.8V, 2.5V and 2.8V) as well as 5V communication lines. Notice that such a module can provide very low current (in the range of a few mA) on each of the lines, therefore it must be used only for data communication and not as a voltage regulator. We use a four channel module, so it provides four low voltage (3.3V) lines with four corresponding high voltage (5V) lines. Two lines are used for UART communication and the other two are used for connecting the CH_PD and RESET lines of the ESP8266 module with the pin 2 and respectively 3 of the Arduino board.

It is important to notice that the RX/TX line of the Arduino Pro Mini board have to be cross-connected with the RX/TX lines of the ESP8266 module. This means: the RX line of the Arduino board connects to the TX line of the ESP8266 module and the TX line of the Arduino board connects to the RX line of the ESP8266 module. These connection is made via the logic level converter module as already explained above and also shown in Figure 1 and Figure 2.

The CH_PD (channel power down) and RESET pins of the ESP8266 module needs to be connected to VCC (+3.3V) line via 3.3KΩ resistors. Normally, a 10KΩ resistor can be used, but we observed periodical resets of our WiFi module (we tested a few of them). Using test and trial method, we found that the 3.3KΩ resistor works the best for all our ESP8266 modules.

Note: the ESP8266-01 module is shown in the schematic, since this was available as Fritzing component, but actually in the real board we use an ESP8266-02 module. This should make no difference, and in general we should be able to use any version of these modules. There are about thirteen versions of ESP8266 modules, which differes in form, size and available I/O, but all have the same WiFi functionality.

The DHT22 sensor allows to obtain temperature readings in the range [-40, 80]°C with a typical accuracy of ±0.5°C and a resolutin of 0.1 units (°C). However, in real tests, the accuracy we could observe is closer to ±1°C. The sensor can also read humidity values in the range [0, 100]%, with a typical accuracy of ±2 units (%) and a resolution of 0.1 units. In our real tests, the accuracy was about ±5%.

The DHT22 sensor can be connected to either 3.3V line or to 5V line, and we decided to use the 5V line. The data pin of the sensor (check the datasheet for more details) is connected to 5V rail via one 10KΩ resistor, to avoid communication errors (this line must stay HIGH when the sensor does not communicate via the data pin). The sensor data pin is connected to digital pin 9 of the Arduino board.

During the tests, we found that it is good to know the actual state of the ESP8266 module, specially because the module becomes unresponsive sometimes. We have used a DUO red/green LED, which is actually composed of one green and one red LEDs in a single physical package, and which share a common cathode (GND) connection. The green LED anode was connected to pin 8 of the Arduino Pro Mini board via a 560Ω resistor, thus allowing about 5mA current passing through the LED. The red LED anode was connected to pin 7 of the Arduino Pro Mini board via a 560Ω resistor, thus allowing about 6mA current passing through the LED.

A LED should never be directly connected between the VCC and GND lines (or directly to I/O pins of an MCU) with the exception of special LEDs which are designed for this, on which case they have a builtin resistor or use other current limiting design. Instead one must use a series resistor to limit the current passing through the LED. Using Ohm's Law we can compute the value of the resistor by knowing the LED forward voltage (the voltage to which the LED starts conducting and emmiting light), the used supply voltage and the current we want to allow passing through the LED (which controls the LED brightness). A standard red LED has about 1.7V forward voltage, a green or orange LED has about 2V forward voltage, a white or blue led has about 2.7V forward voltage. Since we only need the LEDs to provide visual indication, they don't have to lighting very bright. After testing our DUO LED, we decided that a value of 6mA is desired for the red LED and a value of 5mA for the green LED (green light is more visible for human eye than other colors). Applying Ohm's Law, we have V = IR, so R = V / I. For our case, V is the difference between the power supply voltage (+5V) and the LED forward voltage. Solving the equation for the red LED we have R = (5 - 1.7) / 0.006, which give us R = 550Ω. Since 550Ω is not a standard value, the next available standard resistor value can be used, that being 560Ω. As homework, you can do the computations for the green LED.

Note: if you don't have a DUO LED, just use two normal LEDs. Also, you can use other LED colors if you like, and even different resistor values to obtain different brightness levels (use Ohm's Law to find the appropriate resistor value). A standard 3mm or 5mm LED usually stands up to 20mA of current, after this point it gets too warm and it is very likely that it gets burned. However some LEDs can stand much more current, but they need special drivers. Also, notice that you should not draw more than 20mA from each of the Arduino pins, or you may damage the board.

The Arduino code can be written, compiled and deployed to the Arduino board by either using Fritzing or the Arduino IDE (this may be preferred in some cases, because it usually works out of the box). For our project, the following Arduino libraries are needed:

• Arduino-ESP8266, used for the UART communication between the ESP8266 module and the Arduino board. Clone the library repository, rename the folder to ESP8266 and copy it to libraries subfolder, part of the Arduino Software installation folder.
• DHTLib, used for the communication with the DHT22 sensor. This library supports DHT11 sensors as well, in case you use it as a replacement for DHT22. Clone the library repository, rename it to DHT and copy it to libraries subfolder, part of the Arduino Software installation folder.

An Arduino program (also known as sketch) has the following minimal structure:

// 1. constants definition (optional if no constant is needed)
// 2. include headers for used libraries ( optional if no library is used)
// 3. define the global variables (optional if no global variable is required)

// program initialization
void setup() { 
  // write here the setup code.
}

// infinite loop cycle
void loop() { 
  // the code from this method loops as long as the Arduino board is powered.
}              

In the setup method we write initialization code, which is executed only once, when the Arduino is powered or after a software or hardware reset. The loop method contains the code which loops in the Arduino MCU as long as the board receives power.

// Arduino pin number used for the communication with DHT22 sensor.
#define DHT22_PIN 9
// pins number for WiFi disabled LED
#define WIFI_DISABLED_LED_PIN 7
// pins number for WiFi enabled/active LED
#define WIFI_ACTIVE_LED_PIN 8
// arduino pin used to connect to the CH_PD (Power Down) WiFi module pin
#define WIFI_CH_PD_PIN 2
// arduino pin used to connect to the RESET WiFi module pin
#define WIFI_RESET_PIN 3

#include <dht.h>
#include <ESP8266.h>                        

// DHT22 sensor controller class
dht DHT;

// ESP8266 WiFi module controller
ESP8266 esp( Serial);

// store the average temperature and humidity 
// values, starting with last system reset
float avgTemperature = 0;
float avgHumidity = 0;

// utility variable used to compute the averate temperature value
unsigned long avgDhtStep = 1;

// data template for sensors
const char SENSORS_DATA_TEMPLATE[] PROGMEM = 
    "{\"temperature\": %s, \"avgTemperature\": %s, \"humidity\": %s, \"avgHumidity\": %s, \"voltage\": %s, \"freeRam\": %d}";

void setupWiFi() {
  // STEP 1:
  // Set pins used for WiFi status LEDs as OUTPUT.
  pinMode( WIFI_ACTIVE_LED_PIN, OUTPUT);
  pinMode( WIFI_DISABLED_LED_PIN, OUTPUT);

  // STEP 2:
  // Arduino pin connected to ESP8266 CH_PD pin is set to OUTPUT.
  // To keep the module active, this pin must be kept HIGH.
  pinMode( WIFI_CH_PD_PIN, OUTPUT);
  digitalWrite( WIFI_CH_PD_PIN, HIGH);
  // Arduino pin connected to ESP8266 RESET pin is set to OUTPUT.
  // To avoid random resents, we keep this HIGH.
  pinMode( WIFI_RESET_PIN, OUTPUT);
  digitalWrite( WIFI_RESET_PIN, HIGH);

  // STEP 3:
  // perform a hardware reset (ESP8266 RESET pin goes LOW)
  digitalWrite( WIFI_RESET_PIN, LOW);
  delay( 200);
  // allow ESP8266 module to boot
  digitalWrite( WIFI_RESET_PIN, HIGH);

  // STEP 4:
  // baud 115200, communication with ESP8266 module
  Serial.begin( 115200);

  // STEP 5:
  // wait for the ESP8266 module to start, after the forced hardware reset.
  // We check the wifi state once a second, until the ESP8266 WiFi module responds.
  while( !checkWiFi()) {
    delay( 1000);
  };

  // STEP 6:
  // start UDP connection - wait on all ports
  esp.atCipstartUdp();
} 

boolean checkWiFi() {
  if( esp.at() == ESP8266::Error::NONE) {
    digitalWrite( WIFI_DISABLED_LED_PIN, LOW);
    digitalWrite( WIFI_ACTIVE_LED_PIN, HIGH);
    return true;
  } else { 
    digitalWrite( WIFI_ACTIVE_LED_PIN, LOW);
    digitalWrite( WIFI_DISABLED_LED_PIN, HIGH);
    return false;
  }
}

void setup() {
  // setup WiFi - ESP8266 module
  setupWiFi();
  // add other code here...
}

void updateDHTData() {
  if ( dht22.read22( DHT22_PIN) == DHTLIB_OK) {
    avgTemperature = ( avgTemperature * (avgDhtStep - 1) + dht22.temperature) / (float)avgDhtStep;
    avgHumidity = ( avgHumidity * (avgDhtStep - 1) + dht22.humidity) / (float)avgDhtStep;
  }
}

float getVcc() {
  long result;
  // read 1.1V reference against AVcc
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  // wait for Vref to settle
  delay(2); 
  // convert
  ADCSRA |= _BV(ADSC); 
  while (bit_is_set(ADCSRA,ADSC));
  result = ADCL;
  result |= ADCH<<8;
  // Back-calculate AVcc in mV
  result = 1103700L / result; 
  // return response in volts
  return result / 1000.0;
}

void loop() {
  char data[10] = {0}, *ipdData = data;
  // Incomming data from ESP8266 module
  // Lengt must be greater than 7 bytes ("+IPD,n:")
  if ( Serial.available() > 7 && esp.ipd( ipdData) == ESP8266::Error::NONE) {
    // process the request
    processRequest( ipdData);
  }
  // a small delay before checking againd for WiFi incomming data
  delay( 25);
}

enum class Command {
  GET_ALL_SENSORS_DATA = 97
};

void processRequest( char *data) {
  char progmemData[150] = {0};
  char *pData = progmemData;
  // first char represents the command
  char cmd = *(data); 
  switch ( (Command)cmd) {
    case Command::GET_ALL_SENSORS_DATA:
      createSensorsDataFromTemplate( pData);
      esp.atCipsend( pData);
    break;
    default:
      // nothing to do ...
    break;
  }
}

Its main purpose is to decode the received command and to respond with the required data. As discussed earlier, we only have one command, so also only one action case, but this will be extended, so we use the general structure even for this simplest case. The relevant code regards the call to createSensorsDataFromTemplate method. It uses the JSON based data template, replaces the placeholders with real data and send the response to the Android device by calling atCipsend method, part of the ESP8266 library.

void createSensorsDataFromTemplate( char *&data) {
  char buffTemp[7] = {0}, buffAvgTemp[7] = {0}, buffAvgHum[7] = {0},
    buffHum[7] = {0}, buffVcc[5] = {0}, tmpl[140] = {0};
  char *pTmpl = tmpl;
  uint8_t templateLen = -1;
  // read template from PROGMEM
  getPMData( SENSORS_DATA_TEMPLATE, pTmpl, templateLen);
  // create data string from template by replacing
  // parameters with their actual values from sensors
  sprintf( data, pTmpl, 
    dtostrf( dht22.temperature, 6, 1, buffTemp),
    dtostrf( avgTemperature, 6, 1, buffAvgTemp),
    dtostrf( dht22.humidity, 6, 1, buffHum), 
    dtostrf( avgHumidity, 6, 1, buffAvgHum),
    dtostrf( getVcc(), 4, 2, buffVcc),
    getFreeMCUMemory());
}

Using the getPMData utility method (also part of the ESP8266 library), the data template string is read from the flash memory. Replacing the parameters with real values is made by using the standard sprintf method. While for a fully fledged C/C++ environment one will use %x.yf syntax with sprintf for floating points numbers, this will not work with Arduino code. Instead we use dtostrf to format the temperature and humidity values (we like values with just one digit after the decimal point).

An Android application is used to observe the Weather Station sensor node data. For the development of our Android application, IntelliJ IDEA Ultimate was used. A free community version of this IDE is also available and can be used for our project. As an alternative, one cau use Android Studion.

The first thing you need to do after creating an empty Android application by using your preferred IDE, is to edit the application security settings. These can be found in the AndroidManifest.xml file Since we need to use WiFi communication, the following two parameters need to be added:

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.INTERNET"/>

In addition, we like to disable the auto-lock feature of the Android device, as long as this application is active, which requires to set the following permission:

<uses-permission android:name="android.permission.WAKE_LOCK" />

The same AndroidManifest.xml file defines the Android OS version required to run this application. We have tested this application with Android 4.3.1 (API 18) and 4.4.2 (API 19) and 5.0.1 (API 21). Therefore it is safe to set the miminum require version to API 18 by using the following parameter:

<uses-sdk android:minSdkVersion="18" android:targetSdkVersion="21"/>

While this application may run on Android OS older than 4.3.1 (API 18), our tests with Android 2.3.3 (API 10) failed.

Creating the Android application user interface can be done by using the UI editor, or, if you are already familiar with Android, directly editing the layout file. In our case this file is named main.xml and it is located under res/layout folder.

We use a ScrollView container as the user interface parent, to support also small screen devices, with lower physical resolutions. As layout template, we use TableLayout, with two columns: label and value plus measurement unit.

<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"
            android:fillViewport="true">
  <TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
               android:layout_width="fill_parent"
               android:layout_height="fill_parent"
               android:id="@+id/main">
    <TableRow android:layout_width="fill_parent"
              android:layout_height="wrap_content">
      <!-- table row content -->
    </TableRow>
    <!-- more table rows... -->
  </TableLayout>
</ScrollView>

For example, the row used to show the current temperature value is shown below:

<TableRow android:layout_width="fill_parent"
          android:layout_height="wrap_content">
  <TextView android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textAppearance="?android:attr/textAppearanceMedium"
            android:text="  Temperature:   "
            android:id="@+id/temperatureLabel"/>
  <TextView android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textAppearance="?android:attr/textAppearanceMedium"
            android:text="N/A°C"
            android:id="@+id/temperatureValueTextView"/>
</TableRow>

Each UI element has an android:id attribute, with an unique value, used to access the UI element from the Android Java code. The result user interface is shown in Figure 5.

We use an Android activity to implement our class. This is the simplest way to create an Android application, specially this is your first Android application.

public class MainActivity extends Activity {
  // ...here come all the properties and methods...
}

For the UDP communication with the Weather Station sensor node we use Java DatagramSocket, and initialize it for port 1024 (other ports, starting with 1025, can be used as well). This code should execute before trying to send any UDP packet over the network. In this scenario, we request sensor data from the Weather Station node, once every 10 seconds. Feel free to modify it to another value if you like:

public class MainActivity extends Activity {
  int udpPort = 1025;
  DatagramSocket socket;
  
  // other properties....  
  
  @Override
  public void onCreate( Bundle savedInstanceState) {
    // here are some other initializations
    (new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          socket = new DatagramSocket(udpPort);
          while (true) {
            if (appInBackground) continue;
            try {
              sendUdpData( Commands.GET_ALL_SENSORS_DATA, null);
              Thread.sleep( 10000);
            } catch (Exception e) {
              e.printStackTrace();
            }
          }
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    })).start();
  }
}