Official website

Tuesday, July 29, 2014

Arduino RFID access control

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

What we need:
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.

Thursday, July 24, 2014

A brief history of the Jubito of Things

When I first started working on this project and had its concept in my mind back in 2010, I had no idea what the Internet of Things (IoT) was. Actually, I'm not even sure if it was defined. So, this is what forced me to start building a platform that would probably inherit that kind of terminology.

I was always fascinated by automations and dreamed of a smart house that would allow devices, sensors, software applications and services to exchange data and finally populate customized environments. These environments would be used for automated tasks or controlled interactively by the user.

Then I decided to start building my own automation systems with various microcontrollers and sensors, scripts and programs to gather information and connect with hardware from other vendors, like IP-Cameras, etc. A lots of other, innovative ideas that came along. The problem I faced back at the time was that. I had a bunch of dispersed stuff that was useful on its own and incapable of operating as a centric block.

To be honest, I didn't have the full picture in my head from the beginning, but eventually it started maturing enough to become a resolver for most of my considerations.

An illustration of the infrastructure...

In this blog you'll find a bunch of tutorials and information about Jubito and how to interconnect your things. I hope to find it amusing and still do not hesitate to ask any guidance if needed.

Saturday, July 19, 2014

Jubito android app with voice control

The new coveted feature that incorporated in the new version of jubito app (v1.2) is the speech recognition and speech synthesis. It allows us to hit the speech button and come out with a preferred command. That means that from now on your instruction set names (including launchers and events) must listed speech friendly.

Assume that we have three different Instruction Sets that give us the weather conditions. Let's say 'weather today' that consists of a set of today's conditions, 'weather tomorrow' for the day after and 'forecast' for both situations.

For the example to take effect you need to check your weather settings.

Go to Control Panel/Instruction Sets/Add New Instruction Set enter weather_today as name (id) and set the line bellow as action...

Today %todayday% in Athens, %todayconditions%, between %todaylow% and %todayhigh% degrees.

For the other two options you can use...

Tomorrow %tomorrowday% in Athens, %tomorrowconditions%, between %tomorrowlow% and %tomorrowhigh% degrees.

Today %todayday% in Athens, %todayconditions%, between %todaylow% and %todayhigh% degrees. Tomorrow %tomorrowday% in Athens, %tomorrowconditions%, between %tomorrowlow% and %tomorrowhigh% degrees.

Optionally fill description and any other field you want in order to be accessed from the dashboard.

The % enclosures represents the built-in functions that are responsible to translate the retrieved weather data to values. Find more weather functions.

Now open the app and press speech button. The approach is very simple, we just speak the instruction set id (name) and its posted to the server. Once it acknowledged we'll be able to hear the response (from speech synthesis) or see any kind of action that use this example, for instance turn on an appliance. The only limitation we should conform is that we need to replace blank spaces with underscores. Update: Latest versions of Jubito, automatically replace blanks with underscores.

Alternatively before create an instruction set you can perform a preferable command and see how it prints out.


Video demo

Tuesday, July 15, 2014

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.

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

Sample Console application...

Sample ASP.NET web application...

Friday, July 11, 2014

Arduino light sensing

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

What we need:
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) {
    } else if (photocellReading < 200) {
    } else if (photocellReading < 500) {
    } else if (photocellReading < 800) {
    } else {


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

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

Wednesday, July 9, 2014

Jubito android client app v1.1 [ nightly ]

A nightly version (1.1) of Jubito client app is available for download.

The most significant addition is the geo location based user status according the home location.

How it works
In Jubito settings you'll find the button "Get Location". This will retrieve the current location of you at the time you press it. After applying settings and if you enable the feature from the according checkbox, it will be activated when app is running.

The specs for the task is to check when location is changed in a span of 5 seconds, over a step of 25 meters and at a radius of 500 meters against the home location. If you're located within radius, it will trigger the %checkin% function corresponding to your registration and vice versa (%checkout%) when you go ahead.
Check more on built-in functions.

Please feel free to report bugs or any extra additions.

Tuesday, July 8, 2014

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:
First wire the modules and then install the library. To do so navigate to Sketch/Import Library/Add Library


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.

Friday, July 4, 2014

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:
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.

Thursday, July 3, 2014

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:
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 `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)

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.