float fSzam = -11.5;
char fChr[10];
byte fLen = 0;
byte xByt = 0;
uint32_t dataRead = 0x00000000;
bool a = true;

// Dp.,A,B,C,D,E,F,G
// Dp. => 46
const PROGMEM byte sevSeg[] = {
  B01111110, // - 0 - 48
  B00110000, // - 1 - 49
  B01101101, // - 2 - 50
  B01111001, // - 3 - 51
  B00110011, // - 4 - 52
  B01011011, // - 5 - 53
  B01011111, // - 6 - 54
  B01110000, // - 7 - 55
  B01111111, // - 8 - 56
  B01111011, // - 9 - 57
  B01100110, // - 10 -> A
  B00011111, // - 11 -> b
  B01001110, // - 12 -> C
  B00111101, // - 13 -> d
  B01001111, // - 14 -> E
  B01000111, // - 15 -> F
  B00110111, // - 16 -> H
  B00011101, // - 17 -> o
  B01100111, // - 18 -> P
  B00000101, // - 19 -> r
  B01100011, // - 20 -> fok
  B00000001, // - 21 -> - mínusz - 45
  B00001000, // - 22 -> _
  B00100010  // - 23 -> "
};

void setup() {
  Serial.begin(115200);

}

void loop() {
  Serial.println(dataRead, BIN);
  dataRead = dataRead << 1;
  dataRead = dataRead  | a;
  a = !a;


  Serial.println("----------");
  /*
    Lebegőpontos szám konvertálása karakter sorozattá.
    dtostrf - Double To String Function.
    dtostrf(float_value, min_width, num_digits_after_decimal, where_to_store_string)
  */
  dtostrf(fSzam, 1, 2, fChr);
  Serial.println(fChr);

  fLen = 0;
  // Tárolt szám hosszának meghatározása.
  for (int i = 0; i <= 8; i++) {
    if (fChr[i] > 0) {
      fLen = i + 1;
    }
  }
  Serial.print("Hossz: ");
  Serial.println(fLen);


  // Tárolt szám konvertálása 7 szegmenses kijelzőre.
  // A szám végétő kezdi olvasni, a tizedesvessző miatt.
  for (int i = 0; i <= 7; i++) {
    Serial.print(i);
    Serial.print(". --> ");
    if ((fLen - 1) >= i) {
      xByt = fChr[fLen - i - 1];
    } else {
      xByt = 0; // Karakter kikapcsolása.
    }
    Serial.print(xByt, DEC);
    Serial.print(" -> sevSeg:");

    switch (xByt) {
      case 0:
        // xByt = 0 ; // Karakter kikapcsolása.
        break;
      case 45: // Mínusz
        xByt = pgm_read_byte_near(sevSeg + 21);
        break;
      case 46: // Dp.
        // i = i + 1;
        i++; // A tizedesvessző miatt, a következő digit olvasása.
        xByt = fChr[fLen - i - 1];
        xByt = pgm_read_byte_near(sevSeg + xByt - 48 );
        xByt = xByt | 0x80; // Dp. hozzáfűzése a digithez.
        break;
      default:
        xByt = pgm_read_byte_near(sevSeg + xByt - 48 );
        break;
    }
    Serial.println(xByt, BIN);
  }





  fSzam = fSzam + 0.31;
  if (fSzam > 11) {
    fSzam = -11;
  }
  Serial.println("----------");
  delay(1000);

}



/*
  void loop() {
  Serial.println("----------");
  /*
    dtostrf - Double To String Function.
    dtostrf(float_value, min_width, num_digits_after_decimal, where_to_store_string)

  dtostrf(fSzam, 1, 2, floatStr);
  String xStr = String(floatStr) + "C";
  //xStr = xStr + "#";
  Serial.print(xStr);
  Serial.println("#");
  lenStr = xStr.length();
  Serial.print("Len:");
  Serial.println(lenStr);
  // myString.substring(from, to)
  Serial.println(xStr.substring(lenStr - 1, lenStr));
  Serial.println("----------");
  fSzam = fSzam + 0.33;

  for (int i = 7; i >= 0; i--) {

    Serial.print(i);
    Serial.print(". --> ");

    if (lenStr >= 1) {
      String r = xStr.substring(lenStr - 1, lenStr) ;
      r.toCharArray(charBuf, 1) ;
      Serial.print(charBuf, BIN) //--> gives "1001110"
      /*
        char charBuf[50];
        stringOne.toCharArray(charBuf, 50) ;



      if (r == ".") {
        lenStr = lenStr - 1;
        // Serial.print(78, BIN) --> gives "1001110"
        r = xStr.substring(lenStr - 1, lenStr) + "." ;
      }
      Serial.println(r);
      lenStr = lenStr - 1;
    } else {
      Serial.println("_");
    }


    delay(1000);
  }

  delay(1000);

  }
*/

/*
  byte charToSeg(char ch) {

  byte cTS;

  switch (ch) {
    case "0":
      cTS = pgm_read_byte_near(sevSeg + 0);
      break;
    case "1":
      cTS = pgm_read_byte_near(sevSeg + 1);
      break;
    case "2":
      cTS = pgm_read_byte_near(sevSeg + 2);
      break;
    case "3":
      cTS = pgm_read_byte_near(sevSeg + 3);
      break;
    case "4":
      cTS = pgm_read_byte_near(sevSeg + 4);
      break;
    case "5":
      cTS = pgm_read_byte_near(sevSeg + 5);
      break;
    case "6":
      cTS = pgm_read_byte_near(sevSeg + 6);
      break;
    case "7":
      cTS = pgm_read_byte_near(sevSeg + 7);
      break;
    case "8":
      cTS = pgm_read_byte_near(sevSeg + 8);
      break;
    case "9":
      cTS = pgm_read_byte_near(sevSeg + 9);
      break;
    case "A":
      cTS = pgm_read_byte_near(sevSeg + 10);
      break;
    case "b":
      cTS = pgm_read_byte_near(sevSeg + 11);
      break;
    case "C":
      cTS = pgm_read_byte_near(sevSeg + 12);
      break;







    default:
      cTS = pgm_read_byte_near(sevSeg + 21);
      break;

  }
  return (cTS) ;
  }



  int myFun(  int a )
  {
  return (2 * a) ;
  }


  }
*/