Merge branch 'release/0.1.0'

Author: SloCompTech

.travis.yml

@@ -0,0 +1,12 @@
+language: c
+sudo: false
+before_install:
+  - source <(curl -SLs https://raw.githubusercontent.com/adafruit/travis-ci-arduino/master/install.sh)
+install:
+  - arduino --install-library "ByteConvert"
+script:
+  - build_main_platforms
+notifications:
+  email:
+    on_success: change
+    on_failure: change

README.md

@@ -1 +1,57 @@
-ByteConvert
+# ByteConvert
+[![Build Status](https://travis-ci.org/SloCompTech/ByteConvert_arduino.svg?branch=master)](https://travis-ci.org/SloCompTech/ByteConvert_arduino)
+[![Packagist](https://img.shields.io/packagist/l/doctrine/orm.svg)]()    
+
+## What's about ?
+Have you ever wanted to transmit `int`,`short`,`long`,`double` or any other numeric type over I2C,SPI,serial or other protocol or bus, but you converted variable to string to be able to transmit it char by char. This library enables you to convert any numeric value to bytes or other way around and you can also print array of bytes.
+
+## What you need to consider, when you are using this library
+When you are using this library, you need to consider variable byte size, because if you are using different platform, then there may be some errors, because int on platform 1 has 4 bytes and int on platform 2 has 2 bytes.
+
+## Examples
+Convert numeric variable for eg. `int`,`short`,`float`,`double` to array of bytes.
+``` c++
+int somevar = 5;
+size_t blk_size = 0;
+uint8_t *block = ByteConvert::varToArray<int>(blk_size,somevar);
+
+// Use array
+
+delete block; // Don't forget to free memory, when you don't need array any more
+```
+
+Convert array of bytes to numeric variable.
+``` c++
+uint8_t *block; // Predefined byte array with size of int
+int somevar = ByteConvert::arrayToVar<int>(block);
+
+// Use block & somevar
+
+delete block; // Don't forget to free memory, when you don't need array any more
+
+// Use somevar
+```
+
+Convert array of bytes to string of hex characters
+``` c++
+size_t blk_size; // Predefined size of byte array
+uint8_t *block; // Predefined byte array with size of int
+String somevar = ByteConvert::arrayToString(blk_size,block);
+
+// Use block & somevar
+
+delete block; // Don't forget to free memory, when you don't need array any more
+
+// Use somevar
+```
+
+Convert string of hex characters to array of bytes
+``` c++
+String somevar = ""; // Predefined string
+size_t blk_size = 0; 
+uint8_t *block ByteConvert::stringToArray(blk_size,somevar);
+
+// Use block 
+
+delete block; // Don't forget to free memory, when you don't need array any more
+```

examples/SimpleTest/SimpleTest.ino

@@ -13,20 +13,20 @@ void setup() {
   Serial.println("byteToHexString: fa->"+String(ByteConvert::byteToHexString(0xfa)));
 
   uint8_t array1[] = {0xfa,0xca,0xde,0xda};
-  Serial.println("facadeda -> "+ByteConvert::arrayToString(array1,4));
+  Serial.println("facadeda -> "+ByteConvert::arrayToString(4,array1));
 
   size_t s2 = 0;
   uint8_t *array2 = ByteConvert::stringToArray(s2,"bedababa");
   Serial.println("Size(bedababba): "+String(s2));
-  Serial.println("bedababba -> "+ ByteConvert::arrayToString(array2,s2));
+  Serial.println("bedababba -> "+ ByteConvert::arrayToString(s2,array2));
 
   delete array2;
 
   int in = 5;
   Serial.println("Orig: 5 -> "+String(in));
   size_t s3 = 0;
   uint8_t *array3 = ByteConvert::varToArray<int>(s3,in);
-  Serial.println("? -> "+ ByteConvert::arrayToString(array3,s3));
+  Serial.println("0005 -> "+ ByteConvert::arrayToString(s3,array3));
   Serial.println("5 -> "+ String(ByteConvert::arrayToVar<int>(array3)));
 
   delete array3;

library.properties

@@ -1,10 +1,10 @@
 name=ByteConvert
-version=0.0.1
-author=SloCompTech
-maintainer=SloCompTech <[email protected]>
+version=0.1.0
+author=Martin Dagarin
+maintainer=Martin Dagarin <[email protected]>
 sentence=Library for converting variables to bytes and reverse
 paragraph=Library for converting variables to bytes so they are easyer to transmit via I2C,SPI ...
 category=Communication
-url=None
+url=https://github.com/SloCompTech/ByteConvert_arduino
 architectures=*
 includes=ByteConvert.hpp

src/ByteConvert.cpp

@@ -25,18 +25,20 @@ namespace ByteConvert {
     return 16*hexToVal(block.charAt(0))+hexToVal(block.charAt(1));
   }
 
-  String arrayToString(uint8_t *src,size_t size) {
+  String arrayToString(size_t size,uint8_t *src) {
     String buffer = "";
     for (size_t i = 0;i < (size);i++)
       buffer += byteToHexString(src[i]);
     return buffer;
   }
   uint8_t* stringToArray(size_t &size,String src) {
+    // Length of src must be odd !!
+    if (src.length() % 2 == 1)
+      src = "0" + src;
     size = src.length()/2;
     uint8_t *dst = new uint8_t[size]; // Allocate memory space
     for (size_t i = 0;i < (size);i++)
       dst[i] = hexStringToByte(String(src.charAt(i*2))+String(src.charAt(i*2+1)));
-    Serial.println(arrayToString(dst,size));
     return dst;
   }
 }

src/ByteConvert.hpp

@@ -17,7 +17,7 @@ namespace ByteConvert {
   template<class T>
   uint8_t *varToArray(size_t &size,T var) {
     size = sizeof(T)/sizeof(uint8_t);
-    uint8_t *array = new uint8_t[size];
+    uint8_t *array = new uint8_t[size]; // Alocate memory
     for (size_t i = 0;i < size;i++) {
       if (i != 0) var >>= 8;
       array[size-1-i] = (uint8_t)(var&0xff);
@@ -28,7 +28,7 @@ namespace ByteConvert {
   uint8_t hexToVal(char c);
   String byteToHexString(uint8_t b);
   uint8_t hexStringToByte(String block);
-  String arrayToString(uint8_t *src,size_t size);
+  String arrayToString(size_t size,uint8_t *src);
   uint8_t* stringToArray(size_t &size,String src);
 }