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.
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.
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:
#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
void setup()
{
Serial.begin(115200);
Screen.init();
initSensors();
initWiFi();
}
Initializing the sensors we need to communicate with them through the Serial Peripheral Interface(DevI2C)
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.
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()
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
float readTemperature()
{
ht_sensor->reset();
float temperature = 0;
ht_sensor->getTemperature(&temperature);
return temperature;
}
Reading the humidity
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)
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)
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
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;
}
Top comments (0)