#include "RTClib.h"

RTC_DS1307 rtc;


/*  Max7219 Registers:
    No-Op        = 0x00,
    Digit 0      = 0x01,
    Digit 1      = 0x02,
    Digit 2      = 0x03,
    Digit 3      = 0x04,
    Digit 4      = 0x05,
    Digit 5      = 0x06,
    Digit 6      = 0x07,
    Digit 7      = 0x08,
    Decode Mode  = 0x09,
        No decode for digits 7–0 = 0x00,
        Code B decode for digit 0 No decode for digits 7–1 = 0x01,
        Code B decode for digits 3–0 No decode for digits 7–4 = 0x0F,
        Code B decode for digits 7–0 = 0xFF,
    Intensity    = 0x0A, => min 0x00 to max 0x0F,
    Scan Limit   = 0x0B, => 0x00 to 0x07,
    Shutdown     = 0x0C,
        Shutdown Mode = 0x00,
        Normal Operation = 0x01,
    Display Test = 0x0F,
        Normal Operation = 0x00,
        Display Test Mode = 0x01, all LEDs on
*/

int8_t dataIn = 2;
int8_t load = 3;
int8_t clock = 4;

byte maxInUse = 5;  //change this variable to set how many MAX7219's you'll use
byte xi = 0;
byte yi = 0;

int8_t ev = 0;
int8_t ho = 0;
int8_t nap = 0;

byte ora = 0;
byte perc = 0;
byte mp = 0;
bool dmp = 0;  // kettőspont 0xC0

int8_t kar = 0;
int16_t xint = 0;
byte oszlop = 0;

byte dpmemid = 0;
byte dpmem[40];
/*
  byte dpmem[40] = {
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,};
*/

// Számjegyek 0-9
const PROGMEM byte numset[] = {
  0x7C, 0x8A, 0x92, 0xA2, 0x7C, // '0'
  0x00, 0x42, 0xFE, 0x02, 0x00, // '1'
  0x42, 0x86, 0x8A, 0x92, 0x62, // '2'
  0x44, 0x92, 0x92, 0x92, 0x6C, // '3'
  0xF8, 0x08, 0x08, 0x3E, 0x08, // '4'
  0xF2, 0x92, 0x92, 0x92, 0x8C, // '5'
  0x7C, 0x92, 0x92, 0x92, 0x4C, // '6'
  0xC0, 0x80, 0x86, 0x98, 0xE0, // '7'
  0x6C, 0x92, 0x92, 0x92, 0x6C, // '8'
  0x64, 0x92, 0x92, 0x92, 0x7C  // '9'
};

// 0x02, pont
// 0xC0, aposztróf

void putByte(byte data) {
  byte i = 8;
  byte mask;
  while (i > 0) {
    mask = 0x01 << (i - 1);        // get bitmask
    digitalWrite(clock, LOW);      // tick
    if (data & mask) {             // choose bit
      digitalWrite(dataIn, HIGH);  // send 1
    } else {
      digitalWrite(dataIn, LOW);  // send 0
    }
    digitalWrite(clock, HIGH);  // tock
    --i;                        // move to lesser bit
  }
}

void maxSingle(byte reg, byte col) {
  //maxSingle is the "easy"  function to use for a single max7219

  digitalWrite(load, LOW);  // begin
  putByte(reg);             // specify register
  putByte(col);             //((data & 0x01) * 256) + data >> 1); // put data
  digitalWrite(load, LOW);  // and load da stuff
  digitalWrite(load, HIGH);
}

void maxAll(byte reg, byte col) {  // initialize  all  MAX7219's in the system
  int c = 0;
  digitalWrite(load, LOW);  // begin
  for (c = 1; c <= maxInUse; c++) {
    putByte(reg);  // specify register
    putByte(col);  //((data & 0x01) * 256) + data >> 1); // put data
  }
  digitalWrite(load, LOW);
  digitalWrite(load, HIGH);
}

void maxOne(byte maxNr, byte reg, byte col) {
  //maxOne is for addressing different MAX7219's,
  //while having a couple of them cascaded

  int c = 0;
  digitalWrite(load, LOW);  // begin

  for (c = maxInUse; c > maxNr; c--) {
    putByte(0);  // means no operation
    putByte(0);  // means no operation
  }

  putByte(reg);  // specify register
  putByte(col);  //((data & 0x01) * 256) + data >> 1); // put data

  for (c = maxNr - 1; c >= 1; c--) {
    putByte(0);  // means no operation
    putByte(0);  // means no operation
  }

  digitalWrite(load, LOW);  // and load da stuff
  digitalWrite(load, HIGH);
}

void wrdisplay(byte oidx, byte data) {
  byte maxidx = 0;
  byte regidx = 0;
  maxidx = maxInUse - oidx / 8;
  regidx = oidx % 8 + 1; // mod
  maxOne(maxidx, regidx, data);
}

void wrchar() {
  byte xkar = 0; // Karakter 1 oszlopa.
  byte xreg = 0; // Max regiszter index.
  //byte xmax = 0; // Max számláló.
  //byte xmem = 0; // Dp memória adata
  //bool xbit = 0;
  //byte xbitid = 0;

  /*
    Serial.print("kar: ");
    Serial.println(kar);
  */

  for (xi = 0; xi <= 4; xi++) {
    // xmax = oszlop / 8;
    // xbitid = oszlop % 8;  // mod
    xkar = kar * 5 + xi;
    xkar = pgm_read_byte_near(numset + xkar);
    wrreg(xkar);
    /*
      for (yi = 0; yi <= 7; yi++) {
      xreg = yi + xmax * 8;
      xmem = dpmem[xreg];
      xbit = bitRead(xkar, 7 - yi);
      bitWrite(xmem, xbitid, xbit);
      dpmem[xreg] = xmem;
      /*
        Serial.print("xi:");
        Serial.print(xi);
        Serial.print(" yi:");
        Serial.print(yi);
        Serial.print(" Reg:");
        Serial.print(xreg + 1);
        Serial.print(" => ");
        Serial.println(dpmem[xreg], BIN);
    */
    //maxOne(5, xreg + 1, dpmem[xreg]);
  };
  //oszlop = ++oszlop;


  //oszlop = ++oszlop; // karakter elválasztó.

  /*
    Serial.print("Oszlop: ");
    Serial.println(oszlop);
  */
}





/*

    Serial.print("0x");
    Serial.println(karidx, HEX);
    wrdisplay(oszlop, karidx);
    oszlop = ++oszlop;
*/



//wrdisplay(oszlop, 0x00); /
//oszlop = oszlop + 1;  // oszlop kihagyása, azaz üres

void wrreg(byte adat) {

  byte xreg = 0; // Max regiszter index.
  byte xmem = 0; // Dp memória adata
  bool xbit = 0;
  /*
    Serial.print("Adat: 0x");
    Serial.println(adat, HEX);
  */
  byte xmax = oszlop / 8;
  byte xbitid = oszlop % 8;  // mod

  for (yi = 0; yi <= 7; yi++) {
    xreg = yi + xmax * 8;
    xmem = dpmem[xreg];
    xbit = bitRead(adat, 7 - yi);
    bitWrite(xmem, xbitid, xbit);
    dpmem[xreg] = xmem;
  }
  oszlop = ++oszlop;
  /*
    Serial.print("Oszlop: ");
    Serial.println(oszlop);
  */
}

void dptime() {

  oszlop = 0;  // oszlop nullázása.
  kar = ora / 10;
  if (kar == 0) {
    oszlop = 5;
  }
  else {
    wrchar();
  }
  oszlop = ++oszlop; // oszlop kihagyása, azaz üres

  kar = ora % 10;  // mod
  wrchar();
  oszlop = ++oszlop;        // oszlop kihagyása, azaz üres
  oszlop = ++oszlop;        // oszlop kihagyása, azaz üres
  oszlop = ++oszlop; // oszlop kihagyása, azaz üres

  kar = perc / 10;
  wrchar();
  oszlop = ++oszlop; // oszlop kihagyása, azaz üres
  kar = perc % 10;  // mod
  wrchar();
  oszlop = ++oszlop; // oszlop kihagyása, azaz üres
  wrreg(0xC0);
  oszlop = ++oszlop; // oszlop kihagyása, azaz üres

  kar = mp / 10;
  wrchar();
  oszlop = ++oszlop; // oszlop kihagyása, azaz üres
  kar = mp % 10;  // mod
  wrchar();

}

void wrdisp() {
  for (yi = 0; yi <= 4; yi++) {
    for (xi = 0; xi <= 7; xi++) {
      dpmemid = yi * 8 + xi;
      maxOne(5 - yi, xi + 1, dpmem[dpmemid]);
    }
  }
}



void setup() {
  pinMode(dataIn, OUTPUT);
  pinMode(clock, OUTPUT);
  pinMode(load, OUTPUT);
  Serial.begin(115200);

  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    Serial.flush();
    abort();
  }
  //initiation of the max 7219
  /*
    maxAll(0x0B, 0x07);  // Scan Limit = 0x0B,
    maxAll(0x09, 0x00);  // Decode Mode = 0x09, using an led matrix (not digits)
    maxAll(0x0C, 0x01);  // Shutdown = 0x0C, Normal Operation = 0x01,
    maxAll(0x0A, 0x0F);  // Intensity = 0x0A,
    maxAll(0x0F, 0x01);  // Display Test = 0x0F, Display Test Mode = 0x01, all LEDs on
    delay(1000);         // milliseconds
    maxAll(0x0F, 0x00);  // Display Test = 0x0F, Normal Operation = 0x00,
  */

  /*
    for (xi = 1; xi <= 8; xi++) {  // empty registers, turn all LEDs off
      maxOne(5, 1, 0x81);
      maxOne(5, 7, 0x81);
    }
  */
  /*
    for (yi = 0; yi <= 7 ; yi++) {
    for (xi = 0; xi <= maxInUse * 8 - 1; xi++) {

        Serial.print("Mem x:");
        Serial.println(xi);
        Serial.print("Mem y:");
        Serial.println(yi);

    dpmemid = xi + yi * maxInUse * 8;

    Serial.print("Mem id:");
    Serial.println(dpmemid);

    dpmem[dpmemid] = 0;
    }
    }
  */
  //Serial.println("Mem id:");
  // bp memória feltöltése...


  for (yi = 0; yi <= 7; yi++) {
    for (xi = 0; xi <= maxInUse - 1; xi++) {
      dpmemid = xi * 8 + yi;
      dpmem[dpmemid] = 0x00;
      //Serial.println(dpmemid);
    }
  }

  Serial.print("Mem id:");
  Serial.println(dpmemid);
  Serial.println(8 * maxInUse - 1);
  Serial.println("----------");

  DateTime now = rtc.now();
  ev = now.year() % 1000;
  ho = now.month();
  nap = now.day();

  oszlop = 0;  // oszlop nullázása.
  kar = ev / 10;
  if (kar == 0) {
    oszlop = 5;
  }
  else {
    wrchar();
  }
  oszlop = ++oszlop; // oszlop kihagyása, azaz üres

  kar = ev % 10;  // mod
  wrchar();
  oszlop = ++oszlop;        // oszlop kihagyása, azaz üres
  wrreg(0x02);
  oszlop = ++oszlop; // oszlop kihagyása, azaz üres

  kar = ho / 10;
  wrchar();
  oszlop = ++oszlop; // oszlop kihagyása, azaz üres
  kar = ho % 10;  // mod
  wrchar();
  oszlop = ++oszlop; // oszlop kihagyása, azaz üres
  wrreg(0x02);
  oszlop = ++oszlop; // oszlop kihagyása, azaz üres

  kar = nap / 10;
  wrchar();
  oszlop = ++oszlop; // oszlop kihagyása, azaz üres
  kar = nap % 10;  // mod
  wrchar();


  wrdisp();
  /*
    for (yi = 0; yi <= 4; yi++) {
    for (xi = 0; xi <= 7; xi++) {
      dpmemid = yi * 8 + xi;
              Serial.print(dpmemid);
        Serial.print(": 0x");
        Serial.println(dpmem[dpmemid], BIN);

      maxOne(5 - yi, xi + 1, dpmem[dpmemid]);
    }
    }
  */
  delay(2000);

  for (yi = 0; yi <= 7; yi++) {
    for (xi = 0; xi <= maxInUse - 1; xi++) {
      dpmemid = xi * 8 + yi;
      dpmem[dpmemid] = 0x00;
      //Serial.println(dpmemid);
    }
  }


  oszlop = 26;
  wrreg(0xC0);
}

void loop() {
  DateTime now = rtc.now();
  ora = now.hour();
  perc = now.minute();
  Serial.println(perc);
  if (mp == now.second()) {
    dmp = 0;
  }
  else {
    mp = now.second();
  }
  dptime();




  oszlop = 12;
  kar = 0x24;
  if (dmp == 0) {
    kar ^= kar;
  }
  dmp = !dmp;

  wrreg(kar);

  wrdisp();
  /*
    for (yi = 0; yi <= 4; yi++) {
      for (xi = 0; xi <= 7; xi++) {
        dpmemid = yi * 8 + xi;
        maxOne(5 - yi, xi + 1, dpmem[dpmemid]);
      }
    }
  */

  delay(500);
}