JubitOS for Banana Pi

JubitOS (Jubito Operating System) is a Lubuntu based distribution for Banana Pi and is available for download. It is an out of the box compilation and it contains all the ingredients for a home automation server/hub. A native system that comes with all the dependencies required, plus some extra features that could be useful, like festival speech synthesis system and cmu_us_slt_arctic female voice package. The image is approximately 3.7GB, so, a 4GB SD card and higher is recommended.

Release Notes
JubitOS for Banana Pi (Linux kernel 3.4.103; 2015-02-09)
Default username: jubito (Caution: The user have administrative privileges)
Default password: jubitopi

• jubito
• mono-complete
• festival
• cmu_us_slt_arctic-0.95-release

Check this post for installation and extra tweaks.
To update Jubito to the latest version, download and replace extracted files to /usr/share/jubito. You can keep your configuration files AppConfig.xml, .htaccess, .scheduler, etc.

Arduino RFID access control

In this tutorial I will demonstrate an RFID (Radio Frequency Identification) access control system.

What we need:

• Arduino
• 125KHz RFID module
• RFID Tags

Once you wire the module, download the sketch and upload it to arduino.

Alternatively use codebender

Open the serial monitor and approach a token or a card to the antenna. You should receive the tag id.

Now we have readings let's handle them. It's in your discretion what to operate with those, but in this example we will make a simple check-in/check-out sequence.

As always, check your arduino configuration and then enable the serial port.

To achieve our goal we need to evaluate user status in order to switch from present to absent and vice versa when a tag is pointed. At Control Panel click Add New Instruction Set. Type rfideval in the name field (handler) or one of your choice and the evaluation that follows as the action...

{ evalBool("%whereami%" == "present"); check_me_out; check_me_in; }

'check_me_in' and 'check_me_out' are Instruction Sets that corresponds to our preferred actions. For example, saluting user using %salute% function, announce temperature even turning on a light. Also the %checkin% and %checkout% functions are mandatory to changing the current status.

To see how responses will look or sounds like, go to terminal tab and type...
  check_me_in; %whereami%
  check_me_out; %whereami%
...which  will execute the commands and after that get the status with %whereami% function.

We can also drive the check-out sequence within an event handler for extra functionality, like a countdown timer that give as time to leave before status is changed. This action can be achieved by pointing the check_me_out Instruction Set to event handler we just describe. The events will look like this...

judo sleep <ms>; %checkout%

The check_me_out Instruction Set now points to check-out-handler.

It would be wise to read about functions and API for extra customization. Also, it would be very handy to know how events work .It will help you to make multiple actions in a single command.

As we may already know, whatever collected by the serial port triggers corresponding events if they exists. This means that if we create a new event handler with name (id) same as RFID tag then it will be triggered when found.

Notice the last id in the serial monitor screenshot. When specific token (with id 6600942812) is acknowledged the event will trigger the evaluator 'rfideval' and change our status accordingly.

Communicate over a TCP socket

In the Internet of Things era, a good practice to communicate between protocol-agnostic software and/or hardware is a tailor made implementation on top of TCP. Jubito is taking advantage of Internet infrastructure and supports communication requests.

UPDATE: Currently the AppConfig.xml  configuration file is fully supported by the UI. Under settings you can find menus that corresponds to each functionality.

Trusted clients should be semicolon delimited.

I leave the paragraph below as is, in case you want to edit the file and see things behind the scenes.
Let's move to our example. First of all we need to configure the host and the port. Edit AppConfig.xml file and add your preferences to the following fields...

jaNET/System/Comm/localHost - A hostname of the server to connect to (it can also be its raw IP address)
jaNET/System/Comm/localPort - A number representing the TCP port to be used by the socket (Default is 5744)
jaNET/System/Comm/Trusted - Authorized clients delimited by semicolon

Sample Screenshot...

Save and close the file and go to Control Panel/Switches and turn on the socket.

Or by terminal...

judo socket open

We'll start our first debugging by sending some data via telnet.
Open command line ot a terminal in linux and type...

telnet <host> <port>

After that, drop some functions and/or commands (Instruction Sets)...

We can even make a RESTful style call from a web browser as well...

Now that we've find how to implement a communication channel and pass through any kind of data, such as built-in functions, judo API calls or custom Instruction Set's, let's see how to utilize it in a hardware manner using an http request by following that article...

DVR system by using an IP camera

...or by making a simple .NET application using the TcpClient Class of System.Net.Sockets namespace illustrated by the method bellow...

private string getServerResponse()
{
    Int32 port = 5744;
    String host = "localhost";
    String msg = "%whereami%\r\n"; // Always terminate command with \r\n else will cause a deadlock and socket need to be restarted.

    TcpClient client = new TcpClient(host, port);

    // Translate the passed message into ASCII and store it as a Byte array.
    Byte[] data = System.Text.Encoding.ASCII.GetBytes(msg);

    NetworkStream stream = client.GetStream();

    // Send the message to the connected TcpServer.
    stream.Write(data, 0, data.Length);

    // Buffer to store the response bytes.
    data = new Byte[16 * 1024];

    // Read the first batch of the TcpServer response bytes.
    Int32 bytes = stream.Read(data, 0, data.Length);

    // Close everything.
    stream.Close();
    client.Close();

    return System.Text.Encoding.ASCII.GetString(data, 0, bytes);
}

Sample Console application...

Sample ASP.NET web application...

Arduino light sensing

In this tutorial we'll create a simple circuit that sense light using a photoresistor.

What we need:

• Arduino
• Photo cell (CDS Photoresistor)
• 10K Resistor
• Breadboard or perforated pcb

Follow the screenshot to wire the photocell and then upload the sketch to arduino.

Alternatively use codebender

By hitting the 'light' command in the serial monitor we will get a print out of what it interprets as the amount of light in a qualitative manner. Thus is 'Dark', 'Dim', 'Light', 'Bright', 'Very_Bright'. You can change thresholds readings with values that suits your conditions.

OK, now we are ready to take advantage of the above example and make an assistive illumination system. As we already know we can capture serial messages from Jubito and trigger corresponding events. To make it happen we need to create one event handler with the name 'Dark' that will execute the 'plug-A-on' launcher of this example.

To do so, navigate to Control Panel/Instruction Sets/Add New Event Handler and enter the name and the action. When sensor submits 'Dark', the 'plug-A-on' launcher will be executed and turn on a light that is plugged to a wireless power outlet.

Notice: The above example to take effect, we need to let the loop continuous running and print out conditions than waiting for a 'light' command to be send. The modified sketch should be...

void loop(void) {

    // Light measurement
    photocellReading = analogRead(photocellPin);
    
    // We'll have a few threshholds, qualitatively determined
    if (photocellReading < 10) {
      Serial.println("Dark");
    } else if (photocellReading < 200) {
      Serial.println("Dim");
    } else if (photocellReading < 500) {
      Serial.println("Light");
    } else if (photocellReading < 800) {
      Serial.println("Bright");
    } else {
      Serial.println("Very_Bright");
    }
  }
  delay(1000);
}

But still you can use a scheduler and evaluator that applies to original sketch. Follow this article to see how you can do that.

Update

So we come back to see how we can make a running daemon with a scheduler that evaluates the light conditions.
First we need to create a launcher that executes the 'light' command we set to arduino sketch and fetch the state. Then we need a new Instruction Set that invokes it.

From the Instruction Set menu click Add New Launcher and give a name and the judo API call to send the 'light' command to the serial port.

After that create a new Instruction Set that invoke the launcher and make the evaluation with the 'Dark' condition. Type a name of your choise and the evaluation that follows...

{ evalBool("*getlight" == "Dark"); plug-A-on; ; }

The '*getlight' pointer will invoke the 'getlight' launcher and get its returning. Then it will be replaced by the condition data ('Dark', 'Dim', 'Light', etc) and proceed to evaluation. If condition is true the 'plug-A-on' launcher will be triggered, else nothing will happen.

The last thing to do to make it a runnable daemon is to create a new schedule that call the above Instruction Set within an interval.
From Scheduler menu click Add New enter a name, <Repeat> on the period dropdown, interval in milliseconds (the example use 60000ms which is 1 minute) and finally the 'evallight' Instruction Set as the action.

Video demo

Arduino IR remote control

After this tutorial we're coming back to make another kind of remote control. This time we will use infrared modules to receive and transmit codes to devices such as TVs, Hi-Fi systems, Projectors, etc. Thus will give as a universal remote control.

What we need:

• Arduino
• Digital IR Receiver Module
• Digital IR Transmitter Module
• IR Remote Library

First wire the modules and then install the library. To do so navigate to Sketch/Import Library/Add Library

Receiver

Transmitter

After installation is complete it will appear in library list.

Upload the sketch using codebender
Alternatively download the sketch and upload it to arduino.

Open the serial monitor point the IR receiver module and press a key of a remote control. It should return back the readings (code type, code value and code length).

To transmit back we have a simple implementation within loop that translates a specific form of data.

i.e. <codeType:><codeValue>&<codeLength>

For example, son:2704&12 which will cause the transmission.

Jubito as a virtual remote control
First make sure you have properly configure arduino serial port and then enable it.

From Instruction Sets menu press Add New Launcher. Enter a name (handler) and type the following command...

judo serial send son:2704&12

Then visualize it. Again on Instruction Sets menu press Add New Instruction Set and fill the mandatory fields (name, action, category, header) and some optional if you desire, e.g. Thumbnail URL.

As you might already know from previous tutorials, we point the 'sonypower' launcher with an asterisk in front of that.
After that final step you'll see a 'Media' category to your dashboard with the action we've just created.

Scan and enjoy your virtual universal remote control.

Arduino motion detection using a PIR sensor

In addition to this post, I'm providing the arduino sketch and the PIR motion sensor (Pyroelectric "Passive" Infrared Sensor) wiring as follows.

What we need:

• Arduino
• PIR motion sensor

Wire module to arduino and upload the sketch.

Alternatively use codebender
Open serial monitor and start moving, after that, follow this post and learn how to perform operations with Jubito or this one that concerns security.

Arduino MQ-2 Smoke/LPG/CO Gas Sensor Module

In this tutorial we will make a gas leakage detecting system with MQ-2 gas sensor which is sensitive to LPG, i-butane, propane, methane, alcohol, Hydrogen and smoke.

What we need:

• Arduino
• MQ-2 Smoke/LPG/CO Gas Sensor Module

Wire module to arduino and upload the sketch.

Alternatively use codebender

Open serial monitor and type 'smoke', 'co' or 'lpg'. Each of these commands will return concentrations of smoke, carbon monoxide and liquefied petroleum gas. You can read more details here.

You can define your own commands by changing the lines below...

After that we will use those values to detect for any king of leakage. We will make a new schedule that will run every 60 seconds and perform evaluation.

As usual please make sure you have properly configure arduino serial port and then enable it.

Let's get dirty
First we need to make a new launcher to retrieve smoke values for this particular example. Go to Instruction Sets menu and press Add New Launcher. Enter a name (handler) and type the following command...

judo serial send smoke

Then our notification launcher using judo mail send API command.
Syntax: judo mail send <from> <to> `<subject>` `<message>`

judo mail send xxx@gmail.com yyy@gmail.com `smoke alert` `Smoke detected *getsmoke ppm`

And finally the Instruction Set that handle the evaluation function. Press Add New Instruction Set, type a name and the following command...

{ evalBool(*getsmoke > 0); sendmailonsmoke; ; }

Note: Zero value can be changed with one of your choice you consider dangerous.

The above action will call the first launcher and get a value from the sensor, then will evaluate if it's greater than zero, if the statement is true the second launcher will be triggered and send us an email notification. Read more about evaluation function.

Now we are ready to create a 60 seconds schedule for task to be repeated. Click on scheduler and press Add New. In the popup window enter a name, period <Repeat>, interval in milliseconds <60000> and the 'smokeschedule' instruction set we had create in order to call the evaluation procedure.

This is it, once we save the schedule it will be activated. You can do the same way for gas (co) and perform a test with a lighter.

Another approach is to trigger an event from the sketch like this example.
You can accomplish that by change the lines below...

void loop(void) {
 
  if (MQGetGasPercentage(MQRead(MQ_PIN)/Ro,GAS_SMOKE) > 500)
    Serial.println("HazardousSmokeDetection");

When the measurement exceeds the value we have set, the 'HazardousSmokeDetection' will be printed to serial port and cause Jubito to execute the corresponding event.