/*
  MIT License
  Copyright (c) 2022 MicroBeaut
*/

/*
  AuCP_SevenSegment.ino
  Created: 5/4/2022 09:09:09 AM
  Author: MicroBeaut
*/

/*
  const uint8_t numberOfDigits = 8;    // DIG00 TO DIG07
  const uint8_t numberOfSegments = 8;  // SEG-A TO SEG-DP

   DIG07       DIG06       DIG05      DIG04      DIG03      DIG02        DIG01      DIG00

   AAAAA      AAAAA        AAAAA      AAAAA      AAAAA      AAAAA        AAAAA      AAAAA
  F     B    F     B      F     B    F     B    F     B    F     B      F     B    F     B
  F     B    F     B  CL  F     B    F     B    F     B    F     B  CL  F     B    F     B
  F     B    F     B      F     B    F     B    F     B    F     B      F     B    F     B
   GGGGG      GGGGG        GGGGG      GGGGG      GGGGG      GGGGG        GGGGG      GGGGG
  E     C    E     C      E     C    E     C    E     C    E     C      E     C    E     C
  E     C    E     C  CL  E     C    E     C    E     C    E     C  CL  E     C    E     C
  E     C    E     C      E     C    E     C    E     C    E     C      E     C    E     C
   DDDDD dp   DDDDD dp     DDDDD dp   DDDDD dp   DDDDD dp   DDDDD dp     DDDDD dp   DDDDD dp


  Declaration:
  sevenSegment sevenSegment(numberOfDigits, numberOfSegments);
  const uint8_t digitPins[] = {dig00, dig01, dig02, dig03, dig04, dig05, dig06, dig07};
  const uint8_t segmentPins[] = {segA, segB, segC, segD, segE, segF, segG, segDP};
  const unit8_t colonPin = COLON;

  Setup:
  sevenSegment.DigitPins(digitPins);
  sevenSegment.SegmentPins(segmentPins);
  sevenSegment.ColonPins(colonPin);
*/

/*
  const uint8_t numberOfBars = 2;       // BAR-0 TO BAR-1
  const uint8_t numberOfSegments = 10;  // SEG-00 TO SEG-10

   BAR07     BAR06     BAR05     BAR04     BAR03     BAR02     BAR01     BAR00

  SEG-09    SEG-09    SEG-09    SEG-09    SEG-09    SEG-09    SEG-09    SEG-09
  SEG-08    SEG-08    SEG-08    SEG-08    SEG-08    SEG-08    SEG-08    SEG-08
  SEG-07    SEG-07    SEG-07    SEG-07    SEG-07    SEG-07    SEG-07    SEG-07
  SEG-06    SEG-06    SEG-06    SEG-06    SEG-06    SEG-06    SEG-06    SEG-06
  SEG-05    SEG-05    SEG-06    SEG-06    SEG-06    SEG-06    SEG-06    SEG-06
  SEG-04    SEG-04    SEG-04    SEG-04    SEG-04    SEG-04    SEG-04    SEG-04
  SEG-03    SEG-03    SEG-03    SEG-03    SEG-03    SEG-03    SEG-03    SEG-03
  SEG-02    SEG-02    SEG-02    SEG-02    SEG-02    SEG-02    SEG-02    SEG-02
  SEG-01    SEG-01    SEG-01    SEG-01    SEG-01    SEG-01    SEG-01    SEG-01
  SEG-00    SEG-00    SEG-00    SEG-00    SEG-00    SEG-00    SEG-00    SEG-00


  Declaration:
    sevenSegment barSegment(numberOfBars, numberOfSegments);
    const uint8_t digitPins[] = {bar00, bar01, bar02, bar03, bar04, bar05, bar06, bar07};
    const uint8_t segmentPins[] = {seg00, seg01, seg02, seg03, seg04, seg05, seg06, seg07, seg08, seg09};

  Setup:
    barSegment.DigitPins(digitPins);
    barSegment.SegmentPins(segmentPins);
*/

#include "LEDMatrix.h"

#define aPin 11
#define bPin 9
#define cPin 4
#define dPin 6
#define ePin 7
#define fPin 10
#define gPin 3
#define dpPin 5

#define digit0Pin 25
#define digit1Pin 26
#define digit2Pin 27
#define digit3Pin 28
#define digit4Pin 24
#define digit5Pin 29
#define digit6Pin 30
#define digit7Pin 31
#define digit8Pin 23
#define digit9Pin 32
#define digit10Pin 33
#define digit11Pin 34
#define digit12Pin 22
#define digit13Pin 35
#define digit14Pin 36
#define digit15Pin 37

#define colonPin 8

const CommonModes commonMode = cathode;

const uint8_t numberOfSegments = 8;
const uint8_t segmentPins[8] = {aPin, bPin, cPin, dPin, ePin, fPin, gPin, dpPin};

const uint8_t numberOfDigits = 16;
const uint8_t digitPins[16] = {digit0Pin, digit1Pin, digit2Pin, digit3Pin,
                               digit4Pin, digit5Pin, digit6Pin, digit7Pin,
                               digit8Pin, digit9Pin, digit10Pin, digit11Pin,
                               digit12Pin, digit13Pin, digit14Pin, digit15Pin
                              };


LEDMatrix ledMatrix(numberOfDigits, numberOfSegments, digitPins, segmentPins, cathode);

#define scanLimitAinPin A0
#define dpAinPin A1

const uint8_t segmentCode[16] = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07,
                                 0x7F, 0x6F, 0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71
                                };


time_t startTime;
time_t interval;
uint8_t index;

void setup() {
  Serial.begin(115200);
  startTime = micros();
  interval = 1000000UL;
  index = 0;
  ledMatrix.decodeMode(0xFFFF);
  for (index_t index = 0; index < numberOfDigits; index++) {
    ledMatrix.write(numberOfDigits - index - 1, index);
  }
  //ledMatrix.write(0xff, 0);
  ledMatrix.decimalPoint(0, false);
}

void loop() {
  static long prevScanLimit;
  static long prevDPValue;
  long ainValue = analogRead(scanLimitAinPin);
  long scanlimit = map(ainValue, 0, 1023, 0, numberOfDigits);
  ledMatrix.scanLimit(scanlimit);

  long dpAinValue = analogRead(dpAinPin);
  long dpValue = map(dpAinValue, 0, 1023, -1, numberOfDigits + 1);

  if (dpValue != prevDPValue) {
    for (index_t index = 0; index < numberOfDigits; index++) {
      if (index <= dpValue) {
        ledMatrix.decimalPoint(index, true);
      } else {
        ledMatrix.decimalPoint(index, false);
      }
    }
  }
  prevDPValue = dpValue;
  prevScanLimit = scanlimit;
  if (micros() - startTime >= interval) {
    static uint8_t prevValue = segmentCode[index];
    startTime = micros();
    index = (index + 1) % 16;
    Serial.println(ledMatrix.deltaT());
  }
  ledMatrix.refresh();
}