Building a simple client/server IOT application
Tags: node, arduino, cpp, typescript
Published: 2019-07-30 22:28:21

---
title: Building a simple client/server IOT application
published: true
description: playing with boards and IOT
tags: NodeJS, Arduino, Cplusplus, typescript
---

A while ago I run into an MXChip. The MXChip is similar to an arduino, but with a lots of sensors pre build on it and designed specifically for the cloud.

Its components include Wifi, OLED display, headphone, microphone, and it also has the following sensors, temperature, humidity, motion and pressure.

So I got one and took it for a test drive. The first application I build was a simple http client/server.

Basically the MXChip will acts as a client sending sensor readings in a regular interval to the the server (API written in NodeJS).

To keep things simple I'll be using SQLite. Everything will be stored in a single table with the following schema.

```SQL
create table TimeSeries
(
	id integer
	constraint TimeSeries_pk
	primary key autoincrement,
	temperature numeric,
	humidity numeric,
	date text,
	location text,
	timestamp numeric
);

```

The NodeJS API is nothing more than a single endpoint supporting OPTIONS, POST and GET

* POST: adds a record to the db
* GET: retrieves records between two timestamps

On tutorials I tend use as less dependencies as possible. This one only depends on sqlite3.

```typescript
import * as http from 'http';
import * as sqlite3 from 'sqlite3';
import * as url from 'url';

const URLSearchParams = url.URLSearchParams;
const hostname = '0.0.0.0';
const sqlite = sqlite3.verbose();
const port = 3000;
var db = new sqlite.Database('./timedb.sqlite');

http.createServer((req: any, res: any) => {
    res.setHeader('Access-Control-Allow-Methods', 'OPTIONS, GET, POST');
    if (req.method === 'OPTIONS') {
        res.writeHead(200);
        res.end();
        return;
    }
    if (req.method === 'POST') {
        let body = '';
        req.on('data', (chunk: any) => {
            body += chunk.toString();
        });
        req.on('end', () => {
            try {
                db.serialize(() => {
                    const data = JSON.parse(body);
                    db.run("INSERT INTO TimeSeries (temperature, humidity, date, location, timestamp) VALUES (?, ? ,?, ?, ?)", [
                        data.temperature,
                        data.humidity,
                        new Date().toUTCString(),
                        data.location,
                        Date.now() / 1000 | 0
                    ]);
                });
            } catch (error) {
                console.log(error);
            }
            console.log(new Date().toUTCString());
            console.log(body);
            res.end('ok');
        });
    } else if (req.method === 'GET') {
        const search_params = new URLSearchParams(req.url.split('?')[1]);
        let from: any = search_params.get('from');
        let to: any = search_params.get('to');
        const now: Date = new Date as unknown as Date;
        if (to === null) {
            to = (now as unknown as number) / 1000 | 0;
        }
        if (from === null) {
            from = now.setHours(now.getHours() - 24) / 1000 | 0;
        }
        try {
            db.serialize(() => {
                db.all("SELECT * FROM TimeSeries WHERE timestamp > ? AND timestamp < ?", [from, to], (err, rows) => {
                    res.end(JSON.stringify(rows));
                });
            });
        } catch (error) {
            console.log(error);
        }
    }
}).listen(port, hostname, () => {
    console.log("server start at port 3000");
});
```

When it comes to arduino you could write an application in any language you prefer as far as it can be compiled for the platform. My language of choice is C++.

For those that are not familiar with arduino development a basic file structure has the following functions

* setup : everything that has with initialization and setting initial values, goes here
* loop  : a function that runs consecutively and continuously and allow the program to adapt and respond.


Our `include` and `global variables` are:


```c++
#include "AZ3166WiFi.h"
#include "Arduino.h"
#include "http_client.h"
#include "Sensor.h"
#include "SystemTickCounter.h"
#include "RGB_LED.h"

static char buffInfo[128]; // buffer for the screen
static RGB_LED rgbLed;  // our led 
static volatile uint64_t msReadEnvData = 0; // stores current tick of executed loop
#define READ_ENV_INTERVAL 120000 // how often loop will run properly
static HTS221Sensor *ht_sensor; // sensors
static DevI2C *ext_i2c; // SPI
static bool hasWifi = false; // wifi on/off
static bool begin = false; // avoid race condition
```


Our `setup()` will initialize the following

* serial
* screen
* temperature and humidity sensors
* wifi

```c++
void setup()
{
    Serial.begin(115200);
    Screen.init();
    initSensors();
    initWiFi();
}
```

Initializing the sensors we need to communicate with them through the Serial Peripheral Interface(DevI2C)

```c++
void initSensors()
{
    ext_i2c = new DevI2C(D14, D15);

    if (ext_i2c == NULL)
    {
        Screen.print(0, "Error \r\n ext_i2c");
    }

    // temperature and humidity
    ht_sensor = new HTS221Sensor(*ext_i2c);
    if (ht_sensor == NULL)
    {
        Screen.print(0, "Error \r\n ht_sensor");
    }

    ht_sensor->init(NULL);
    ht_sensor->reset();
}
```

And then we need to connect to wifi. Setting up the wifi, is really easy on the MXChip as it stores persistently the SSID and password on first setup of the device. So the code we need is minimal.

```c++
void initWiFi()
{
    if (WiFi.begin() == WL_CONNECTED)
    {
        IPAddress ip = WiFi.localIP();
        Screen.print(1, ip.get_address());
        hasWifi = true;
    }
    else
    {
        Screen.print(1, "No Wi-Fi");
    }
}
```

Then we move to our main function the `loop()`

```c++
void loop()
{
    if (hasWifi)
    {
        // get current tick
        uint64_t ms = SystemTickCounterRead() - msReadEnvData;
        if (!begin)
        {
            if (ms < READ_ENV_INTERVAL)
            {
                return;
            }
        }
        begin = true;

        // get readings
        float temperature = readTemperature();
        float humidity = readHumidity();

        // display the values, because its cool
        displayLines("Leicester", "Temp:" + String(temperature), "Hum: " + String(humidity));

        // update the tick to track loop full execution 
        msReadEnvData = SystemTickCounterRead();	
        
        // switch on rgb led while posting data (visual feedback)
        rgbLed.setColor(185, 24, 23);

        // POST sensor data
        sendData(temperature, humidity);

        // turn off rgb led
        rgbLed.turnOff();
    }
}
```

Reading the temperature

```c++
float readTemperature()
{
    ht_sensor->reset();

    float temperature = 0;
    ht_sensor->getTemperature(&temperature);

    return temperature;
}
```
Reading the humidity

```c++
float readHumidity()
{
    ht_sensor->reset();

    float humidity = 0;
    ht_sensor->getHumidity(&humidity);

    return humidity;
}
```

A handy helper function to print to the all screen lines at once (MXChip has 3)

```c++
void displayLines(String line1, String line2, String line3)
{
    char screenBuff[128];
    line1.toCharArray(screenBuff, 128);
    Screen.print(0, screenBuff);

    line2.toCharArray(screenBuff, 128);
    Screen.print(1, screenBuff);

    line3.toCharArray(screenBuff, 128);
    Screen.print(2, screenBuff);
}
```

And finally we need to POST our data to the API (as JSON)

```c++
void sendData(float temp, float humidity)
{
    httpRequest(HTTP_POST, "http://192.168.1.128:3000/", "{\"location\":\"Earth\",\"humidity\":\"" + String(humidity) + "\",\"temperature\":\"" + String(temp) + "\"}");
}
```

Http_Request/Http_Response function

```c++
const Http_Response *httpRequest(http_method method, String url, String body)
{
    Screen.print(3, "Sending Data");

    char urlBuf[48];
    url.toCharArray(urlBuf, 48);

    HTTPClient *httpClient = new HTTPClient(method, urlBuf);
    httpClient->set_header("Content-Type", "application/json"); // required for posting data in the body

    char bodyBuf[256];
    body.toCharArray(bodyBuf, 256);
    const Http_Response *result = httpClient->send(bodyBuf, strlen(bodyBuf));

    if (result == NULL)
    {
        Screen.print(1, "Failed");
        char errorBuf[10];
        String(httpClient->get_error()).toCharArray(errorBuf, 10);
        Screen.print(1, errorBuf);
        return result;
    }

    Screen.print(3, "Success");

    String(result->body).toCharArray(buffInfo, 128);
    Screen.print(3, buffInfo);

    Serial.print(result->status_code);
    Serial.print(result->status_message);

    delete httpClient;

    return result;
}
```