//Diego Rodríguez González 
//Ingeniería electromecánica 302

const byte Segments[] =
{
  0b01111110, // 0 - segmentos: a,b,c,d,e,f
  0b00110000, // 1 - segmentos: b,c  
  0b01101101, // 2 - segmentos: a,b,d,e,g
  0b01111001, // 3 - segmentos: a,b,c,d,g
  0b00110011, // 4 - segmentos: b,c,f,g
  0b01011011, // 5 - segmentos: a,c,d,f,g
  0b01011111, // 6 - segmentos: a,c,d,e,f,g
  0b01110000, // 7 - segmentos: a,b,c
  0b01111111, // 8 - todos los segmentos
  0b01111011  // 9 - segmentos: a,b,c,d,f,g
};

const byte DigitCount = 4;
const byte DigitPins[DigitCount] = {13, 12, 11, 10};

const byte SegmentCount = 7;
const unsigned char SegmentPins[SegmentCount] = {2, 3, 4, 5, 6, 7, 8};

void setup()
{
  for (int i = 0; i < DigitCount; i++)
  {
    pinMode(DigitPins[i], OUTPUT);
    digitalWrite(DigitPins[i], HIGH);
  }

  for (int i = 0; i < SegmentCount; i++)
  {
    pinMode(SegmentPins[i], OUTPUT);
    digitalWrite(SegmentPins[i], LOW);
  }
}

void loop()
{
  int rawValue = analogRead(A0);
  int scaledValue = map(rawValue, 0, 1023, 0, 1000);
  if (scaledValue > 1000) scaledValue = 1000;
  int value = scaledValue;

  for (int i = 0; i < DigitCount; i++)
  {
    for (int d = 0; d < DigitCount; d++)
    {
      digitalWrite(DigitPins[d], HIGH);
    }
    
    for (int s = 0; s < SegmentCount; s++)
    {
      digitalWrite(SegmentPins[s], LOW);
    }

    int digit;
    switch(i) {
      case 0:
        digit = value % 10;
        break;
      case 1:
        digit = (value / 10) % 10;
        break;
      case 2:
        digit = (value / 100) % 10;
        break;
      case 3:
        digit = value / 1000;
        break;
      default:
        digit = 0;
    }

    if (!(i == 3 && value < 1000)) {
      unsigned char segments = Segments[digit];
      for (int s = 0; s < SegmentCount; s++)
      {
        bool segmentOn = (segments >> (6 - s)) & 0x01;
        digitalWrite(SegmentPins[s], segmentOn ? HIGH : LOW);
      }
    }

    digitalWrite(DigitPins[i], LOW);
    delay(5);
    digitalWrite(DigitPins[i], HIGH);
  }
}