DEV Community: Austin Spivey

How to build your own security system using Android Things

Austin Spivey — Wed, 15 Aug 2018 18:06:46 +0000

In this tutorial, we will send an event to Wia using Android Things.

Components

Raspberry Pi (We used a Raspberry Pi 3 Model B)
PIR Sensor
USB Cable
Jumper wires

You will also need Android Studio and a Wia account. You can download the latest version of Android Studio here.

Wia is a cloud platform to support your Internet of Things devices. You can sign up or login here.

Getting Started

First, we need to install Android Things onto the raspberry pi. Click here to go to the Android Things console, and sign in using a google account.

Create a product and choose Raspberry Pi as the SOM, name it what you like, and save.

You will be taken to this page. Click on your model:

Click on NEW and choose Start from scratch from the drop down menu.

Name your build. Keep all of the default settings by clicking Next on each step. Then click create build.

Your build is now available for download. Download the file and choose production.

Once the file has downloaded, unzip it. The file will take a moment to expand. You will get a .img file.

Burning the SD Card

Next, burn the image to the SD card. We used Etcher to do this. You can download Etcher here.

Insert the SD card into your computer and open Etcher. Select the image we just downloaded and select the SD card, then click Flash. Then, remove the SD card from your computer and insert it into the raspberry pi.

Connect the raspberry pi to an ethernet cable and use a USB to connect the raspberry pi to a 5V power source. Use an HDMI to connect the raspberry pi to a monitor and obtain the IP address. You will need the IP address later.

Wiring the Hardware

Use this diagram to help you connect the hardware:

Connect a USB to the raspberry pi and your computer. Connect the HDMI cable to a monitor and the raspberry pi.

Set up your space in Wia

If you don't already have a Wia account, you can sign up here, it's free.

In the Wia dashboard, click Create a New Space. In the left sidebar, navigate to Devices and click Add Device. We used the Raspberry Pi 3 Model B. Name your device anything you like.

Once your device is added, navigate to the Configuration tab. Here you will find your device's secret key, which starts with d_sk. You will need this key later.

Development

Open Android Studio and start a new project. Fill in the required fields:

Click next. For the target devices, select only Android Things

Click next. Choose Empty Activity

Click next and then Finish.

In the left sidebar, click Gradle Scripts > build.gradle (Module: app), and enter this line of code in dependencies:

implementation 'io.wia:wia-android-sdk:0.3.1'

Your screen should look like this:

Now, it's time to connect the raspberry pi to our project. You need to know the IP address of the raspberry pi for this step. In the terminal, run this command:

adb connect Your-Raspberry-Pi-IP-address)

Open Android Studio. Copy and paste this code into MainActivity.java:


import android.app.Activity;
import android.os.Bundle;

import android.util.Log;

import com.google.android.things.pio.Gpio;
import com.google.android.things.pio.PeripheralManager;


import io.reactivex.Observable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.schedulers.Schedulers;
import io.wia.Wia;

import io.wia.WiaEvent;


public class MainActivity extends Activity implements MotionsSensor.Listener {

    private static final String GPIO_PIN = "BCM18";
    private PirMotionSensor motionSensor;
    private static final String TAG = "TEST";
    private Gpio mGpio;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        PeripheralManager pms = PeripheralManager.getInstance();
        try {
            mGpio = pms.openGpio(GPIO_PIN);
            motionSensor = new PirMotionSensor(mGpio, this);
            motionSensor.startup();
        } catch (Exception ex) {
            Log.d(TAG, "failing", ex);
        }
        Log.d(TAG, "IN ON CREATE FUNCTION.");

        Wia.initialize(new Wia.Configuration.Builder(this.getApplicationContext())
                .server("https://api.wia.io/v1")
                .build()
        );
        //replace this with your own device secret key 
        Wia.accessToken("your-device-secret-key");

    }

    @Override
    public void onMovement() {
        Log.d(TAG, "in onMovement");
        Log.d(TAG, "MOVEMENT DETECTED");
        Observable<WiaEvent> result = Wia.createEvent("motion");
        result.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(response -> {
                    Log.d(TAG, "In onMovement function");
                }, error -> {
                    Log.d(TAG, "ERROR IN MOVEMENT EVENT");
                });
    }

In the code, locate this line, around line 45 in Android Studio:

//replace this with your own device secret key 
        Wia.accessToken("your-device-secret-key");

Change "your-device-secret-key" to your own device secret key. This can be found in the Wia Dashboard in your space > device > configurations. The key starts with d_sk.

In the left hand menu, navigate to App > Java and right click on the package name. Choose New > New Java Class and name it PirMotionSensor.

Then, copy and paste this code into the class PirMotionSensor :


import android.util.Log;

import com.google.android.things.pio.Gpio;
import com.google.android.things.pio.GpioCallback;

import java.io.IOException;

public class PirMotionSensor implements MotionsSensor {
    private final Gpio bus;
    private final MotionsSensor.Listener listener;

    PirMotionSensor(Gpio bus, Listener listener) {
        this.bus = bus;
        this.listener = listener;
    }

    @Override
    public void startup() {
        try {
            bus.setDirection(Gpio.DIRECTION_IN);
            bus.setActiveType(Gpio.ACTIVE_HIGH);
            bus.setEdgeTriggerType(Gpio.EDGE_FALLING);
        } catch (IOException e) {
            throw new IllegalStateException("Sensor can't start", e);
        }
        try {
            bus.registerGpioCallback(callback);
        } catch (IOException e) {
            throw new IllegalStateException("Sensor can't register callback", e);
        }
    }

    private final GpioCallback callback = new GpioCallback() {
        @Override
        public boolean onGpioEdge(Gpio gpio) {
            listener.onMovement();
            return true; // True to continue listening
        }
    };

    @Override
    public void shutdown() {
        bus.unregisterGpioCallback(callback);
        try {
            bus.close();
        } catch (IOException e) {
            Log.e("TEST", "Failed to shut down. You might get errors next time you try to start.", e);
        }
    }

}

In the lefthand menu, navigate again to App > Java and right click on the package name. Choose New > New Java Class. In the pop-up screen, change the field Kind to Interface instead of Class. Name the interface MotionsSensor.

Then, copy and paste this code into the interface:

public interface MotionsSensor {
    void startup();

    void shutdown();

    interface Listener {
        void onMovement();
    }
}

Click run and in the next screen choose Google_Iot_rpi3 as the device.

Go back to the Wia Dashboard. In the debugger tab, you can see your events appearing in real time! Each time motion is detected, and event is being sent to Wia.

To take this a step farther, you can use the Wia platform to send you a notification when motion is detected.

Wia Flows

In the left sidebar, navigate to Flows and add a new flow. Name it anything you like. From the Trigger tab, drag over a Create Event node. Name this node motion and select your device.

Next, in the Logic tab, drag over a run-function node. Copy and paste this code into the box:

if (input.body.name == "motion") { 
  output.body.data = "motion detected"; 
}
else {
  output.body.data = "no motion"; 
}

Connect the nodes by dragging the orange dots.

Then, in the Action tab, drag over a Notification node. Enter "Motion detected!" as the message. When motion is detected, this flow will send a notification to the Wia mobile app.

PIR Sensor Sensitivity Measures

The PIR Sensor allows you to change the Delay Time as well as the Sensitivty Level.

The PIR Sensor is a digital device. This means that it reads two values: HIGH and LOW. When the sensor detects movement, it reads HIGH. Otherwise, it reads LOW.

The Delay setting determines how long the PIR Sensor will read HIGH after it has detected a motion. The Sensitivity Sensor determines the proximity at which the PIR Sensor will register a movement. This sensor is more accurate when it is set to a lower proximity level. You can control these settings using the orange panels located directly across from the pins you used to wire your device.

How to connect a Sigfox Sens'It to Wia

Austin Spivey — Wed, 15 Aug 2018 17:07:28 +0000

In this tutorial, we will connect the Sigfox Sens'It to the Wia platform.

Components

Wia Account. You can create one here
Sigfox Sens'It
USB to Micro USB Cable

Connect the Sens'It to the Sigfox App

First, plug in your Sens 'It to ensure it stays charged. Then, follow this link to Sigfox's platform for the Sens 'It. In the upper right corner, click Launch App.

Choose to Activate a Sens'It. The Device ID is written on the back of the Sens'It. Enter the Device ID into the box.

Continue and add your location. Follow the prompts to finish activating the Sens'It.

Get the PAC

Once the Sens'It is activated, launch the app. In the left side menu, select the name of your device. Then, in the upper right corner, select Sens'It details

On the right bottom of the page, click the blue button for Get my PAC. The next display will show your PAC. You will need this later.

Connect the Sens'It to the Sigfox Backend

Follow this link to register your device so you can configure it in the Sigfox backend. Enter your location and click Next.

You will be prompted to enter your Device ID and PAC. The Device ID is the number on the back of the Sens'It. The PAC is the sequence we found in the last step.

Continue to the Account step and create an account. Finish and confirm.

Now, follow this link to the Sigfox backend. Enter your login details for the account you just created.

Send events to Wia

Wia has a Sigfox integration available, so you can connect your sigfox device to the Wia platform.

Create API Keys

In the Sigfox backend, go to Group > [Your group name] > API Access > New
Select DEVICES_MESSAGES [R]

Once checked, an API login and password will be created for you.

Add API Keys to Wia

Go to the Wia dashboard.
Open the Space dropdown, by clicking on the Space name in the top left corner, and click Settings. Select Integrations in the sidebar.

Enter your API Access Login and Password. Note: This is not the one you use to login to the Sigfox backend dashboard, it is the one you just created.
You should now see your Inbound Key for Sigfox created.

Setup your Sigfox Callback

Go back to the Sigfox backend
Select Device Type, then under name column of the device type list you would like to integrate
On the left, select Callbacks (If there are any Wia callbacks already there, remove them)
Click New in the top left corner to create a new callback
Select Custom Callback

Enter the values below in each of the fields:

Type: DATA UPLINK
Channel: URL
Url pattern: https://api.wia.io/v1/events
Use HTTP method: POST

Headers

Content Type: application/json
Body: Copy and paste the text below.

{
  "integrations":{
    "sigfox":{
      "id":"{device}"
    }
  },
  "name":"sigfoxDataUplink",
  "data":{
    "sigfoxData":"{data}",
    "time":"{time}",
    "duplicate":"{duplicate}",
    "snr":"{snr}",
    "station":"{station}",
    "avgSnr":"{avgSnr}",
    "lat":"{lat}",
    "lng":"{lng}",
    "rssi":"{rssi}",
    "seqNumber":"{seqNumber}"
  }
}

Click OK to save the callback.

Once your device sends an event it will automatically appear in the Wia dashboard.

Build a smart mailbox with a Sigfox and Pycom

Austin Spivey — Thu, 26 Jul 2018 14:50:09 +0000

Hi folks,

Today I’m going to show you how to create a Sigfox mail notifier using Wia and the Pycom SiPy.

This tutorial assumes that you have already connected Sigfox to Wia if you haven’t, please click here to find a tutorial for initial Sigfox setup and publishing data to Wia.

Components

Pycom SiPy
Pycom Expansion Board
Sigfox compatible antenna
Mobile device (iOS or Android)
HC-SR04 ultrasonic sensor

Setup your board

Connect the SiPy to the Expansion board. (The Pycom logos should face the same way)
Connect the Sigfox antenna to the SiPy. The connection is the small gold circle on the bottom left of the SiPy board. Simply snap the antenna in place. [upl-image-preview url=https://s3-eu-west-1.amazonaws.com/wia-flarum-bucket/2018-07-13/1531486321-146149-sipy-antenna.png]

For the HC-SR04 ultrasonic sensor, you'll need to connect the following pins to the Pycom SiPy:

HC-SR0 | Pycom
Vcc -> Vin
Trig -> G8
echo -> G7
Gnd -> GND

Setup Your Project

In Atom:

Create a new folder for your project. I'm going to call mine sigfox-mailbox
In Atom, go to File > New Window to open a new window
Add your newly created folder by clicking File > Add Project Folder and navigating to it
If the Pymakr plugin is not open at the bottom of your Atom window, click on the arrow on the right hand side to open it
Select Settings > Project Settings. In the address field replace the value with the device name from the step above e.g. /dev/tty.usbmodemPy343431 (Mac OS X), COM3 (Windows), /dev/ttyACM0 (Linux) then save the file

Publish a sigfox Event for our mail

We'll need three files for our application:

boot.py which is run when the device is powered up
main.py which is where our main code is
ultrasonic.py is where is our functions for obtaining distance and calibration

In Atom:

Right click on your project and click New File. Enter boot.py as the filename
Copy and paste the code below into the file

from machine import UART
import machine
import os

uart = UART(0, baudrate=115200)
os.dupterm(uart)

machine.main('main.py')

Right click on your project and click New File. Enter main.py as the filename
Copy and paste the code below into the file

import time
import pycom
import socket
from network import Sigfox
from machine import Pin, Timer
import ultrasonic


pycom.heartbeat(False)

echo = Pin(Pin.exp_board.G7, mode=Pin.IN)
trigger = Pin(Pin.exp_board.G8, mode=Pin.OUT)
trigger(0)

# Get the chronometer object
chrono = Timer.Chrono()

# init Sigfox for RCZ1 (Europe)
sigfox = Sigfox(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1)
# create a Sigfox socket
s = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)
# make the socket blocking
s.setblocking(True)
# configure it as uplink only
s.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, False)


calibrated_distance = ultrasonic.calibration(chrono, trigger, echo, 1)
mailed_distance = 0
while True:
    time.sleep(30)
    distance = ultrasonic.getDistance(chrono, trigger, echo)
    print("distance: {}, calibration: {}".format(distance, calibrated_distance))
    if distance < calibrated_distance:
        if distance != mailed_distance:
            s.send('') # Send 1 bit
            print("you got mail")
            mailed_distance = ultrasonic.calibration(chrono, trigger, echo)

Right click on your project and click New File. Enter ultrasonic.py as the filename
Copy and paste the code below into the file

from machine import Pin, Timer
import pycom
import time
import socket

def calibration(chrono, trigger, echo, led = False):
    if led:
        pycom.rgbled(0x7f0000) # red
    prev_distance = 0
    distance = getDistance(chrono, trigger, echo)
    print("calibration distance is {}".format(distance))
    count = 0
    while True:
        prev_distance = distance
        distance = getDistance(chrono, trigger, echo)
        while prev_distance == distance:
            count+=1
            print("count: {}".format(count))
            if count > 5:
                if led:
                    pycom.rgbled(0x007f00) # green
                    time.sleep(1.5)
                    pycom.rgbled(0) # off
                return distance
            time.sleep(5)
            prev_distance = distance
            distance = getDistance(chrono, trigger, echo)
        else:
            count = 0

def getDistance(chrono, trigger, echo):
    chrono.reset()
    trigger(1)
    time.sleep_us(10)
    trigger(0)

    while echo() == 0:
        pass
    chrono.start()

    while echo() == 1:
        pass
    chrono.stop()

    distance = chrono.read_us() / 58.0
    if distance > 400:
        return -1
    else:
        return int(distance)

    time.sleep(1)

Your folder structure should now look like this:

ultrasonic.py
boot.py
main.py

Click Upload in the Pymakr plugin at the bottom of your window in Atom and send the code to your Pycom board. Now go to the Wia dashboard and you should see data appearing in the debugger section of your dashboard.

In order for the sensor to operate correctly, it needs to calibrate the distance inside you mail box.

Calibration

To calibrate the sensor, place the sensor in the mailbox where its suits best. Power the board; when the LED on the board is red, the sensor is calibrating; once the LED flashes green, the sensor has been calibrated. The sensor needs at-least 2cm of space in order for it to operate correctly.

Now when mail is inserted into your mailbox, the distance will be reduced from the calibrated distance and the code will publish an Event via Sigfox to Wia.

Send a Push Notification

Now for the next step, once we recieve the Sigfox event in Wia, we will send a notification to any connected phones that there is mail. For this we need to build a Flow.

Head over to your Wia dashboard and in the Space where your Sigfox device is held. From there click on the Flow icon in the left hand menu to go your Flows.

Now to create your Flow, you can name it whatever you like. Once you have created a Flow, you should be taken to the Flow studio.

In the Flow studio:

Drag the trigger event node from the left hand side onto the canvas
Click on the node and enter sigfoxDataUplink as the event name
Enable your Sigfox Device as the event source

Now we are going add a notification for the Sigfox Event so we get notified of our inbound mail. To do this, you will require the Wia mobile app. You can download it for iOS here and Android here.

In the Flow Studio editor:

Drag over a notification node and enter the following text

You've got Mail!

Now you should receive Sigfox data to your mobile device.

Play Rock Paper Scissors Using the ESP8266

Austin Spivey — Wed, 04 Jul 2018 11:04:43 +0000

In this tutorial, we will build an online rock, paper, scissors game using ESP8266, the Wia Dashboard, and Github.

What You Will Need

2x ESP8266
2x Micro USB to USB cables

Before you begin, you must have a Wia account. You can create one here.

If you have not set up your ESP8266 with Arduino yet, you will need to do that first. This tutorial will show you how.

Getting Started

First, connect a USB cable to one of the ESP8266 and plug it into your computer or laptop.

Open the Arduino IDE. You can download the latest version here. In Arduino IDE, create a new sketch and save it as playerOne.ino. Create a second sketch and name it playerTwo.ino.

Next, navigate to the Wia Dashboard, create a new space and add device. Name it something like "playerOne".

Once you have added your device, navigate to the Devices tab on the left-hand side of the page. Select your device, then navigate to the configuration tab. You will see your device ID as well as your device_secret_key. You will need need to device secret key later.

The Code

Copy and paste the following code into your Arduino sketch named playerOne.ino.


#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>
#include <ESP8266HTTPClient.h>

#define USE_SERIAL Serial

ESP8266WiFiMulti WiFiMulti;

const char* ssid     = "name-of-your-Wifi";
const char* password = "your-Wifi-Password";

// get this from the wia dashboard. it should start with `d_sk`

const char* device_secret_key = "your-device-secret-key";

boolean buttonState = HIGH;
boolean buttonDown = false;

void setup() {
  // put your setup code here, to run once:
  pinMode(0, INPUT);
  Serial.begin(115200);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  WiFi.mode(WIFI_STA);
  WiFiMulti.addAP(ssid, password);
}

void loop() {
  // put your main code here, to run repeatedly:
  buttonState = digitalRead(0);
  // check if the pushbutton is pressed.
  // if it is, the buttonState is LOW:
  if (buttonState == LOW) {
    if (buttonDown == false) {
      Serial.println("Button Pushed");
      buttonDown = true;
      postToWia();
      delay(750);
    }
  } else {
    buttonDown = false;
  }
}

void postToWia() {
  // wait for WiFi connection
  if((WiFiMulti.run() == WL_CONNECTED)) {
    HTTPClient http;
    USE_SERIAL.print("[HTTP] begin...\n");
    // configure wia rest api
    http.begin("http://api.wia.io/v1/events");
    USE_SERIAL.print("[HTTP] POST...\n");

    // set authorization token
    http.addHeader("Authorization", "Bearer " + String(device_secret_key));
    // set content-type to json
    http.addHeader("Content-Type", "application/json");
    // start connection and send HTTP headers. replace name and data values with your own.
    int httpCode = http.POST("{\"name\":\"buttonPress\"}");
    // httpCode will be negative on error

    if(httpCode > 0) {
        // HTTP header has been send and Server response header has been handled
        USE_SERIAL.printf("[HTTP] POST... code: %d\n", httpCode);
        // file found at server
        if(httpCode == HTTP_CODE_OK) {
            String payload = http.getString();
            USE_SERIAL.println(payload);
        }
    } else {
        USE_SERIAL.printf("[HTTP] POST... failed, error: %s\n", http.errorToString(httpCode).c_str());
    }
    http.end();
  }
}

Change the following values:

name-of-your-WiFi to the name of your WiFi. This must be the same WiFi network that your computer is using.
your-WiFi-password to your WiFi network password
you-device-secret-key to your device secret key, found on the Wia Dashboard under Devices > Configuration

Upload the code to your device by clicking upload in the Arduino IDE. Then, set your device aside. Remember that this device is playerOne and contains the playerOne code.

Connect the second device to your computer, and add it to your space in the Wia Dashboard. This device will have an entirely different device-secret-key. Collect the key from the configuration tab. Copy and paste the code from before into the Arduino file playerTwo.ino, but change the device-secret-key to match the second device.

Upload the code from the file playerTwo.ino onto your second device.

Wia Flows

Now in your Wia dashboard, click Flows in the left-hand sidebar. Create a new flow and name it whatever you like.

Drag over an Event from the trigger tab and name it buttonPress. Select both devices.

In the logic tab, drag over a run-function node. Drag the yellow dot from the Event node to the run-function node. In the box, copy and paste this code:

  var items = [
    '🗿',
    '📜',
    '✂'
];

var item = items[Math.floor(Math.random()*items.length)];
output.body.data = item;

Your screen should look like this:

Click Update.
Then, in the action tab, drag over an event and name it emoji. To connect the nodes, drag the orange dots. Your screen should look like this:

Next, navigate to Devices > playerOne. This should take you to the overview page for your device. In the right hand corner, click add a widget. Write emoji for the title and emoji for the event. Then, navigate back to Devices on the sidebar and select your device for playerTwo. Create a new widget and write emoji for the title and emoji for the event.

Plug both devices into your computer. Press the flash button on both devices. Your widgets will show whether the device chose rock, paper or scissors.

However, navigating between the two devices is not an efficient way to play the game. So, we must make a webpage that will show us the result of each player's choice simultaneously.

To do this, we will use Github. You can create an account here.

Web Page

Begin by logging into Github. Create a new repository and name it your-github-username.github.io. Check the box to initialize with a README.

Once you have created your respository, open it. Click create new file. Copy and paste the code below into a file called index.html. The file must be named index.html.

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Wia Game</title>
  </head>
  <body>
    <h1>Wia Rock Paper Scissors</h1>
  </body>
</html>

This is the HTML boilerplate. To see our game update in real time, we need to embed our widgets from Wia. Back in the Wia Dashboard, navigate to one of the two player devices. In the overview, you can see your widget. Click the box with an arrow in the upper right hand corner of the widget. Choose the setting anyone can view this widget. Copy the code of embed the widget. The code starts with and ends with .

Back in GitHub, edit the index.html file. Paste the widget code below the header <h1>Wia Rock Paper Scissors</h1>.

Repeat this with the widget for the other device. Now, your HTML file should look like this:

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Wia Game</title>
  </head>
  <body>
    <h1>Wia Rock Paper Scissors</h1>
    <iframe> YOUR WIDGET </iframe>
    <iframe> YOUR SECOND WIDGET </iframe>
  </body>
  </html>

To view your new Web Page, navigate to https://your-github-username.github.io/

And there is your game!

How to install Node.js on any Raspberry Pi

Austin Spivey — Tue, 03 Jul 2018 12:39:40 +0000

Hi All,
Here's a quick tutorial showing you how to install Node.js on any Raspberry Pi. When logged into your Pi (either by SSH or desktop), run the following 5 commands one by one:

cd ~
wget https://nodejs.org/dist/v4.3.2/node-v4.3.2-linux-$(uname -m).tar.gz 
tar -xvf node-v4.3.2-linux-$(uname -m).tar.gz
cd node-v4.3.2-linux-$(uname -m)
sudo cp -R * /usr/local/

To check Node.js is installed correctly, run node -v. It should return v4.3.2. Run npm -v to check if NPM (Node package Manager) has also been installed.

How to Build Your Own Weather Station Using a Raspberry Pi

Austin Spivey — Tue, 03 Jul 2018 10:12:39 +0000

In this tutorial, we will show you how to create a Weather Station using a raspberry pi and send events to Wia.

This is an updated version of our old tutorial. There have been several changes to the Wia dashboard and code since our last tutorial.

What You Will Need

Raspberry Pi 2 or Model 3 B+
Raspberry Pi Sense HAT
Node.js and NPM must both be installed on the raspberry pi.

If you do not have it already installed, learn how to install node.js here.

Setting up the Raspberry Pi

First, you have to set up the Raspberry Pi. Our tutorial will walk you through it! Be sure to follow each step carefully. When you're ready, run ssh pi@('RASPBERRY-PI-IP-ADDRESS'). This will allow you to begin working in the raspberry pi terminal through your computer.

Setting up the Wia Node.js SDK

First, we need to create a folder on the raspberry pi to store our files. Create a new folder called wia-wether-device.

Next, initialize the package by creating a packackge.json file using the command line npm init. Hit enter for each of the prompts, they are not important at this time.

Once you are through that, you can install the Wia SDK onto the raspberry pi by using the command line npm install --save wia.

Using the Sense HAT with Node.js

Next, we must install nodeimu so that we can use the sensors. Use the command npm install --save nodeimu.

Your package.json file should look like this:

Create Your Weather Device

Go to the Wia Dashboard and select Create a New Space then select Devices. Add a device and give it a name. Now, in the Configuration tab for your device, you will find device_secret_key which should begin with d_sk. This will be important later on.

The Code

Create a file called index.js. Then, copy the code from the example below and paste it into the index.js file.

Replace the device_secret_key with your device's secret key.

'use strict';
var wia = require('wia')('device-secret-key');
var util = require('util')
var nodeimu  = require('nodeimu');
var IMU = new nodeimu.IMU();
var tic = new Date();
var callback = function (error, data) {
 var toc = new Date();
 if (error) {
   console.log(error);
   return;
 }
 // Send temperature data
 wia.events.publish({
   name: "temperature",
   data: data.temperature.toFixed(4) // data received from temperature sensor
 });
 // Send pressure data
 wia.events.publish({
   name: "pressure",
   data: data.pressure.toFixed(4) // data received from pressure sensor
 });
 // Send humidity data
 wia.events.publish({
   name: "humidity",
   data: data.humidity.toFixed(4) // data received from humidity sensor
 });
 setTimeout(function() { tic = new Date(); IMU.getValue(callback); } , 250 - (toc - tic));
}
// Using the MQTT stream
wia.stream.on('connect', function() {
 IMU.getValue(callback);
});
wia.stream.connect();

To test your program, run node index.js
Now, you should see events appearing in the Events tab for your Device in the Wia Dashboard.

The App

Next, we will make a few Widgets through Wia to present the data that the Weather Station collects. Log in to the Wia dashboard, and navigate to your Device. Select the Widgets tab and create a new Widget. Name it Humidity. For the event box, type humidity exactly as it appears in the node.js code that you copy and pasted before. Select done and you will see the latest update. Follow these steps for temperature and pressure to finish your Weather Station project.

Web Page

Next, create a webpage and host it on GitHub so you can check the weather from your Weather Station any time!

If you don't have a github account already, you can make one here.

Once you are set up with github, create a new repository and name it your-username.github.io. Check the box to initialize with a README.

Now, navigate to your new repository and create a new file. It must be named index.html. Copy and paste the following block of code:

  <!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
  </head>
  <body>

    <h1>Wia Weather Station</h1>

  </body>
</html>

So far, our webpage is pretty blank. Navigate back to your Wia Dashboard and in the overview for your Device, you can see your Widgets. In the upper right hand corner of the Widget, there should be a box with an arrow. Click the box and a screen like this should pop up.

Change the settings so that Anyone can view this Widget and embed it in any website. You should also Embed code, which will start with <iframe> and end with </iframe>. Copy the entire code and paste it below the <h1>Wia Weather Station</h1> line and above the </body> line. Your full code should look something like this:

  <!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
  </head>
  <body>

    <h1>Wia Weather Station</h1>

    <iframe> YOUR WIDGET </iframe>


  </body>
</html>

Do this again with each Widget.

Click commit changes and visit your site at https://github.com/username/username.github.io

You should be able to see the weather from your raspberry pi appear on your own webpage!

Javascript - DOM Manipulation without jQuery

Austin Spivey — Fri, 29 Jun 2018 09:57:09 +0000

Often, developers tend to rely on libraries like jQuery for basic DOM manipulation like querying elements, adding/removing classes, adding event listeners etc. A lot of resources point to jQuery as a solution for these things, but in reality, using it just for the basics is probably overkill for your website. The vanilla Javascript DOM API is more than capable of basic DOM manipulation, and being able to drop jQuery will mean a decrease in page load speed! Here's a run down of the basics in vanilla Javascript.

Querying DOM elements

There are a few methods you can use to query a DOM element in vanilla Javascript, the most common being document.querySelector(). This method takes a CSS selector as an argument, and returns the first match for that selector. Here's how to use it:

var mySelector = document.querySelector('.my-selector');
var paragraph = document.querySelector('p');
var hiddenInput = document.querySelector('input[type="hidden"]');

If you want to get all occurrences of a selector (for example, all the <h1> tags on the page), use document.querySelectorAll(). This method returns a NodeList. Here's how to use it:

var headings = document.querySelectorAll('h1');
var listLinks = document.querySelectorAll('li a');
var items = document.querySelectorAll('.my-selector > p strong');

To further manipulate them, you can simply iterate over them. There are a few ways to do this, the most straightforward being a for loop or a for of loop.

var headings = document.querySelectorAll('h1');

for (var i = 0; i < headings.length; i++) {
  var heading = headings[i];
  // do something with heading here
}

for (var heading of headings) {
  // do something with heading here
}

In recent browsers, you can also use the forEach() method on NodeLists:

var headings = document.querySelectorAll('h1');

headings.forEach(function(heading) {
  // do something with heading here
});

Other methods for querying DOM elements are document.getElementById() for getting the first element that matches an ID, document.getElementsByClassName() for getting a list of elements that match a class (returns a HTMLCollection), and document.getElementsByTagName() for getting a live list of elements that match a selector (returns a HTMLCollection).

The difference between getElementsByTagName() and querySelectorAll() is that getElementsByTagName() returns a live list, meaning that it will update if an element is added dynamically.

Adding/removing classes

A really common DOM manipulation is adding or removing a class from an element. Luckily, this is very easy to achieve with vanilla Javascript.

var button = document.querySelector('button');

button.classList.add('small');
button.classList.remove('large');
button.classList.toggle('active'); // if element has class 'active' then remove it, otherwise add it

Adding event listeners

Adding an event listener (like 'click', 'scroll' etc) is quite simple with vanilla JS. Simply use the addEventListener() method on a DOM element, passing in an event type and a callback function (similar to jQuery's on method). Here's how to use it:

var button = document.getElementById('button');

button.addEventListener('click', function(event) {
  // do something here
});

Putting it all together

Now that we've learned the basics of DOM manipulation, let's put them all together:

// Query all button elements
var buttons = document.querySelectorAll('button');

// Iterate through the buttons
for (var button of buttons) {
  // Add a 'click' event listener to each button
  button.addEventListener('click', function() {
    // Add a class to the clicked button
    this.classList.add('active');
  });
}

How we built our facial recognition ferris wheel

Austin Spivey — Thu, 28 Jun 2018 15:18:04 +0000

At Coolest Projects 2018, we showcased the Wia platform with a facial recognition ferris wheel - if you're smiling, the wheel turns, and if you're not smiling, it stops. Today we're going to talk about how we built this project, and maybe you'll be inspired to build something like it!

What we used

Lego Ferris wheel kit
Arduino MKR 1000
L293D motor driver
High torque DC motor
Breadboard
Raspberry Pi Zero W
Raspberry Pi Camera Module (we used this one)

The Lego Ferris wheel

For the Ferris wheel itself, we decided to go with this Lego kit. It took about 7 hours or so to complete. This kit has an optional add-on motor, but we decided to create our own solution.

Driving the motor

We used a high torque DC motor to turn the wheel, and the L293D motor driver to drive the motor.
Click here to read in depth about how we set this up, along with a basic code snippet for making the motor turn. We'll build upon this code later in this article, when we add in MQTT functionality to listen for Commands.

Attaching the motor to the wheel

The next step was to hook up the DC motor to the Ferris wheel mechanism and make it turn. This proved to be quite challenging, and required some dismantling of the lower part of the structure to make space for the components. We found that the motor's shaft fit almost perfectly into one of the Lego pieces, all we had to do was mount the motor in the correct place and make sure it wouldn't move around. So, we built a little Lego enclosure for the motor out of spare pieces, leaving space at the back for connecting the wires to the motor's terminals.

Listening for Commands

Next, we wanted to create some Commands for the Arduino to listen for, and rotate the motor accordingly. The first step was to create the Commands in the Wia dashboard. As you can see, we created some basic Commands for manually controlling the wheel, as well as a 'take photo' Command, which we'll get to later.

Next, we updated the Arduino code to use MQTT to listen for the Commands. Here's the code:

#include <WiFi101.h>
#include <MQTT.h>

const char WIFI_SSID[] = "wifi-ssid"; // WiFI ssid 
const char WIFI_PASS[] = "wifi-password"; //WiFI password

// get this from the wia dashboard. it should start with `d_sk`
const char* device_secret_key = "device-secret-key";

//WiFiSSLClient ipCloudStack;
WiFiClient wifiClient;
MQTTClient mqttClient;

int status = WL_IDLE_STATUS;

// Wia Cloud MQTT params
char mqttCloudServer[]     = "api.wia.io";
int  mqttCloudPort         = 1883;
char mqttCloudUsername[]   = "device_secret_key"; 
char mqttCloudPassword[]   = " "; 

// Wia API parameters
char server[] = "api.wia.io";
const int mqttPort = 1883;  // Default MQTT port

const String deviceId = "device-id";   // starts with dev_, found in Wia Dashboard
const String commandName = "take-photo";  // Configured in Wia Dashboard

// Topics
String takePhotoCommandTopic = "devices/" + deviceId + "/commands/take-photo/run";
String rotateForFiveCommandTopic = "devices/" + deviceId + "/commands/rotate-for-5-seconds/run";
String startMovingCommandTopic = "devices/" + deviceId + "/commands/start-moving/run";
String stopMovingCommandTopic = "devices/" + deviceId + "/commands/stop-moving/run";

//L293D
const int motorPin1  = 7;
const int motorPin2  = 6;


void messageReceived(String &topic, String &payload) {
  Serial.println("incoming: " + topic + " - " + payload);
  if (topic.equals(rotateForFiveCommandTopic)) {
    Serial.println("Rotating for 5 seconds.....");
    // Start rotating
    digitalWrite(motorPin1, HIGH);
    digitalWrite(motorPin2, LOW);
    // wait 5 seconds for connection:
    delay(5000);
    // Stop rotating
    digitalWrite(motorPin1, LOW);
    digitalWrite(motorPin2, LOW);
  } else if (topic.equals(startMovingCommandTopic)) {
    Serial.println("Start rotating.....");
    // Start rotating
    digitalWrite(motorPin1, HIGH);
    digitalWrite(motorPin2, LOW);
  } else if (topic.equals(stopMovingCommandTopic)) {
     Serial.println("Stop rotating.....");
    // Stop rotating
    digitalWrite(motorPin1, LOW);
    digitalWrite(motorPin2, LOW);
  } else {
    Serial.println("Unhandled topic");
  }
}

void connect() {

 // check for the presence of the shield:
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("WiFi shield not present");
    // don't continue:
    while (true);
  }

  // attempt to connect to WiFi network:
  while ( status != WL_CONNECTED) {
    Serial.print("Attempting to connect to SSID: ");
    Serial.println(WIFI_SSID);
    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
    status = WiFi.begin(WIFI_SSID, WIFI_PASS);

    // wait 5 seconds for connection:
    delay(5000);
  }
  Serial.print("\nconnecting...");

  Serial.println("\nconnected!\n");
  Serial.print("\nIP address: ");
  Serial.println(WiFi.localIP());

  // You need to set the IP address directly.
  mqttClient.begin(mqttCloudServer, mqttCloudPort, wifiClient);

  Serial.println("start wia connect"); Serial.println();

  while (!mqttClient.connect("wiatest", mqttCloudUsername, mqttCloudPassword)) {
    Serial.print("*");
    delay(500);    
  }

  Serial.println("Connected to MQTT");

  mqttClient.onMessage(messageReceived);

  mqttClient.subscribe(takePhotoCommandTopic);
  mqttClient.subscribe(rotateForFiveCommandTopic);
  mqttClient.subscribe(startMovingCommandTopic);
  mqttClient.subscribe(stopMovingCommandTopic);
}

void setup() {
  Serial.begin(115200);

  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);

  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);  

  connect();
}

void loop() {
  mqttClient.loop();
  delay(1000);

  if (!wifiClient.connected()) {
    connect();
  }

}

After uploading that code to the Arduino, we could then simply click 'Run' on the Commands in the Wia dashboard, and the Ferris wheel would turn accordingly.

The facial recognition camera

For the facial recognition camera, we used a Raspberry Pi Zero W with a Raspberry Pi camera module.
Read in depth about how we set this up here. This covers setting up the Raspberry Pi with the camera module, using NodeJS to take a photo and post it as an Event to the Wia platform, and setting up a basic Flow to check if the subject of the photo is smiling or not.

We built upon this setup a bit more, and added the ability for the Raspberry Pi to listen for the 'take photo' Command. Here's the code:

'use strict';

var wia = require('wia')('device-secret-key');
var fs = require('fs');
var RaspiCam = require("raspicam");

wia.events.publish({
    name: "started"
});

// Setup the camera
var camera = new RaspiCam({
  mode: 'photo',
  output: __dirname + '/photo.jpg',
  encoding: 'jpg'
});

// Listen for the "start" event triggered when the start method has been successfully initiated
camera.on("start", function(){
  console.log("Starting to take photo.");
});

// Listen for the "read" event triggered when each new photo/video is saved
camera.on("read", function(err, timestamp, filename){
  console.log("New photo created.", timestamp, filename);

  // Publish the photo to Wia
  wia.events.publish({
    name: 'photo',
    file:  fs.createReadStream(__dirname + '/' + filename)
  });
});

wia.stream.on("connect", function() {
  console.log("Connected to stream.");
  wia.events.publish({name: "connected"});
});

setTimeout(function() {
  wia.commands.subscribe({
    slug: 'take-photo'
  }, function(err, data) {
    wia.events.publish({name:"gotCommand"});

    console.log("In command callback. Taking photo.");

    // Take a photo
    camera.start();
  });
}, 12500);

wia.stream.connect();

Building the Flow

Our next step was to make the Raspberry Pi and Arduino work together over Wia, by creating a Flow.

In the Wia dashboard, we created a new Flow. The trigger is the photo Event created when the 'take photo' Command is run. This then goes through a 'Detect Faces' node, the output of which branches off into two logic nodes - one to output a string 'Smiling' if the subject is smiling, and one to output a string 'Not smiling' if the subject isn't smiling.
Here's the code for the 'smiling' logic node:

if (input.body.faceDetails) {
  input.body.faceDetails.forEach(function(face) { 
    if (face.smile.value == true) {
        output.process = true; 
      output.body.data = "Smiling";
    } else {
        output.process = false; 
    }
  });
} else {
    output.process = false; 
}

...and here's the code for the 'not smiling' logic node:

if (input.body.faceDetails) {
  input.body.faceDetails.forEach(function(face) { 
    if (face.smile.value == false) {
        output.process = true; 
        output.body.data = "Not smiling";
    } else {
        output.process = false; 
    }
  });
} else {
    output.process = false; 
}

If the subject is smiling, the 'start moving' Command is run, triggering the Arduino to start turning the motor. If the subject isn't smiling, the 'stop moving' Command is run, stopping the motor from turning.

Creating Widgets

You'll notice that we also have 'create event' nodes at the end of the Flow. This is where we use the output.body.data values from the logic nodes - to create Widgets!
Each time a photo is taken, a new Event is created with the data equal to either 'Smiling' or 'Not smiling'. Over on the Device overview page of the dashboard, we were able to create a text Widget that would display this text and auto-update every time a new photo is taken. We also set up handy widgets for running the various Commands, as well as displaying the photo taken by the Raspberry Pi!

Connecting a LoRa device to Wia via The Things Network

Austin Spivey — Tue, 26 Jun 2018 12:39:22 +0000

In this tutorial, we are going to take two Pycom LoPy's, set the first one as a LoRaWAN Gateway and register it as a Gateway with The Things Network. Then with the second LoPy, we set it up to talk to our LoRaWAN gateway and have the The Things Network push Events to Wia.

Components

2 x Pycom LoPy
2 x LoRa compatible antenna

Prerequisites

If you are completely unfamiliar with the Pycom LoPy and Wia, you should try our getting started tutorial on how to connect the LoPy over WiFi and publish an Event to Wia here.

Basic setup of the LoRaWAN Nano Gateway

We are going to use Pycom's LoRaWAN Nano Gateway example for our basic LoRa Gateway.

Create a new folder in Atom and name it lorawan-nano-gateway this is the main folder for our Nano Gateway
Go to the Pycom library examples in the lorawan-nano-gateway folder, the files can be found here
Copy the main.py, config.py and nanogateway.py into our main folder in Atom
Copy the code below into a file named boot.py

The code is run on boot up of the Pycom board and starts the Nano Gateway automatically when the board is connected to the power.

from machine import UART
import machine
import os

uart = UART(0, baudrate=115200)
os.dupterm(uart)

machine.main('main.py')

Now your folder structure for your LoRaWAN Nano Gateway should look like below:

main.py
boot.py
config.py
nanogateway.py

Click Upload in the Pymakr plugin at the bottom of your window in Atom and send the code to your Pycom board.

The Gateway ID will be used later when registering the Gateway with The Things Network

Registering with The Things Network (TTN)

To set up the Gateway with The Things Network, you'll need to register/create an account with them. The link to their registration page is here. Once registered, you'll be taken to the TTN console where you register Gateway's and Applications, monitor Device activity and set uplinks to push the data to other services.

Registering a Gateway with The Things Network (TTN)

Inside the TTN Console, there are two options, Applications and Gateways. Select Gateways and then click on register Gateway. This will allow for the setup and registration of a new Gateway.

The tick box from I'm using the legacy packet forwarder must be ticked
The Gateway EUI is from when we ran the Nano Gateway earlier
The Description can be what you like your Gateway to be used for
The Frequency Plan is for your region is the geographical area you are based
The Router that should be picked should be the closest to your area as well
Once you are finished inputting all the fields, click on Register Gateway

On registering your Gateway, you should have everything you need to have your Gateway communicate with TTN.

Configuring your LoRaWAN nano Gateway with The Things Network (TTN)

Now that your Gateway has been fully registered with TTN, you should see the push and pull acknowledgements in your atom terminal.

Setting up an application with The Things Network (TTN)

Applications are used to group a collection of device's that have similar functions.
In the TTN Console, click on the applications tab and click on add applicationyour application will need to have:

A random unique Application ID which you just generate yourself
A Description of your application
For the Handler Registration, add the handler that best suits your geographical region

Click on Add application to add an Application to TTN.

Adding a Device to your Application in The Things Network (TTN)

In the TTN Console, click on the Applications tab and click on the Application that we created earlier.

In the Application overview tab:

Click on register device on the Device's section
Add a unique Device ID(Device ID can only exist of lowercase alphanumeric characters, nonconsecutive - and _ and it cannot start or end with a - or a _)
Click on the pencil icon for Device EUI
Click on the Register button to add a Device

Activating The Things Network (TTN) integration in Wia

In your Wia dashboard, click on the Space you would like to add you and click on the settings icon on the left manu bar to see your Space's settings page.

Now click on the Integrations tab to see a list of the available Integrations:

FInd the The Things Network integration and click to add it
An Integration key will be generated for and should start with ik_

Go back to your TTN console and in you Application you just created, click on the Integrations tab:

Click on Get started by creating a new one to see the available integrations
Click on HTTP Integration
Add a random Process ID
Click on the Access Key that was generated earlier in your Application
Enter https://integrations.wia.io/api/ttn/uplink as the url
Select POST as the HTTP method
Add Bearer ik_your_integration_key, replacing the ik_your_integration_key with the Integration generated in your Wia Space
Nothing needs be added for Custom Header Name and Custom Header Value
Click on save so that TTN will push all Event data from your LoRa Devices to Wia

Now with setup everything with need to connected our LoRa Device's to The Things Network and publish our Events to Wia. Now we need to setup a LoRa client node. We'll need the second LoPy to complete this task.

Setup of an over the air activation LoRa node

In Atom, create a new folder and call it otaa_lora. In this folder add the config file from the LoRaWAN nano Gateway and copy it into the folder.

Create a main.py file and copy the code from below into it.

""" OTAA Node example compatible with the LoPy Nano Gateway """

from network import LoRa
import socket
import binascii
import struct
import time
import config
import random

# Initialize LoRa in LORAWAN mode.
# Please pick the region that matches where you are using the device:
# Asia = LoRa.AS923
# Australia = LoRa.AU915
# Europe = LoRa.EU868
# United States = LoRa.US915
lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)

# create an OTA authentication params
dev_eui = binascii.unhexlify('your-ttn-dev-eui')
app_eui = binascii.unhexlify('your-ttn-app-eui')
app_key = binascii.unhexlify('your-ttn-app-key')

# set the 3 default channels to the same frequency (must be before sending the OTAA join request)
lora.add_channel(0, frequency=config.LORA_FREQUENCY, dr_min=0, dr_max=5)
lora.add_channel(1, frequency=config.LORA_FREQUENCY, dr_min=0, dr_max=5)
lora.add_channel(2, frequency=config.LORA_FREQUENCY, dr_min=0, dr_max=5)

# join a network using OTAA
lora.join(activation=LoRa.OTAA, auth=(dev_eui, app_eui, app_key), timeout=0, dr=config.LORA_NODE_DR)

# wait until the module has joined the network
while not lora.has_joined():
    time.sleep(2.5)
    print('Not joined yet...')

# remove all the non-default channels
for i in range(3, 16):
    lora.remove_channel(i)

# create a LoRa socket
s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)

# set the LoRaWAN data rate
s.setsockopt(socket.SOL_LORA, socket.SO_DR, config.LORA_NODE_DR)

# make the socket blocking
s.setblocking(False)

time.sleep(5.0)

temperature = random.randint(0, 40)

for i in range (200):
    pkt = b'{}'.format(temperature)
    print('Sending:', pkt)
    s.send(pkt)
    time.sleep(4)
    rx, port = s.recvfrom(256)
    if rx:
        print('Received: {}, on port: {}'.format(rx, port))
    time.sleep(20)

You'll need to add the following keys obtained from TTN earlier into the tutorial code:

dev_eui (Device EUI)
app_eui (Application EUI)
app_key (The access key)

The LORAWAN mode should be set to the region that matches your region and the one you set for the LoRaWAN nano Gateway.

Add a boot.py file into the and copy the code for below into the file:

from machine import UART
import machine
import os

uart = UART(0, baudrate=115200)
os.dupterm(uart)

machine.main('main.py')

Now your folder: otaa_lora should contain:

main.py
boot.py
config.py

Note: If you have both your LoRaWAN nano Gateway and your otaa LoRa Node
running for your USB ports, you'll need to set project-level settings for one of the projects and change the address to the port that your second device is connected with. Click on Settings on the Pymakr plugin and click on project settings to add a pymakr.conf. This is where you add the port for your second device.

Click Upload in the Pymakr plugin at the bottom of your window in Atom and send the code to your Pycom board.

In your Wia Dashboard, click on your LoRa Device and switch to the Debugger tab to see the Events that your LoRa Device published coming through in real-time. To view all, click on the Events tab.

Handling your LoRa data in Wia

Now for the next step, we must parse the data we received from The Things Network and do something useful with it. For this we need to build a Flow.

Head over to your Wia dashboard and in the Space where your LoRa device is held. From there click on the Flow icon in the left hand menu to go your Flows.

Now to create your Flow, you can name it whatever you like. Once you have created a Flow, you should be taken to the Flow studio.

In the Flow studio:

Drag the trigger Event node from the left hand side onto the canvas
Click on the node and enter ttnUplink as the event name
Enable your LoRa Device as the event source

[upl-image-preview url=https://s3-eu-west-1.amazonaws.com/wia-flarum-bucket/2018-06-26/1530006282-733766-lora-flow-event.png]

Now drag over a function node from the logic section (We’ll parse the data here)

Click on the function node and add the following code:

function parseLoRaEvent(loraData) {
  return Buffer.from(loraData, 'base64');
}

if (input.body) {
  output.body.data = parseLoRaEvent(input.body.data.payload_raw);
}

This code parses the LoRa data from base64 format to ascii.

Start publishing data and your Flow should trigger.

That's it!

What is Wia, and how I can use it

Austin Spivey — Tue, 26 Jun 2018 11:18:34 +0000

After asking what you would like to hear about, I have lots of tutorials in the making, so thank you for all your feedback! In the meantime, I realised I should tell you about what Wia is and how you can get setup.

Starting with the basics, What is Wia?

Wia is an Internet of Things (IoT) cloud platform which provides a simple way for people and things to talk to each other with just a few lines of code encouraging developers to build any IoT application. Essentially providing the ability to turn any dumb device into a smart connected device within minutes.

Anyone can learn how to connect their favourite development boards to Wia and integrate with third party services.

For more advances developers you can also use our REST, MQTT and CoAP API reference by click here.

Create a Wia Account

You can create a Wia account by visiting the Sign Up page. Wia is free up to 10 devices at a time so you are able to continually test different devices and prototypes. Create a Wia account today.

Next Up, Create your Space

Spaces are a safe, secure place where your Devices live. You can create as many Spaces as you would like adding your Devices to monitor and share with anyone, anywhere. Learn how to create a Space.

Lets add your Devices

Harness the full power and potential of the IoT Devices you own. If it connects to the internet, it connects to Wia. We make it easy to connect and turn your Devices into smart applications within minutes. Learn how to add a Device.

Now publishing an event is as easy as 1,2,3

Once your Device has been added, you can publish events to Wia, and watch them come through in real time. You can also add a widget to see your Device data in your favourite format (I will talk more about this below). Learn how to publish an Event.

Taking it one fantastic step further

Flow Studio is the easiest way to connect your IoT devices to your favourite services. We are integrated with applications such as Slack and Twilio to help you get all your data in the most convenient way possible, tailored just for you. Learn how to create your a Flow.

The final step

Its time to add in a Widget or Command. Our new Widgets provide you with an overview of the data gathered from your Devices. Widgets display data through Text, Images, Maps and Commands. Learn how to add a Widget.

Commands allow you to control your Devices from near and far in a few simple lines of code. Learn how to add a Command

If you have any questions about how it works please ask, in the meantime many more tutorials are to come! Hope this helps explain Wia a bit more and will help with clarifying some of the tutorials I have posted.

What type of tutorials do people like to see?

Austin Spivey — Thu, 21 Jun 2018 14:47:13 +0000

We are rolling out more and more tutorials everyday but I always like to hear what people are most interested and what they would like to see! Any feedback is greatly appreciated.

Setup a Raspberry Pi Zero and Publish an Event to Wia

Austin Spivey — Thu, 21 Jun 2018 12:00:36 +0000

Components

You will need the following components:

Raspberry Pi Zero
microSD card
SD card adapter
Micro USB to USB cable
Ethernet cable and micro USB to ethernet adapter (if connecting via ethernet)
Compatible WiFi chip (if connecting via WiFi) and USB to micro USB adapter if necessary
Computer with an SD slot (or an appropriate SD card adapter)

Installing the operating system

Download Raspbian and extract the .img file
- On Windows, right-click on the Zip file in your downloads folder and click Extract All
Insert the microSD into your computer's SD card slot via the SD card adapter
Next, you'll need to flash the Raspbian image to the microSD. There are various applications you can use to do this, such as Etcher for Linux, macOS or Windows
Open the SD card from your file explorer - the drive will be labelled boot
SSH access is disabled by default. To enable it, create an empty file in the boot drive called ssh
- On Windows, inside the boot directory, right-click in the white space, scroll to New and select Text Document. Enter ssh as the name

Connecting to the network

Option 1 - Via ethernet

Connect the Raspberry Pi to your router via the micro USB to ethernet adapter and ethernet cable, and proceed to the next section.

Option 2 - Via WiFi

Connect your WiFi chip to your Raspberry Pi via the micro USB port.

On Mac/Linux

Create a new file in the boot drive called wpa_supplicant.conf
Follow code step below

On Windows

Download and install Notepad++ from here.
Once installed, inside Notepad++ go to File > New to create a new file.
In the top bar, select Edit > EOL Conversion. Make sure Unix (LF) is selected. It should appear disabled if it is.
Select File > Save as, navigate to your boot drive and call the file wpa_supplicant.conf

All OSs

Paste in the following code:

Text

 country=IE
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
  scan_ssid=1
  ssid="Your-SSID"
  psk="Your-PSK"
  key_mgmt=WPA-PSK
}

Replace Your-SSID with your WiFi network, and Your-PSK with your WiFi password.
This file will tell the Raspberry Pi to connect to the specified network when it boots up.

Note: Make sure your computer is connected to the same network as your Raspberry Pi.

Booting up the board

Eject the microSD card and insert it into the Raspberry Pi's microSD slot
Connect the PWR IN micro USB on your Raspberry Pi to a 5v power source (e.g. your computer's USB port)
Wait for the board to boot up - the green LED should stop flashing when it's finished booting up

Get your Raspberry Pi's IP Address

Option 1 - Login to your router

If you have access to your router, you can login to it's admin panel via a browser. It's usually something like 192.168.0.1, 192.168.1.1 or 192.168.1.254
Look at the list of devices and find the IP address of your Pi. It should look something like 192.168.1.8

Note: Please note
When entering a password in terminal or command prompt, you won't see it being typed, for security reasons. Simply type the password and hit the enter key.

Option 2 - Scan using Nmap

The nmap command (Network Mapper) is a free and open-source tool for network discovery, available for Linux, macOS, and Windows.

To install on Linux, install the nmap package. To do this, load your terminal and run the command apt-get install nmap. (If it does not run due to permissions, try sudo apt-get install nmap)
To install on macOS or Windows, see the nmap.org download page here

To use nmap to scan the devices on your network, you need to know the subnet you are connected to. First find your own IP address, in other words the one of the computer you're using to find your Pi's IP address:

On Linux, type hostname -I into a terminal window
On macOS, go to System Preferences then Network and select your active network connection to view the IP address
On Windows, go to the Settings, then under Network and Internet, select your connection type i.e. Wi-Fi, Ethernet, click Properties (for some this is called Hardware Properties)
In here, you will see IPv4 address
- Now you have the IP address of your computer, you will scan the whole subnet for other devices. For example, if your IP address is 192.168.1.5, other devices will be at addresses like 192.168.1.2, 192.168.1.3, 192.168.1.4, etc.

In your terminal or Command Prompt, now use the nmap command with the -sn flag (ping scan) on the whole subnet range. This may take a few seconds:
nmap -sn 192.168.1.0/24

Note: The 192.168.1 part in the command above should be replaced by the first 3 parts of the IP address you attained previously.

Ping scan just pings all the IP addresses to see if they respond. For each device that responds to the ping, the output shows the hostname and IP address like so:

Starting Nmap 6.40 ( http://nmap.org ) at 2018-04-02 12:51 GMT
Nmap scan report for Conalls-MBP (192.168.1.4)
Host is up (0.0017s latency).
Nmap scan report for iPhone (192.168.1.45)
Host is up (0.0021s latency).
Nmap scan report for raspberrypi (192.168.1.8)
Host is up (0.0038s latency).
Nmap done: 256 IP addresses (3 hosts up) scanned in 2.21 seconds
Here you can see a device with hostname raspberrypi has IP address 192.168.1.8.

Option 3 - Use the hostname

By default, the hostname for the Raspberry Pi is raspberrypi. If you cannot get your IP address, you can try using raspberrypi.local instead.

Connecting to Raspberry Pi via SSH

On Mac and Linux

Open a terminal window, and run ssh pi@ip-address
- Replace ip-address with the one you attained in the previous step
You will be prompted to enter a password - the default password is raspberry

On Windows

Download Putty from here to allow you to communicate with your board via SSH.
Under Host Name (or IP address) enter the IP address for your Raspberry Pi.
Click the Open button to create the connection.

Publishing an event to Wia

Once you're connected to the Raspberry Pi via SSH, run sudo apt-get install python-pip to install pip, a package manager
Run sudo pip install wia to install the Wia SDK.
Create a new directory for your project by running mkdir my-project
Navigate into this new directory by running cd my-project

For this tutorial, we'll use python, but you can also use our Node.js SDK.

Create a new python file by running touch test.py.

Note: You can name the file anything you want, but make sure you don’t name it ‘wia.py’ as this will cause an ImportError.

Edit the file with nano test.py
Paste in the following code snippet to get started:

Python

 from wia import Wia

wia = Wia()
wia.access_token = "your-access-token"

wia.Event.publish(name="temperature", data=21.5)

Replace your-access-token with your device's secret key (you can find this in your Wia dashboard, it begins with d_sk), and save the file by following the on screen instructions at the bottom.

Run your newly created script by running python test.py
Navigate to the Wia Dashboard and you'll see that your device is connected

Navigate to the 'events' tab, and you'll see an event has been published