Newb Guide to Jubito Universal IR_rcmm_Uverse_Add Protocol_IRLib_Remote Control

[ PROGRESS ] - Go to the bottom of the guide if you'd like to see progress updates - [ PROGRESS ]

Arduino is something I've shied away from for years. I was always worried that any project I'd attempt would be too technical, frustrating, and inaccessible. Running an arduino as a universal IR remote is fortunately well within the grasp of almost anyone who cares to attempt it. After enjoying the hospitable arduino community in all its wisdom, I've realized how fortunate we all are to have such a rich source of information at our disposal. The individuals who made this project possible have gone to great lengths to share their knowledge and I for one would like to thank everyone. My hope is that this guide will make your IR remote setup as easy as possible. This is honestly the most enjoyable and educational project I think anyone could wish to start with. I hope you find this guide helpful.

I've attached all my modified files for your convenience. That should make things very easy, and with the right knowledge, that is all you'll need. I imagine some may have more use for greater detail. I'm providing a separate Guide I will refer to as Additional Guide located lower in the thread, which describes file changes I've made, and how I made them. I'll do my best to make this as clear and complete as I can. This has all worked fantastic for me so far, but to be honest, I've not tested this for very long and can't vouch for any long-term reliability. Please keep in mind that I'm a newb myself, and I'm only hoping to provide you with insight. Be sure to read up on soldering, circuitry, safety, arduino basics and any other subject of inquiry that you may encounter in this guide.

One of the best things I found in my search for Universal IR bliss, is Jubito. If you aren't familiar with Jubito by Jambel, it's time for you to do your homework. (you don't have to, but please do) The guide I'm linking to by Jambel will already meet the needs of most anyone out there. It is very clear and newb-friendly. This guide will provide the same newb friendliness, but will also go into greater detail about the technical background of the code.

Jambel created a sketch which was written for the older IR library known as Arduino-IRremote by z3t0. The Arduino-IRremote library later spawned an updated library known as IRLib by Cyborg5. Although the Arduino-IRremote met most of my needs as it would yours, it wasn't compatible with my Uverse boxes (Motorola VIP2200 & VIP2250). That is what forced me to learn more about IR and arduino coding then I care to know, to be honest. IRLib claims to be compatible with Uverse and I can confirm that this is true, but they make you merge the code yourself. That was where things got complicated for me, but not for you. The real technical challenge beyond modifying the library, was creating a sketch which let me send RCMM (Uverse IRTYPE) commands at will instead of the default sketch which could only store and send 1 code at a time. I mention this for those who seek greater detail, as for anyone else, nevermind what I just said. Just pay close attention from here on out.

[ EDIT ] 2015-11-29 - Some time has passed since I wrote the guide. It's worth noting that Pronto Send Hex offers greater compatibility than IRLib when used in conjunction with IrScrutinizer. This is discussed in greater detail in the Progress Updates section at the bottom of the guide. A new updated guide will follow soon.

JUBITO IR REMOTE CONTROL

JUBITO GETTING STARTED

Jubito:
"Wrap your Arduino with Jubito and dynamically populate HTML5 web interfaces against custom Instruction Sets. Expose your projects to the Internet with the built-in lightweight web server and gain access anywhere in the world, from any device. No extra programming or native code required."

For those who don't want to read that, Jubito is running a basic server on your computer which when accessed from a browser provides a full website where commands can be set and accessed. Those commands are sent to the arduino via your computer. For all intents and purposes the Jubito site is your web-accessible arduino serial monitor. Jubito helps facilitate the process of automating your home and that means you can do way more than just sending IR signals. That is a story for another time, but to make this long story short, Jubito is your friend.

Things to seriously keep in mind:

  1. If the IR signal readout appears as RAW data or isn't otherwise decoded properly, you are dealing with 1 of at least 7 probable causes.
    a. Make sure the recv pin is set correctly in the sketch. (Pin 2 in my case)
    b. Your remote isn't close enough to the receiver or sometimes not far enough. Get as close as you can and as far as you can (try lots of positions)
    c. The library simply doesn't support your remote. Possible decoding solutions are discussed in the PROGRESS UPDATES section. (I estimate a 30% chance of no support in IRLib)
    d. "#define RAWBUF" should be changed from default to 140 to accomodate duration (Located in IRLib.h) (things get tricky here)
    e. Some code (who knows what) will need to be added to either the library or sketch in order to decode. (might involve raw data)
    f. Let's assume things are complicated. You'll have to read up on how to decode raw data. (Good Luck with that)
    g. Hardware Issues (May god be with you)

  2. This isn't a hardware guide so make sure you've got your hardware needs covered. That means if you aren't even able to read some kind of signal from your remote, it's almost certainly a hardware problem and you need to resolve it.

  3. Just so you know, you don't strictly have to use one specific arduino board. Addicore ESP8266 ESP-01 WiFi Wireless Tranceiver Module A small wifi shield like that one can actually run arduino code and host a simple website on it's own wirelessly. Think that one over for yourself. The possibilities are endless, but that's way beyond the scope of this guide.

  4. You may have to troubleshoot a variety of issues. Please know that I understand, but this isn't a troubleshoot guide. Still, I'll try to mention where the more immediate sticking points could lie. You are seriously going to want to read almost every reference I provide if your problems prove difficult. It's the best I can do for you, but at least there's hope.

  5. The IR transmitter (LED) belongs on Arduino PIN 3. I accidentally had PIN 2 indicated as the transmitter PIN in this guide. PIN 3 is the transmitting PIN for IRLib. Also note that the IR transmitter used in the guide has a very short range of around 3 - 4 Feet. If you know what you're doing, I'm sure you can find a more high powered alternative.

I used the following hardware:
You'll want to shop around for yourself. These links are for reference only. A total budget of $30 - $40 should be enough. If you already have the arduino board then $10 should be your total budget.
Sparkfun Redboard (required)
940nm IR Transmitter LED 40deg - IR333C (required)
38khz IR Receiver - TSOP38238 (required)
100 ohm resistor (required)
MALE FEMALE CABLE (not required)
or
MALE MALE CABLE (not required)
Breadboard (now this is handy) (not required)
Solderless Breadboard Jumper Wire (not required)

Follow this Jubito Guide instead if you don't care about using IRLib (most current IR Library)

Here is where I found the Uverse IR Protocol Info

########## TO BE CONTINUED ##########

Files for Guide rcmm Uverse.zip (1.21 MB)

########## CONTINUED ##########

Setup Guide:

My wiring was as follows:

When facing front of IR Receiver, count left to right
Receiver Pin 1 - Arduino Pin 2
Receiver Pin 2 - Arduino Pin GND (next to 5v PIN)
Receiver Pin 3 - Arduino Pin 5v

For the IR Transmitter
Long Leg of Transmitter is + which is connected to Arduino Pin 3 (edit-sorry, I accidentally had this as 2)
Short Leg of Transmitter - Put 100ohm resistor between Short leg of transmitter and Arduino Pin GND (next to VIN PIN)

Bare in mind that if this Setup Guide isn't technical enough for you, then you'll want to refer to the Additional Guide down below, as a detailed extension to this Setup Guide.

Download and install Arduino 1.6.6 (Latest)
Download Jubito Server
Download My Modified Files

NOT REQUIRED - If you want the original IRLib unmodified, HERE it is, but the original files are only discussed in the Additional Guide: (look for the download zip option on the right side)

I'll start by setting you up to test your hardware and software and introduce you to the procedure which you'll follow later to add all your remotes to the Jubito database. What I recommend you do here is test all your remotes of concern immediately with the receiver once it's setup. I inform you when to start testing in the guide and tell you what to do to efficiently get through any initial troubleshooting.

Unzip “Files for Guide rcmm Uverse.zip”
Put the .ino files into their own separate folders. Required for some reason.
Open Arduino Program (make sure your com port is set correctly)
Install library - Got to -> Sketch - Include Library - Add “IRLib-master rcmm Uverse.zip” Library (My modified IRLib library)
Open sketch SKETCH_FOR_TEST_RECEIVING_REMOTE.ino
Upload that sketch to the Arduino. (There shouldn't be any compiling errors, and if there are, it won't upload)
Open the Serial Monitor
Point and click your remote right at the Arduino receiver
It should give you a readout of the remote signal. Like This


Decoded NEC: Value:2340265C (32 bits)
Raw samples(36): Gap:19962
  Head: m410  s340
0:m160 s240	1:m160 s640		 2:m160 s240	3:m210 s740		 
4:m160 s440	5:m160 s290		 6:m160 s290	7:m160 s240		 
8:m210 s240	9:m160 s640		 10:m160 s440	11:m160 s590		 
12:m160 s440	13:m160 s440		 14:m160 s790	15:m160 s290		 

16:m160
Extent=10560
Mark  min:160	 max:210
Space min:240	 max:790

If you didn't get a signal at all, you have work to do. (Please refer to my "Things to seriously keep in mind" section)

I will not go into any deeper explanation on the variations it may spit out. All you need to know is that if it identifies the manufacturer (protocol) , it will also provide a value which is our primary concern. The bits are another piece of required info. If you really want to be thorough, be sure to press the same remote button like 6 distinct times in a row. If the 6 readouts give the same value, then you're golden. Also note that when I say identify the manufacturer, I don't mean the brand of your remote. The protocol from your Motorola remote may be NOKIA protocol in which case it is identified as RCMM. My Vizio tv is NEC protocol. NEC is identified as 1 in the library, and RCMM is identified as 10, just to give you an example. (More on that later) When you look at that code, this is what you should see in your mind:

1, 2340265C, 32
or stated differently
code type, code value, code length (bits)

That is your key to sending an IR signal.

Speaking of keys, here are the protocol numbers for each protocol for future reference:
UNKNOWN-0, NEC-1, SONY-2, RC5-3, RC6-4, PANASONIC_OLD-5, JVC-6, NECX-7, RCMM-10 (you see it correctly, went from 7 - 10, long story, don’t worry about it, nothing is missing)

What is cool here, is that in this test sketch, it allows you to immediately transmit any signal you've just received. One at a time only, but still this is perfect to make sure your hardware is in order. Simply type in any character like "U" for example, hit enter and it will send that signal you just received right out through your IR transmitter (LED) on pin 3. Any device within range should trigger the exact same as your remote control. When blasting IR make sure you're within range of the device you wish to control.

Test all your remotes with the IR receiver now. Just take each one and see if it gives you a readout and a send. One or 2 buttons will be enough for each remote just to check it. Each remote that only gives you raw or fails to identify a protocol is going to be your problem child. Make sure to check the "Things to seriously keep in mind" section in that event.

Before we move on, I want you to pick 1 remote, and on it choose 1 button. That 1 button should be pressed 6 times in the manner specified above. If it looks kosher, then you can take note of the code type, code value, code length as mentioned previously.

We are now going to attempt manually sending the code in order to trigger the IR signal on your IR LED connected to Pin 3.

First, you'll need to upload a different sketch. We're now going to open WORKING_SKETCH_FOR_UVERSE.ino which is in fact the final sketch we'll be using at the end of this guide. You guessed it, once the sketch has been uploaded you can type "1, 2340265C, 32" (or whatever your readout was, without quotations) in the serial monitor and hit enter. If your device is within range it should trigger your chosen button.

The response will look something like this: Prot:1 Code:2340265C Bits:32

You will probably want to attempt a couple of reads and sends with at least 2 buttons of each remote with it's respective device from the Arduino. Definitely do this now to identify potential problems you have to resolve at some point. It’s the only way to be sure.

That concludes introduction and testing

########## TO BE CONTINUED ##########

########## CONTINUED ##########

What this really boils down to, of course, is that you need to gather all of your IR codes together and prepare them for processing. To get all of your IR codes, you need to repeat the steps above. That means you'll need to log what each code is for each button of each remote. Logging is all you're doing here. You don't have to actually attempt a send for every single button, just log it and you're done.

Where do the codes go, you might ask. Here is where Jubito comes to rid us of our tethers. A command database at your convenience.
Jubito Getting Started Guide

[ EDIT ] 2015-11-26: To turn off Jubito Confirmation Button, a minor modification should be made to the jubito.core.js. (located in the js folder in the jubito-server folder) Remove both instances of "$('div#popup-response-p1').popup('open');" . You'll see that code twice in the file. Both need to be deleted. This has to be done because Jubito by default gives a confirmation screen which interferes with pressing multiple buttons quickly. This is a great quickfix. To turn off jubito voice response, just change the file name of the jspeech.exe file and you won't hear anymore Voice Response.

All you have to do is startup arduino and make sure WORKING_SKETCH_FOR_UVERSE.ino is uploaded onto your arduino. If it is, and you have your Jubito zip unpacked, then all you have to do is start jubito-server.exe as administrator. (firewall issues or connection issues you encounter are up to you to resolve so check the getting started guide for Jubito) Keep the arduino program on in the background as long as Jubito is running. Jubito opens a simple window with start and stop. That just turns it on and off clearly, but the real settings once turned on are accessed via your browser.

http://localhost:8080/www/index.html was the address I used to access Jubito from my browser. Username: admin Password: admin

OPTIONAL - The rest of this guide is very similar to the Jubito Arduino IR Remote Control Guide. Go down to the part where he mentions codeType:& . From there he gives clear illustrations.

Anyhow, here is what to do in Jubito. Once at the homepage of your Jubito server, go to menu in the top left. Cick on settings.

Go Down to Serial Port
Click on Setup Port/Baud. You'll want to enter in your com port there. Mine was COM3. Your baud should be set to 9600.
Click that Serial Port on
Go up to Instructions at the top
Click Add New Launcher

Choose a name for your Launcher (anything will do like ATT Power)
For Action you can enter "judo serial send 1:2340265C&32" (or whatever your readout was, without quotations)
Hit Save

Click on Add New Instruction Set
Choose a name for the Instruction Set (Cable Box Power)
For Action you don't have to type anything, instead hit the plus sign next to Add Action(s)
In the Action List you can select your action and hit the Add button.(The one above function list) It will automatically populate Action with the correct name *ATT_POWER

Click on Add to Dashboard at the bottom (Don't hit save yet)
You will See:
*Category
*Header
Short Description
Description
Thumbnail URL
Reference

######## OPTIONAL ########

Only the Category and Header are required. If you want to have nicer interface, you can add the following: (Optional)
Create or download an icon image for your button in Jubito. You can search "power icon" in google and use any downloaded image for this purpose.
Save that download image into the following subfolder in your jubito-server folder.
jubito-server\www\images\Your Own Custom Folder\image.png
If we turn that into a URL it should look something like http://localhost:8080/www\images\Your Own Custom Folder\image.png
If you copy that custom Thumbnail URL we just created into the Thumbnail URL field, you'll find you have a working button icon at the end.
You can actually put the URL you created into your browser if you want to test it. It'll show you an image if you did it correctly.
Hit Save

##########################

After you hit save, go to the Menu tab in the top left again.
Click on Dashboard
At the top beneath where it says Jubito, you'll find a dropdown menu that probably says User. Click on that
In the dropdown select your Category
It will display your newly created button
If you now point your IR transmitter at the device you've now programmed it for and click on your custom button, it'll send the desired code and you should see your device respond accordingly.

Now it's rinse and repeat for all your other remotes. I hope you get the idea by now.

My hope is to possibly update this guide in the future. I really need to work on my posting skills. Get some embedding going on, maybe some picture, etc. I think this should be enough for most. That is the end of my total newb guide to Jubito, IRLib and the RCMM Protocol for Uverse boxes. I delve into code more in my Additional Guide. My hope is that the Additional Guide below will give newbs seeking more of a challenge a head start in learning how to manage protocols, and modify libraries. It simply breaks down the steps I had to take in order to merge the rcmm sketch with the library. None of that is necessary if you're satisfied with your current setup. I blasted both guides out in 1 night so please be gentle on me if there are any errors. I'll do my best to correct them.

Even with all the hard work of the excellent programmers involved, the chances that your remote isn't supported is quite high. 30% chance by my estimation for typical media center/TV remotes in IRLib. Arduino-IRremote has a 60% chance of incompatibility in contrast. (These #'s aren't official, they're based on my experience) That means you either need to get creative and add support to IRLib for your protocol, or you'll need to find an alternative solution. For those who seek information and alternatives, you'll want to go to the - PROGRESS UPDATES - at the bottom of the Additional Guide.

This is what we're talking about.
Scroll to the very bottom of the guide to see my Unified Remote setup. UR and Jubito are sure to impress.



Thanks for reading

Here are some great places to read up on IR Protocols and such.
These are also good sources for a ESP8266 ESP-01 project.
Good Source 1
Good Source 2
Good Source 3
Good Source 4
Good Source 5
Good Source 6
SPARKFUN IR GUIDE
RASPI RELATED REFERENCE

########## END OF SETUP GUIDE (GO FORTH TO THE ADDITIONAL GUIDE) ##########

Additional Guide - NOT REQUIRED (OPTIONAL)

This guide describes more what is happening behind the scenes in the code. My original Setup Guide is more complete but not as detailed. If the thought of merging code and managing protocols makes you uncomfortable, then you're going to want to go up to my Setup Guide.

Thanks for getting this far. If you are like me and have all the curiosity in the world but are too lazy to do much about it, then I'll thank you to offer a tip of your hat when you next have time. What I'm attempting here comes solely from the spoils of the internet. I don't actually beleive my coding skill to be beyond that of a modern kindergartner. Not that I want to give myself too much credit. The IRLib journey was an interesting one for me. What I found so fascinating was that IRLib ver.-1.51 supported UVERSE RCMM NOKIA blah, blah, blah which was exactly what I needed. However, upon closer inspection, I discovered that this RCMM support was not directly available in the library. Don't get me wrong, I'm not here to bite the hand that feeds me. I have no doubt there are solid reasons for why that is the case. Cyborg5 by no means left us empty handed, it just took a little figuring out.

I remind you again that this is being looked at from the perspective of someone who has only lightly dabbled in coding (we're talkin just a dip of the toe here). I would like to briefly describe what I was working with and what I did with it. I'll talk about it as if I were working from scratch.

Lets talk files, to begin we have the one and only original unmodified IRLib zip library. Once that's installed in the arduino program, it creates an unpacked library folder typically located in C:\Users\Your Name Example\Documents\Arduino\libraries. Within the IRLib directory the first thing you'll see are a bunch of files among which you'll spot IRLib.h and IRLib.cpp. In the subfolder called example you'll find all the example sketches you could want. If you can make sense of them, I mean. That's what I'll attempt to clarify here.

Files of interest:
IRLib.h
IRLib.cpp

Example Sketches of interest:
IRrecord.ino - Clearly lets you record from the Receiver (sort of tested) (NO RCMM Default Support)
IRrecvDump.ino - This is a great go to if you want to just see a readout from your IR Remote (NO RCMM Default Support)
*rcmm.ino - From what I could see this is the same as IRrecord except it has RCMM protocol Support
*Samsung36.ino - If you open rcmm, it will clearly refer to Samsung36 for good reason as you'll find out
IRserial_remote.ino - I recommend you play with this. It will also let you send out commands like "1, 20DF629D, 32" Shown in setup guide. (NO RCMM Default Support)

Those are the ingredients we need to make this happen.

Now you want the widest range of support you can get. rcmm.ino is your best bet for that because all it does is add one more decoding option which is great. I had to use rcmm because I knew my remote required it. You should try to find out your device's protocol if you run into any issues, as it's kind of a necessary point of reference for getting raw code decoded.

At this point you might expect that rcmm.ino on it's own will meet your requirements. Sadly No, but it does work right out of the box for getting code readouts. And you can send out the previously received code one at a time simply by hitting a single key and enter. This means it's ripe for testing remotes as soon as you upload the sketch to your arduino. All that is needed is the arduino serial monitor open and it'll read whatever comes through the receiver.

RCMM.ino on its own is great, but we need to be able to send various IR signals at will. RCMM.ino doesn't offer that by default. Hence the problem, we are newbs, and god knows I don't know what to change in the code to make that work. I spent hours searching and wasn't able to find a newb friendly guide on anything that specific. Point is, we need to be able to send various "1, 20DF629D, 32" (IR Send) commands at will with full rcmm support. Here We Go

RCMM.ino itself gives us the answers in it's divine text. It states that:

" This example demonstrates how to extend this library to add a new protocol without actually modifying or recompiling the libnonstickrary itself. It implements the Phillips RC-MM also known as Nokia Protocol. Is used by AT&T U-Verse cable boxes.There are three different varieties that are 12, 24, or 32 bits.This is a modified version of the IRecord example. If you would like to make this a permanent part of your library you could copy the class prototypes to IRLib.h and the code itself to IRLib.cpp. Search for the word "ADDITIONAL" to see where to add various pieces of code. Also see the Samsung36 example for details. "

There it is!! Now I don't know if you looked at the code, but that is a tall order for a newb. It is a humble walkthrough to say the least, and the text takes you through the code in sections, explaining as it goes. Even with that, it was a lot to take in for me. They're talking about merging code from the rcmm sketch into the library. That needs to be achieved while somehow coming out on the other end with a workable sketch. The important reference they make here is to the Samsung36 example sketch. That is the saving grace. Problem is, despite the similarities between Samsung36 and rcmm, it's still a slightly different sketch. It wasn't impossible to relate them but certainly difficult. I did my research online, and I couldn't find anyone discussing this specific scenario in IRLib. It looked like I had to go it alone.

I'm only going to talk about the individual code sections I moved from rcmm, and not go into detail about what Samsung36 had to offer. Just know that Samsung36 is essential to breaking down how the code merge was done. I'm just going to take you straight to the final product and show you what to move section by section. In addition to moving code, some minor lines of code had to be added and altered. That’s an important section which I’ve clearly marked.

All Line numbers here are based on the unmodified original IRLib.h and IRLib.cpp in order to keep a consistent point of reference. If you’re lost, look to the original files for Line #s. If you aren't used to programming, you can easily get lost while editing this code, believe me.

Here are some great places to read up on IR Protocols and such.
These are also good sources for a ESP8266 ESP-01 project.
Good Source 1
Good Source 2
Good Source 3
Good Source 4
Good Source 5
Good Source 6

The Merge Begins

++++++++++++
rcmm.ino Merge Break-Down:
++++++++++++

// This section stays right where it is


#include <IRLib.h>
#include <IRLibMatch.h>

// This class over here goes to IRLib.h
// At Line 167
// Between virtual bool decode(void); };
// and // main class
// Delete this section from rcmm.ino after moving


class IRdecodeRCMM: public virtual IRdecodeBase
{
public:
  bool decode(void); 
};

// This class over here goes to IRLib.h
// At Line 246
// Between void send(unsigned long data); };
// and class IRsend:
// Delete this section from rcmm.ino after moving


class IRsendRCMM: public virtual IRsendBase
{
public:
  void send(unsigned long data, unsigned char nbits);
};

// These definitions go to IRLib.h
// After Line 76
// Between #define ADDITIONAL
// and #define HASH_CODE 8
// The following definition causes RCMM to be referred
// to as Protocol # "10" for future reference (#"1" is NEC)
// Delete this section from rcmm.ino after moving
// Note that I've changed this next one from the original code slightly
// to help illustrate how it should look with HASH_CODE in IRLib.h
// Numbers seem off, but I tell ya it works like this


#define RCMM (LAST_PROTOCOL+1)
#define HASH_CODE 9
#define LAST_PROTOCOL HASH_CODE
#define RCMM_HEAD_MARK 417
#define RCMM_DATA_MARK 167
#define RCMM_ZERO      278
#define RCMM_ONE       444
#define RCMM_TWO       611
#define RCMM_THREE     778

########## TO BE CONTINUED ##########

########## CONTINUED ##########


// This bool thing goes to IRLib.cpp
// At Line 659
// Between return true;
// and /*
// Delete this section from rcmm.ino after moving


#define RCMM_TOLERANCE 80
bool IRdecodeRCMM::decode(void) {
  long data; 
  IRLIB_ATTEMPT_MESSAGE(F("RCMM"));
  if ( (rawlen!=(12+2)) && (rawlen!=(24+2)) && (rawlen!=(32+4)) ) return RAW_COUNT_ERROR;
  if (!MATCH(rawbuf[1],RCMM_HEAD_MARK)) return HEADER_MARK_ERROR(RCMM_HEAD_MARK);
  if (!MATCH(rawbuf[2],RCMM_ZERO)) return HEADER_SPACE_ERROR(RCMM_ZERO);
  offset=3; data=0;
  while (offset < (rawlen-1)) {
      if (!ABS_MATCH(rawbuf[offset],RCMM_DATA_MARK, RCMM_TOLERANCE+50)) return DATA_MARK_ERROR(RCMM_DATA_MARK);
      offset++;
      if (ABS_MATCH(rawbuf[offset],RCMM_ZERO, RCMM_TOLERANCE) ) { //Logical "0"
        data <<= 2;
      } 
      else if (ABS_MATCH(rawbuf[offset],RCMM_ONE, RCMM_TOLERANCE) ) { //Logical "1"
        data = (data<<2) + 1;
      } 
      else if (ABS_MATCH(rawbuf[offset],RCMM_TWO, RCMM_TOLERANCE) ) { //Logical "2"
        data = (data<<2) + 2;
      } 
      else if (ABS_MATCH(rawbuf[offset],RCMM_THREE, RCMM_TOLERANCE) ) { //Logical "3"
        data = (data<<2) + 3;
      } 
      else return DATA_SPACE_ERROR(RCMM_ZERO);
      offset++;
  }
  if (!MATCH(rawbuf[offset],RCMM_DATA_MARK))  return DATA_MARK_ERROR(RCMM_DATA_MARK);
  bits = rawlen-4;//set bit length
  value = data;//put remaining bits in value
  decode_type= static_cast<IRTYPES>RCMM;
  return true;
};

// This void thing goes to IRLib.cpp
// At Line 228
// Between space(107000-Extent); // Turn off at end }
// and /*
// Delete this section from rcmm.ino after moving


void IRsendRCMM::send(unsigned long data, unsigned char nbits) {
  Extent=0;
  data = data << (32 - nbits);
  nbits=nbits/2;
  enableIROut(36);
  mark(RCMM_HEAD_MARK); space(RCMM_ZERO);//Send header
  for (int i = 0; i < nbits; i++) {
    mark(RCMM_DATA_MARK);
    switch (data & 0xC0000000UL) {//use the leftmost two bits
      case 0x00000000UL: space(RCMM_ZERO); break;
      case 0x40000000UL: space(RCMM_ONE); break;
      case 0x80000000UL: space(RCMM_TWO); break;
      case 0xC0000000UL: space(RCMM_THREE); break;
      default: Serial.println("sending error");
    }
    data <<= 2;
  };
  mark(RCMM_DATA_MARK);  
  space(27778-Extent);
};

// The following code is not located in the rcmm.ino, it must be seperately added into the
// IRLib.cpp and IRLib.h files. Be sure that they get added (and look out for commas)
// I'll just show you each completed section with location (note the comma after NECx to allow for additional protocol)


+++++++++++++++++
IRLib.h
Line 169 - Line 177

// main class for decoding all supported protocols
class IRdecode: 
public virtual IRdecodeNEC,
public virtual IRdecodeSony,
public virtual IRdecodeRC5,
public virtual IRdecodeRC6,
public virtual IRdecodePanasonic_Old,
public virtual IRdecodeJVC,
public virtual IRdecodeNECx,
public virtual IRdecodeRCMM

+++++++++++++++++
IRLib.h
Line 247 - Line 256

class IRsend: 
public virtual IRsendNEC,
public virtual IRsendSony,
public virtual IRsendRaw,
public virtual IRsendRC5,
public virtual IRsendRC6,
public virtual IRsendPanasonic_Old,
public virtual IRsendJVC,
public virtual IRsendNECx,
public virtual IRsendRCMM

+++++++++++++++++
IRLib.cpp
Line 42 - Add F("RCMM") as shown
F("NECx"),F("RCMM"),F("Hash Code")};
+++++++++++++++++
IRLib.cpp
Line 234 - 243

void IRsend::send(IRTYPES Type, unsigned long data, unsigned int data2) {
  switch(Type) {
    case NEC:           IRsendNEC::send(data); break;
    case SONY:          IRsendSony::send(data,data2); break;
    case RC5:           IRsendRC5::send(data); break;
    case RC6:           IRsendRC6::send(data,data2); break;
    case PANASONIC_OLD: IRsendPanasonic_Old::send(data); break;
    case NECX:          IRsendNECx::send(data); break;    
    case JVC:           IRsendJVC::send(data,(bool)data2); break;
	case RCMM:          IRsendRCMM::send(data,data2); break;

+++++++++++++++++
IRLib.cpp
Line 417 - 425

bool IRdecode::decode(void) {
  if (IRdecodeNEC::decode()) return true;
  if (IRdecodeSony::decode()) return true;
  if (IRdecodeRC5::decode()) return true;
  if (IRdecodeRC6::decode()) return true;
  if (IRdecodePanasonic_Old::decode()) return true;
  if (IRdecodeNECx::decode()) return true;
  if (IRdecodeJVC::decode()) return true;
  if (IRdecodeRCMM::decode()) return true;

+++++++++++++++++


// Be sure to save your IRLib.cpp and IRLib.h files now.
// The remainder here of rcmm can stay where it is.
// Do Not Delete The Remaining Section
// Everything from "class MyCustomSend:" on down remains till we edit it
// Only the top and bottom sections should now remain in the sketch
// It will look like this (don't forget to set your RECV_PIN accordingly)


#include <IRLib.h>
#include <IRLibMatch.h>

class MyCustomSend: 
public virtual IRsend,
public virtual IRsendRCMM
{
public:
  void send(IRTYPES Type, unsigned long data, int nbits);
};
void MyCustomSend::send(IRTYPES Type, unsigned long data, int nbits) {
  if (Type==RCMM)
    IRsendRCMM::send(data,nbits);
  else
    IRsend::send(Type, data, nbits);
}
class MyCustomDecode: 
public virtual IRdecode,
public virtual IRdecodeRCMM
{
public:
  virtual bool decode(void);    // Calls each decode routine individually
  void DumpResults(void);
};
bool MyCustomDecode::decode(void) {
  if (IRdecodeRCMM::decode()) return true;
  return IRdecode::decode ();
}
void MyCustomDecode::DumpResults(void){
  if(decode_type==RCMM) {
    Serial.print(F("Decoded RCMM: Value:")); Serial.print(value, HEX);
  };
  IRdecode::DumpResults();
};

MyCustomDecode My_Decoder;

MyCustomSend My_Sender;

int RECV_PIN = 2;

IRrecv My_Receiver(RECV_PIN);
IRTYPES codeType;         // The type of code
unsigned long codeValue;  // The data bits
int codeBits;             // The length of the code in bits or for Samsung is storage for data2
bool GotOne; 
char c;

void setup()
{
  GotOne=false;
  codeType=UNKNOWN; 
  codeValue=0; 
  codeBits=0;
  Serial.begin(9600);while (! Serial) {};
  Serial.println(F("Send a code from your remote and we will record it."));
  Serial.println(F("Type any character and press enter. We will send the recorded code."));
  My_Receiver.enableIRIn(); // Start the receiver
  My_Receiver.Mark_Excess=40;
}
void loop() {
  if (Serial.available()>0) {
    c=Serial.read();
    if (c=='p') {//Send a test pattern
      GotOne= true;  codeType=RCMM; codeValue=0x12345678; codeBits= 32;
    }
    if(GotOne) {
      My_Sender.send(codeType,codeValue,codeBits);
      Serial.print(F("Sent "));
      if (codeType== RCMM) Serial.print(F("RCMM")); else Serial.print(Pnames(codeType));
      Serial.print(F(" Value:0x"));
      Serial.print(codeValue, HEX);
      Serial.print(F(" Bits:"));
      Serial.println(codeBits, DEC);
      My_Receiver.enableIRIn(); // Re-enable receiver
    }
  }
  else if (My_Receiver.GetResults(&My_Decoder)) {
    My_Decoder.decode();
    if(My_Decoder.decode_type == UNKNOWN) {
      Serial.println(F("Unknown type received. Ignoring."));
    } else {
      codeType= My_Decoder.decode_type;
      codeValue= My_Decoder.value;
      codeBits= My_Decoder.bits;
      GotOne=true;
    }
    My_Decoder.DumpResults();
    delay(1000);
    My_Receiver.resume(); 
  }
}

// Save the sketch now as "IR Read Code" or something since that's what the sketch will be used for later
// If you compile this sketch now and upload it, it'll function exactly as the original rcmm did, with a very important difference
// It is now integrated and merged into your library, so we have more control over the commands
// The only remaining issue is that the bottom section of code needs to be altered in the rcmm.ino


########## TO BE CONTINUED ##########

########## CONTINUED ##########


// As is, the code will only allow for the previously received signal to be sent out as apposed to any signal at will
// To open that door we'll take a small section of code from our friend IRserial_remote (the sketch example mentioned previously)
// In the IRserial_remote sketch you'll find the following lines of code


int protocol;
long code;
int bits;
void setup() {
  Serial.begin(9600);
  delay(2000);while(!Serial);//delay for Leonardo
}

long parseHex (void) {
  long Value=0; char C;delay(100);
  while (Serial.available()>0) {
     C= tolower(Serial.read());
     if ((C>='0')&&(C<='9'))
       C=C-'0';
     else
       if ((C>='a') && (C<='f'))
         C=C-'a'+10;
       else
         return Value;
     Value=  C+(Value<<4);
  };
  return Value;
}
void parseDelimiter () {
  char C;
  while(Serial.available()>0) {
    C=tolower(Serial.peek());
    if( (C>='0') && (C<='9') )return;
    if( (C>='a') && (C<='f') )return;
    C=Serial.read();//throwaway delimiters
    delay (5);
  }
}

void loop() {
  if (Serial.available ()>0) {
    protocol = Serial.parseInt (); parseDelimiter();
    code     = parseHex ();        parseDelimiter();
    bits     = Serial.parseInt (); parseDelimiter();
    Serial.print("Prot:");  Serial.print(protocol);
    Serial.print(" Code:"); Serial.print(code,HEX);
    Serial.print(" Bits:"); Serial.println(bits);
    My_Sender.send(IRTYPES(protocol), code, bits);   
  }
}

// Replace the following code section in the modified rcmm sketch with the section shown above
// That means you need to make sure to delete the following section in the modified rcmm.ino


void setup()
{
  GotOne=false;
  codeType=UNKNOWN; 
  codeValue=0; 
  codeBits=0;
  Serial.begin(9600);while (! Serial) {};
  Serial.println(F("Send a code from your remote and we will record it."));
  Serial.println(F("Type any character and press enter. We will send the recorded code."));
  My_Receiver.enableIRIn(); // Start the receiver
  My_Receiver.Mark_Excess=40;
}
void loop() {
  if (Serial.available()>0) {
    c=Serial.read();
    if (c=='p') {//Send a test pattern
      GotOne= true;  codeType=RCMM; codeValue=0x12345678; codeBits= 32;
    }
    if(GotOne) {
      My_Sender.send(codeType,codeValue,codeBits);
      Serial.print(F("Sent "));
      if (codeType== RCMM) Serial.print(F("RCMM")); else Serial.print(Pnames(codeType));
      Serial.print(F(" Value:0x"));
      Serial.print(codeValue, HEX);
      Serial.print(F(" Bits:"));
      Serial.println(codeBits, DEC);
      My_Receiver.enableIRIn(); // Re-enable receiver
    }
  }
  else if (My_Receiver.GetResults(&My_Decoder)) {
    My_Decoder.decode();
    if(My_Decoder.decode_type == UNKNOWN) {
      Serial.println(F("Unknown type received. Ignoring."));
    } else {
      codeType= My_Decoder.decode_type;
      codeValue= My_Decoder.value;
      codeBits= My_Decoder.bits;
      GotOne=true;
    }
    My_Decoder.DumpResults();
    delay(1000);
    My_Receiver.resume(); 
  }
}

// You can save this sketch as "IR Send Code" or something since that's what this version of the sketch will be used for
// That just about seals it. What you end up with is a sketch which will let you send commands like "1, 20DF629D, 32"
// The only disadvantage is that you'll need to load a separate sketch ("IR Read Code") if you want to get a read on your remote.
// Since all your remote reading are meant to be done in your initial setup, the lack of read capability in this sketch
// shouldn't stand in your way. Once you have all the read codes, you add them to the Jubito database and just upload this modified rcmm.ino
// and send your IR signals till the cows come home.


++++++++++++
End of Merge Break-Down
++++++++++++

With this modified library, and the modified sketches, you are pretty much left with logging your IR codes and getting them into Jubito which is precisely what I address in the original Setup Guide. It's a lot of information and with my limited knowledge, I'm certain there are holes in here somewhere. I'll certainly be on the lookout for more information with regards to this guide, but I figured since I got a working project, combined with the fact that nobody seems to have covered this stuff for newbs, I better just push it out there till something better comes along. I hope you've enjoyed reading this as much as I've enjoyed writing it. Thanks again to the entire Arduino community. You're the salt of the earth.

########## THE END (FOR NOW) ##########

[ PROGRESS ] - PROGRESS UPDATES - [ PROGRESS ]

If you're looking for more info on decoding additional protocols, this is where you want to be. This isn't a guide, it's just to inform you of solutions I'm exploring.

[ EDIT ] 2015-11-17 - There are more remotes I want to decode and it's lookin like even IRLib isn't getting it done anymore. Thankfully there may be a solution to literally almost all of our decoding needs. I don't know how I didn't find it sooner. AnalysIR.

AnalysIR has an export function which works for several IR libraries. So far, the IRLib export function hasn't given me much to work with as a newb. I'll be continuing my testing with AnalyIR in the coming days. More On AnalysIR

What I can tell you for certain about AnalysIR is that the demo version doesn't allow you to communicate with the arduino. I can tell you that for non-commercial use you'll be paying roughly $15 as an average user. There is a pricing system you'll want to look at. Out of the box and with very little work, it'll decode just about any controller you throw at it. Problem is getting that decode functionality to work with IRLib, because this is all about Jubito in the end.

AnalysIR is definitely a must for anyone who wants to know as much as possible about their remote without too much fuss. For those with more coding knowledge, it may well be that AnalysIR is a ticket to simpler decoding.

My goal is to find the simplest way to allow newbs to get the decode info out of AnalysIR and into IRLib in order to open up functionality with Jubito. With any luck that will be my next major update to the guide. No Promises

[ EDIT ] 2015-11-18 - After investing several hours, another status update seems justified. AnalysIR is definitely good, and it will remain a big part of my decoding quest. However, AnalysIR output is still proving near impossible to integrate into IRLib for a newb. I feel an alternative will have to be found until more IRLib solutions become available. I've read a decent amount about various decoding options, not just the arduino. I can't complain about the documentation available. If I wasn't frugal, I could have taken several steps to make things simpler. I'm limiting myself strictly to arduino, and that may not be the easiest option, if I'm being honest. Luckily, I'm stubborn, but you might not be. Be sure to read up on alternative device options like IRToy or Raspi LIRC.

For those who would like to see Jubito work with just about every remote in existence, the following may be of interest to you. To start with, there is a program called IrScrutinizer by bengtmartensson. It's a java based IR solution (so you need java installed) which will work with arduino when used in conjunction with Agirs. Agirs is also by bengtmartensson, and is a complete package addressing several hardware solutions including arduino. Agirs contains GirsLite and GirsLib which can both be added to the arduino Library Folder. The GirsLite folder contains the Girslite sketch which will need to be loaded to the arduino. I'm not really guiding you here, that's just a tidbit that you need to know.

Think of IrScrutinizer as a free version of AnalysIR with it's own set of advantages and disadvantages. IrScrutinizer has what appears to be a similar level of protocol support to AnalysIR. More importantly, it also has it's own set of export functions that could be of serious help to folks looking for additional compatibility. (Like adding protocol to IRLib or other libraries) Sadly there is too much info for me to go into detail about all this.

To add to what I've just said, the thing that makes IrScrutinizer so enticing is the fact that it works with AGirs. Agirs has IRLib integrated into it among other libraries. That means it has some serious protocol support. HarcToolBox Has lots of good info as does IrScrutinizer_Guide . It's all about config.h when you are initially setting up GirsLite.ino for the arduino. When using the hardware I've specified in my guide, you have to change the config.h in order to allow for a demodulating receiver, by defining RECEIVE. With Receive enabled, the receiver pin is #5 on the arduino board. With Capture enabled it's pin #8. (just so you know) When Capture is defined it will will work with a modulating receiver. When Receive is defined instead of Capture, you can use a demodulating TSOP38238 receiver on pin 5. The baud rate is 115200 by default in case you want to use the serial monitor. Here's an example of the modified section in config.h.

config.h file example:
// Use one of these two, normally CAPTURE
// Define RECEIVE to us a demodulating receiver (TSOP*) instead.
// #define CAPTURE
#define RECEIVE

When using the serial monitor with GirsLite.ino, you have to press "r" then enter to begin signal capture. That means if you want to test GirsLite.ino before opening IrScrutinizer, you can do it this way in the serial monitor. Make sure you're connected to pin 5. The signal tends to delay about 5 - 10 seconds before you see a respone. You have to press "r" then enter for each individual capture.

If IrScrutinizer will allow me to export in such a way that I can use Jubito to send commands at will, then we're in business.

Now that I've actually had an opportunity to run some tests with IrScrutinizer, I feel comfortable saying that it appears very robust. AnalysIR is $15 where IrScrutinizer is free, so based on my results, AnalysIR is completely unnecessary for the common newb.

[ EDIT ] 2015-11-20 - Pronto Hex is where I think this is headed now. Otherwise known as CCF FORMAT (not to be confused with CCF File Format). irdb appears to be the solution to the before mentioned issues. We want a means of identifying and/or decoding every protocol we might encounter. AnalysIR and IrScrutinizer have addressed that to beyond an acceptable level. IRLib is great on it's own but not nearly as well supported. Once decoded we want to be able to send that signal out via the serial monitor and by extension, Jubito. That is where Pronto Hex comes in to let us arbitrarily send out the signals we require. Pronto has a sketch to allow for that called send_pronto_hex.ino (download as zip). Add the pronto folder to the arduino library folder, and upload the .ino to the arduino. IrScrutinizer is the powerhouse which will provide us with the required Pronto Hex code to send the desired signal. I'm now going to begin experimenting, and will post results. The next issue I anticipate once I get the Pronto Hex working, is compatibility with Jubito. I don't know if Jubito will let us send these commands. It will be a minor issue in the scheme of things, I'm sure.

##IMPORTANT##
IRLib Implementing New Protocols - This is the page you'll want to keep an eye on if adding new protocol to IRLib interests you. Cyborg5 claims documentation on adding protocol will be updated. So now we play the waiting game.
##IMPORTANT##

########## TO BE CONTINUED ##########

########## CONTINUED ##########

[ EDIT ] 2015-11-23 - For those interested, you'll be glad to know that IRDB has so far shown itself to be the most complete source for our IR sending needs. I seem to be able to send all my desired IR signals and that's all that was required. To my amazement, the actual Protocol Database on IRDB.tk turned out to have HEX codes which worked inconsistently with Send Pronto Hex. I checked the HEX codes produced by IrScrutinizer and found the same unreliable HEX code so I was about to lose hope, as not having a working HEX would mean no working signal. [ EDIT ] The baud rate needed to be set to 115200 in order to produce consistent results. The serial monitor was set to Newline as an option which also proved to have positive results. Results will vary for everyone. Test as many different settings as you can.

[ EDIT ] - AnalysIR turned out to be a mixed bag when it comes to HEX codes. Yes, they often do work, but somehow they can be inconsistent with Pronto Send Hex. I'm not taking anything away from AnalaysIR, it's amazing. Playing around with the signals I received got me decent results but in the end it was IrScrutinizer that stole the show.

Bottom line, Jubito works with Pronto Hex Sender. The Hex Codes required to recreate virtually any signal with Hex Sender are available in AnalysIR, or IrScrutinizer or by searching IRDB.tk. If you want the IR wisdom of AnalysIR, you'll be spending $15 for the privilege.

I still need to mess with this a bit more, but things now look extremely promising. All this work is about to culminate into the Newb Guide 2.0 which I hope to have ready no later than mid December, but I will shoot to have it ready by December 1, 2015.

[ EDIT ] 2015-11-26 - I've been putting in a good amount of work on getting this perfected. Getting reads and sends to function flawlessly was a bit harder than I expected. Clear roads ahead now as I think I'm getting the hang of this. So much of what I've done is going to make for a massive guide update. The setup process is not exactly inherently newb friendly and involves tons of testing, so it will be time consuming, even for a more practiced Arduino enthusiasts, I imagine.

I've now had the chance to focus in more closely on Jubito and it's great set of features. I realized that I overlooked what would be a brick wall for some of the readers. A confirmation normally comes up each time a button is pressed, so that pretty much makes full IR use impossible as you'd be pressing an extra button each time you send a signal. NOT COOL!! I've added the process to the guide in the Jubito setup section. Jubito despite it's greatness, isn't optimized for IR remote use when it comes to it's menu system, not yet anyway. That's easily resolved with a little HTML editing if you're experienced with that sort of thing. I'm interested to see what can be done with HTML modifications.

How To Turn Off Jubito Confirmation Button:
A minor modification should be made to the jubito.core.js. (located in the js folder in the jubito-server folder) Remove both instances of "$('div#popup-response-p1').popup('open');" . You'll see that code twice in the file. Both need to be deleted. This has to be done because Jubito by default give a confirmation screen which interferes with pressing multiple buttons quickly. This is a great quickfix.

How To Turn Off Jubito Voice Response:
Just change the file name of the jspeech.exe file and you won't hear anymore Voice Response.

[ EDIT ] 2015-11-27 - I hope everybody's Thanksgiving was as good as mine was. The saga continues. As I go through and put the finishing touches on my setup, I'm realizing how poorly my Setup Guide addresses network setup with Jubito. In addition, I feel I need to add a little bit more troubleshooting guidance. By the end of the weekend, I'll be revamping the Setup Guide to better address some of the unusual problems that can arise during setup. I hope everyone till now who has used the guide has enough experience to resolve things on their own.

[ EDIT ] 2015-11-29 - Finally I got the signals working exactly as they should. IrScrutinizer was actually the most accurate source for my HEX codes ultimately, but I was still dependent on AnalysIR for my SONY amplifier. So I've discovered both programs can be essential. Jubito is still going strong despite minor issues which need to be addressed in the guide. I'm very impressed by how well the whole thing works.

I should also mention that I added a newline character to every instruction provided in Jubito. Just as an example, if you were to look at my AppConfig.xml, you'll see something like the following towards the end of every instructionset line.

0677 \n"

Now that my signals are in order, I want to see about getting Jubito working on a linux system. I'll almost certainly be doing that on my Raspi. That's going to be my setup until I can get something more efficient, and wireless like the ESP8266 ESP-01. Some customization seems in order with regards to remote button interface also. Jubito is cool, and will get the job done, however, it doesn't quite offer the efficiency that a customized remote layout would offer. That's not necessarily something I'm equipped to do anything about, but who knows what I might come across.

[ EDIT ] 2015-11-30 - I've come across something. There is a good chance Unified Remote will allow for a multiplatform remote that is customizable and could ultimately work with Jubito. Jubito can be communicated with through TCP commands such as the following:

http://:/
e.g. http://192.168.1.92:5744/play_button

So any app that will let us send that kind of TCP command will let us control Jubito over the network. This makes for great possibilities. I've got quite a bit more research to do on the subject.

[ EDIT ] 2015-12-04 - I've been working very hard the past couple of days to get the functionality out of Unified Remote that will bring this whole thing to its final, awesome conclusion. I am now able to create buttons in Unified Remote that will control the database in Jubito and effectively let us build our own custom remotes. Unified Remote works with countless devices and will let you combine functionality from multiple remote control sources into one amazing remote or several if that's what you prefer.

Out of the box, Unified Remote will turn into a mouse pad at the push of a button, or a keyboard. From there you can click another button and switch into any custom remote you like. Widgets can also be created so you could have a single button on your phone's home screen and have that control just about anything you desire.

This comes down to having 2 server programs installed. One server to host Unified Remote and the other server is Jubito. Both are cross-platform which is why I chose them. Jubito has an app, but Unified Remote has a much more robust app allowing for far more functionality. Fortunately, the two go together like milk and honey.

The code to allow a command to be sent to Jubito looks as follows in the Remote Lua file for your custom remote. Please refer to the Unified Remote website for more info on creating a custom remote. You will, of course, need to change my URL to one that correspond to your Jubito settings.

Your URL structure will be - "http://:/" as shown below.

remote.lua Example:

#This refers to the library and must be included in the file
local http = libs.http;

#This is the command being called out. Refer to layout.xml for the final button layout. look for "ontap"

--@help sony volume up
actions.vol_up = function ()
local url = "http://192.168.1.140:5744/SONY_VOLUP";
http.get(url, function (err, resp)
    if (err) then return; end
    print(resp);
end);
end

A guide will be created soon to address the setup in its entirety. This should already be more than enough information for those determined enough to make this work.

[ EDIT ] 2015-12-09 - Here are some pics to give you an idea of what my custom Remote looks like. This remote takes care of all my Media Center IR. I separated a single remote into multiple tabs so that I'm always only 1 tap away from each set of controls. It's logical, fast, and relatively easy to put together. The remote also happens to look great in my opinion. It was fun coming up with the design, colors and customizing individual buttons. For those who are more creative, you can pretty much customize these to whatever degree you see fit.

[ EDIT ] 2016-01-23 - I'm glad to see people are still dropping in to check out the guide once in a while. It's more than I can say for myself lately. I'd still like to get into Guide 2.0, but I can't say when that'll be. Please spread the word about Jubito if you haven't already. Jubito has many uses and deserves more attention within the community. Someday soon I'll be investing my efforts once more.

I salute the community.

I am the author of Jubito and I would like to thank in public IRBlaster2015 for his support and his great work! People like you, make me obliged and deliver the best I can.

New version is available and the web server became more robust. Latest implementation supports json responses.

More info:

http://jubito.org
http://jubitoblog.blogspot.com