void setup() {
  // put your setup code here, to run once:
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(9600);
  Serial.setTimeout(100);
  Serial.println("\tSTART");
  int32_t value = 1000000000L;
  uint8_t bits = 32;
  Serial.println("intToHexStr1:\t"  +   intToHexStr1(value, bits));
  Serial.println("intToHexStr2:\t"  +   intToHexStr2(value, bits));
  Serial.println("intToHexStr3:\t"  +   intToHexStr3(value, bits));
  Serial.println("intToHexStr:\t"   +   intToHexStr(value, bits));
  Serial.println("BitVector:\t"     +   byteToBitStr(45));
  uint8_t bytes[4] = {0x3B, 0xF0, 0x0F, 0x4C};
  int32_t calcVal = bytesToInt(bytes, sizeof(bytes));
  Serial.println("BytesToInt:\t"    +   String(calcVal));
  Serial.println("BytesToStr:\t"    +   bytesToStr(bytes, sizeof(bytes)));
  intToBytes(calcVal, bytes, sizeof(bytes));
  Serial.println("Recalced:\t"      +   bytesToStr(bytes, sizeof(bytes)));
  reverseBytesOrder(bytes, sizeof(bytes));
  Serial.println("Reversed:\t"      +   bytesToStr(bytes, sizeof(bytes)));
  uint8_t bb[10] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09};
  insertToArray(bb, 200500800UL, 4, 4);
  Serial.println("Inserted:\t"      +   bytesToStr(bb, sizeof(bb)));
  uint8_t crc[2] = {0xC1, 0xC2};
  insertToArray(bb, crc, 2, 8);
  Serial.println("CRC added:\t"     +   bytesToStr(bb, sizeof(bb)));
  String data = "FF07A3C2";
  Serial.println("HexStrToInt:\t"   +   String(hexStrToInt(data, 0, 8)));
  data = "200922";
  Serial.flush();
  Serial.println("DecStrToInt:\t"   +   String(decStrToInt(data, 0, 8)));
  Serial.println("IsBigEndian:\t"   +   String(isBigEndianSystem()));
  char ca[15];
  strToCharArray("Hello", ca);
  data = ca;
  Serial.println(data);
  char c = 120;
  uint8_t b = 120;
  Serial.println(charToByte(c));
  Serial.println(byteToChar(b));
  uint8_t flags[8] = {0, 1, 1, 0, 1, 0, 0, 1};
  b = flagsToByte(flags, true);
  Serial.println(b);
  Serial.println("ArrToBits:\t"     +   byteToBitStr(b));
  b = flagsToByte(flags);
  Serial.println(b);
  Serial.println("ArrToBits:\t"     +   byteToBitStr(b));
  b = bitStrToByte("01011", true);
  Serial.println("BitStrToByte:\t"  +   byteToBitStr(b));
  b = bitStrToByte("01011", false);
  Serial.println("BitStrToByte:\t"  +   byteToBitStr(b));
  Serial.println("BitSetHigh:\t"    +   byteToBitStr(setBitHighUpdate(b, 0)));
  Serial.println("BitStrToByte:\t"  +   byteToBitStr(b));
  Serial.println("BitSet:    \t"    +   byteToBitStr(setBit(b, 2, 1)));
  Serial.println("BitStrToByte:\t"  +   byteToBitStr(b));
}

void loop() {
  // put your main code here, to run repeatedly:
  digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  delay(250);
}

uint32_t bytesToInt(uint8_t inData[], uint8_t length) {
  uint32_t result = 0;
  for (uint32_t i = 0; i < length; i++) {
    result += (uint32_t)inData[length-1-i] << 8*i;
  }
  return result;
}

void intToBytes(int32_t value, uint8_t outArr[], uint8_t length) {
  for (uint32_t i = 0; i < length; i++) {
    outArr[length - 1 - i] = (value >> (i*8)) & 0xff;
  }
}

String bytesToStr(uint8_t arr[], uint32_t length) {
  uint8_t len = length * 2;
  String str;
  for (uint32_t i = 0; i < length; i++) {
    char cc[4];
    ltoa(arr[i], cc, HEX);
    if (cc[0] < '0') cc[0] = '0';
    if (cc[1] < '0') {
      cc[1] = cc[0];
      cc[0] = '0';
    }
    //Serial.println(String(i) + ": " + String(arr[i],HEX) + " " + cc[0] + cc[1]);
    str += cc[0];
    str += cc[1];
  }
  str.toUpperCase();
  while (str.length() > len) str = str.substring(1);
  while (str.length() < len) str = "0" + str;
  return str;
}

String byteToBitStr(int8_t value) {
  static char b[9];
  b[0] = '\0';
  for (uint8_t i = 128; i > 0; i >>= 1) {
    strcat(b, ((value & i) == i) ? "1" : "0");
  }
  String str = b;
  return str;
}

uint8_t flagsToByte(uint8_t flags[]) {
  return flagsToByte(flags, false);
}

//HEX-string to integer converter
int32_t hexStrToInt(String dataString, uint32_t startIndex, uint8_t len) {
  const uint8_t BASE_LENGTH = 8;
  dataString = dataString.substring(startIndex, len);
  while (dataString.length() < BASE_LENGTH) dataString = "0" + dataString;
  char data[BASE_LENGTH];
  dataString.toCharArray(data, BASE_LENGTH + 1);
  int32_t result = strtoul(data, 0, HEX);
  return result;
}

//DEC-string to integer converter
int32_t decStrToInt(String dataString, uint32_t startIndex, uint8_t len) {
  const uint8_t BASE_LENGTH = 8;
  dataString = dataString.substring(startIndex, len);
  while (dataString.length() < BASE_LENGTH) dataString = "0" + dataString;
  char data[BASE_LENGTH];
  dataString.toCharArray(data, BASE_LENGTH + 1);
  int32_t result = strtoul(data, 0, DEC);
  return result;
}

//Integer to DEC-string converter
String intToStr(int32_t value) {
  return String(value, DEC);
}

/*private*/ String intToHexStr1(int32_t value, uint8_t bits) {
  if (bits == 0 || bits > 32 || bits % 8 != 0) bits = 32;
  uint8_t len = bits/4;
  char cc[4];
  const char* tl = "%04X";
  sprintf(cc, tl, value);
  String str = cc;
  if (value > 0xFFFF || value < 0) {
    sprintf(cc, tl, value >> 16);
    str = cc + str;
  }
  while (str.length() < len) str = '0' + str;
  if (str.length() > len) {
    str = str.substring(str.length() - 0 - len);
  }
  return str;
}

/*private*/ String intToHexStr2(int32_t value, uint8_t bits) {
  if (bits == 0 || bits > 32 || bits % 8 != 0) bits = 32;
  const uint8_t len = bits/4;
  char cc[8];
  ltoa(value, cc, HEX);
  String str = cc;
  while (str.length() < len) str = '0' + str;
  if (str.length() > len) {
    str = str.substring(str.length() - 0 - len);
  }
  str.toUpperCase();
  return str;
}

//Integer to HEX-string converter
String intToHexStr(int32_t value, uint8_t bits) {
  const int32_t maxVal = (1UL << bits) - 1 ;
  String result;
  if (bits >= 32 || (value >= 0xFF && value < maxVal)) {
    result = intToHexStr1(value, bits);
  } else {
    result = intToHexStr2(value, bits);
  }
  return result;
}

String intToHexStr3(int32_t value, uint8_t bits) {
  if (bits == 0 || bits > 32 || bits % 8 != 0) bits = 32;
  const uint8_t len = bits/8;
  uint8_t cc[len];
  intToBytes(value, cc, len);
  String str = bytesToStr(cc, len);
  return str;
}

//Reversing byte order (swap endianness)
void reverseBytesOrder(uint8_t arr[], uint32_t length) {
  for (int i = 0; i <= length / 2 - 1; i++) {
    uint8_t temp = arr[i];
    arr[i] = arr[length-1-i];
    arr[length-1-i] = temp;
  }
}

//Insert array to array
void insertToArray(uint8_t outArr[], uint8_t valueArr[], uint32_t length, uint32_t index) {
  for (uint32_t i = 0; i < length; i++) {
    outArr[index + i] = valueArr[i];
  }
}

//Insert integer to array
void insertToArray(uint8_t outArr[], int32_t value, uint32_t length, uint32_t index) {
  uint8_t valueArr[length];
  intToBytes(value, valueArr, length);
  insertToArray(outArr, valueArr, length, index);
}

//Check if machine using big endian byte order
bool isBigEndianSystem() {
  uint16_t x = 0x0001;
  return *((uint8_t *) &x) ? false : true;
}

//Convert string to array of chars
void strToCharArray(String source, char outArr[]) {
  uint32_t len = source.length();
  char cc[len];
  source.toCharArray(cc, len + 1);
  for (uint32_t i = 0; i < len; i++) {
    outArr[i] = cc[i];
  }
}

//Convert byte to char
char byteToChar(uint8_t b) { return b; }

//Convert char to byte
uint8_t charToByte(char c) { return c; }

//Convert array of bit values to byte
uint8_t flagsToByte(uint8_t flags[], bool isReversed) {
  uint8_t result = 0;
  for (uint8_t i = 0; i < 8; i++) {
    uint8_t idx = (isReversed) ? 7-i : i;
    bitWrite(result, i, flags[idx]); 
  }
  return result;
}

//Convert bit vector string to byte
uint8_t bitStrToByte(String bitStr, bool isReversed) {
  const uint8_t zero = '0';
  uint8_t result = 0;
  for (uint8_t i = 0; i < 8 && i < bitStr.length(); i++) {
    uint8_t idx = (isReversed) ? bitStr.length()-1-i : i;
    bitWrite(result, i, bitStr[idx]-zero);
  }
  return result;
}

//Get bit at position of byte
bool getBit(uint8_t value, uint8_t index) {
  return ((value) >> (index)) & 0x01;
}

//Set bit of byte to low value without byte updating
uint8_t setBitLow(uint8_t target, uint8_t index) {
  return (target) &= ~(1UL << (index));
}

//Set bit of byte to low value with byte updating
uint8_t setBitLowUpdate(uint8_t &target, uint8_t index) {
  return (target) &= ~(1UL << (index));
}

//Set bit of byte to high without byte updating
uint8_t setBitHigh(uint8_t target, uint8_t index) {
  return ((target) |= (1UL << (index)));
}

//Set bit of byte to high value with byte updating
uint8_t setBitHighUpdate(uint8_t &target, uint8_t index) {
  return ((target) |= (1UL << (index)));
}

//Set bit of byte to new value without byte updating
uint8_t setBit(uint8_t target, uint8_t index, bool value) {
  return (value) ? setBitHigh(target, index) : setBitLow(target, index);
}

//Set bit of byte to new value with byte updating
uint8_t setBitUpdate(uint8_t &target, uint8_t index, bool value) {
  return (value) ? setBitHighUpdate(target, index) : setBitLowUpdate(target, index);
}