Now that we live in he age of the Internet-of-Things (IOT), I find that these ‘things’ have to communicate to a normal web server at some point.

The problem of course is how best to send data to the server and make sure what was sent is what was received. My preferred method is to use ‘Method GET’ which means that the data is encoded in the URL. It is easy to implement on just about any platform from Arduino UNOs to Arm Cortex processors. Every platform that supports 802.11 or 802.3 will have an example of using ‘Method GET’ to fetch a URL. Which means that the opportunity to send data is as easy as getting a URL.

The next problem is how to send binary data. Since the URL schema has special characters like, ‘”/?& that have meaning you cant just send binary data in the url. To be completely safe in a 7bit ASCII world, one needs to encode that data into some format.

For example if you wanted to send a number of 0x31EAA5 via a URL you could do http://127.0.0.1/?q=3271333 easily enough. That would be converting the number to a integer represented by ASCII characters. This method becomes cumbersome when there are multiple values to send: ?q1=555&q2=444&q3=333&q2=222

My preferred method of late is to send the data as a byte stream. Doing this requires some sort of ASCII armor, such as BASE64 or UUENCODING. Originally I started using base64 which creates GET URLs like: ?q=SSBhbSBEQVRBCg== which decoded on the receiving server would be ‘I am DATA’. But for whatever reason the encoding uses special characters for some data. Namely / and + characters. So a few variants of base64 have sprung up to change these characters to more friendly to URL or other standards.

Not wanting to deal with the hassles of base64. I decided to give base 16 a try as the encoding. This has worked out rather well. Base16 encoding is easy to implement in any language. And many have built in encoders/decoders.

So in the above example of the data being ‘I am DATA’ it would render as

?q=4920616D2044415441

It uses exactly twice as many bytes as the original data, but is perfectly safe to transport binary data. So the sacrifice is size vs safety and ease of implementation. I will almost always chose ease of implementation over any other factor.

On to the code:
Full Examples

Arduino code snippet

char base16[16]={ '0','1','2','3','4', '5','6','7','8', '9','A','B','C', 'D','E','F' };
// this expects byte theData[len] and byte theEncodedData[len*2]
void base16encode()
{
  char b1,b2; // bytes 1 and 2 of the encoded data
  byte ev; // the value to encode
  for (int lop=0; lop<theDataLength; lop++)
  {
    ev=theData[lop]; 
    b1=base16[( (ev>>4) & 0x0F)];
    b2=base16[( (ev) & 0x0F)];
    theEncodedData[(lop*2)]=b1;
    theEncodedData[(lop*2)+1]=b2;
  }
}

PHP snippet

function base16decode($data)
{
  $retv="";
  $base16str="0123456789ABCDEF";
  for ($lop=0; $lop<strlen($data); $lop+=2)
  {
    $oneByte=$data[$lop];
    $twoByte=$data[$lop+1];
    $v1=strpos($base16str,$oneByte);
    $v2=strpos($base16str,$twoByte);
    $theValue=($v1*16)+$v2;
    $av=chr($theValue);
    //echo "ob[$oneByte]tb[$twoByte] v1[$v1]v2[$v2] tv[$theValue] av[$av]| \n";
    $retv.=$av;
  }
  return $retv;
}

These code examples are written with the goal of being easy to read and understand rather than being examples of a good coding style.