JubitOS-Z is a free Operating System (OS) for the Internet of Things
(IoT). A single image that convert your Banana Pi or BPi-R1 to a
inexpensive home automation hub.
The combined power of RaZberry and
Jubito brings together the most cutting edge technologies
like Z-Wave and Arduino. Regardless of whether you are a beginner, an experienced maker or a professional this
software will let you transform your house into a self-regulating
mechanism at an extremely low budget. No additional hub is required.
Furthermore you can install Kodi, ownCloud, and much more for enhanced
home center experience. Unlike any other proprietary product, it is
designed with open technologies. Now, privacy is in your hands. No registration, no dependency on cloud-based services.
Since the latest version of Jubito, based on jaNET Framework 0.2.5 [ rev. r550 ], was released, I spent some time, by doing tests in multiple environments. I focused on single board computers, such as Raspberry Pi and Banana Pi, both with Rasbian and Lubuntu flavors. To my surprise, the installation and migration was flawless! Actually, it was expected, but I didn't have the chance to give a try till I bought them.
So, the evolution came with a new Jubito Home Server, passing from my old netbook Dell mini 9, to a Raspberry Pi and finally to a Banana Pi.
Let's take a look at some pictures from varioustests.
Dell mini 9 (Ubuntu)
Hosted on upper kitchen cabinets
Asus eee (Linux Lite)
Mac (OS X Yosemite)
Raspberry Pi (Raspbian)
Banana Pi (Lubuntu)
Migration process...
Banana Pi + Arduino Uno + Various modules
Stress tests, power consumption tests (*), cpu and memory load tests.
(*) Arduino needs external supply 9V. If not, then with some open tabs on Firefox or other load Banana turns off.
The outcome!
Playing with Banana Pi for three weeks, I believe is a good deal and I recommend it.
Current compilation is consisted with the Banana Pi as my Jubito Home Server and the Arduino, plus various sensor modules for environment control.
Now, it's time to become invisible and be placed in its natural location, the upper kitchen cabinets.
The release of the updated version comes with Mac OS X support, including TTS. In most cases, you probably have noticed that I used the command-line interface, because it's more straightforward to me and also it runs natively, with no extra dependencies that wouldn’t already be available on each platform. [ Download page ]
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.
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...
'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.
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...
// 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.
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.
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.
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.
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.
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>`
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.
