First version

Author: SloCompTech

examples/SimpleTest/SimpleTest.ino

@@ -0,0 +1,37 @@
+#include <ByteConvert.hpp>
+
+void setup() {
+  Serial.begin(9600);
+  Serial.println("Simple test");
+  Serial.println("size(short): "+String(sizeof(short)));
+  Serial.println("size(int): "+String(sizeof(int)));
+  Serial.println("size(float): "+String(sizeof(float)));
+  Serial.println("size(char): "+String(sizeof(char)));
+  Serial.println("size(uint8_t): "+String(sizeof(uint8_t)));
+  Serial.println("valToHex: 9->"+String(ByteConvert::valToHex(0x09)));
+  Serial.println("valToHex: b->"+String(ByteConvert::valToHex(0x0b)));
+  Serial.println("byteToHexString: fa->"+String(ByteConvert::byteToHexString(0xfa)));
+
+  uint8_t array1[] = {0xfa,0xca,0xde,0xda};
+  Serial.println("facadeda -> "+ByteConvert::arrayToString(array1,4));
+
+  size_t s2 = 0;
+  uint8_t *array2 = ByteConvert::stringToArray(s2,"bedababa");
+  Serial.println("Size(bedababba): "+String(s2));
+  Serial.println("bedababba -> "+ ByteConvert::arrayToString(array2,s2));
+
+  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("5 -> "+ String(ByteConvert::arrayToVar<int>(array3)));
+
+  delete array3;
+}
+
+void loop() {
+
+}

keywords.txt

@@ -0,0 +1,10 @@
+name=ByteConvert
+version=0.0.1
+author=SloCompTech
+maintainer=SloCompTech <SloCompTech@gmail.com>
+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
+architectures=*
+includes=ByteConvert.hpp

library.properties

@@ -0,0 +1,42 @@
+#include "ByteConvert.hpp"
+namespace ByteConvert {
+  char valToHex(uint8_t val) {
+    if ((val & 0x0f) < 10)
+      return ('0' + val);
+    else
+      return ('a' + (val - 10));
+  }
+  uint8_t hexToVal(char c) {
+    if (c >= 'a')
+      return (15 - ('f' - c));
+    else
+      return (9 - ('9' - c));
+  }
+  String byteToHexString(uint8_t b) {
+    String buffer = "";
+    buffer += valToHex(b & 0x0f);
+    b >>= 4;
+    buffer = valToHex(b & 0x0f) + buffer;
+    return buffer;
+  }
+  uint8_t hexStringToByte(String block) {
+    if (block.length() != 2)
+      return 0x00;
+    return 16*hexToVal(block.charAt(0))+hexToVal(block.charAt(1));
+  }
+
+  String arrayToString(uint8_t *src,size_t size) {
+    String buffer = "";
+    for (size_t i = 0;i < (size);i++)
+      buffer += byteToHexString(src[i]);
+    return buffer;
+  }
+  uint8_t* stringToArray(size_t &size,String 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.cpp

@@ -0,0 +1,35 @@
+#ifndef _ByteConvert_hpp_
+#define _ByteConvert_hpp_
+
+#include "Arduino.h"
+
+namespace ByteConvert {
+  template<class T>
+  T arrayToVar(uint8_t *array) {
+    size_t size = sizeof(T)/sizeof(uint8_t);
+    T var = 0x00;
+    for (size_t i = 0;i < (size);i++) {
+      if (i != 0) var <<= 8;
+      var |= array[i];
+    }
+    return var;
+  }
+  template<class T>
+  uint8_t *varToArray(size_t &size,T var) {
+    size = sizeof(T)/sizeof(uint8_t);
+    uint8_t *array = new uint8_t[size];
+    for (size_t i = 0;i < size;i++) {
+      if (i != 0) var >>= 8;
+      array[size-1-i] = (uint8_t)(var&0xff);
+    }
+    return array;
+  }
+  char valToHex(uint8_t val);
+  uint8_t hexToVal(char c);
+  String byteToHexString(uint8_t b);
+  uint8_t hexStringToByte(String block);
+  String arrayToString(uint8_t *src,size_t size);
+  uint8_t* stringToArray(size_t &size,String src);
+}
+
+#endif