// Dezimale / bcd_hex - Anzeige eines Byte
// Mega8 wegen Pincount - Prozessor fast leer :-)
// Anzeige GL-3P402 (dreistellig)
// PortB: Input für Zahl
// PortC: Spaltentreiber gemeinsame Anode (PC0 sind die Einer, PC1 die Zehner usw.)
// PortD: Treiber für Segmente (Kathode). Segment A an PD6 ... Segment G an PD0
// Segmente:  
//     -a-
//   f|   |b
//     -g- 
//   e|   |c
//     -d-
// 
// Stelle 0: rechts, die niederwertigste     
// 25.6.20

#define F_CPU 1e6
#include <avr/io.h>
#include <util/delay.h>

uint8_t s7_table[17] = 
{
// Segmente
//      -abcdefg  // active HIGH codiert
      0b01111110, // 0
			0b00110000, // 1
			0b01101101, // 2
			0b01111001, // 3
			0b00110011, // 4
			0b01011011, // 5
			0b01011111, // 6
			0b01110000, // 7
			0b01111111, // 8
			0b01111011, // 9
			0b01110111, // A
			0b00011111, // b
			0b01001110, // C
			0b00111101, // d
			0b01001111, // E
			0b01000111, // F
			0b00000000  // blank
};

uint8_t ziffern[3];	
uint8_t bcd_hex = 0;

/*************************************************************************************************/
void show_value(void)
{
  uint8_t stelle, segmente, anzahl_stellen;

  anzahl_stellen = 3; // gleiche Helligkei beim Umschalten BCD/Dez

  for (stelle=0; stelle<anzahl_stellen; stelle++)
  {
    segmente = ~s7_table[ziffern[stelle]];  // invertiert wg. Common Anode, Segmente direkt ansteuern

    // hier führende Nullen ausblenden bei Dezimaldarstellung bzw. immer zweistellig anzeigen bei BCD / HEX
    if ((stelle==1) && (ziffern[1]==0) && (ziffern[2] == 0) && !bcd_hex) // beide führenden Stellen sind Null
    {
      segmente = ~s7_table[16]; // active LOW: 0 -> EIN
    }
    if ((stelle==2) && (ziffern[2]==0)) // führende Stelle ist Null
    {
      segmente = ~s7_table[16]; 
    }

    PORTC  = 0xFF;          // common Anode: alles AUS
    PORTD = segmente;       // Segmente für nächste Stelle laden 
    PORTC  = ~(1<<stelle);  // aktuelle Stelle aktivieren, invertiert wg. Common Anode, Spalte über PNP (0 -> EIN)
    _delay_ms(3);           // Multiplex-Leuchtdauer
  }
}

/*************************************************************************************************/
void get_value(void)
{
  uint8_t inverted; // invertierte Darstellung bei STK500 (Gleichlauf mit LEDs)
  uint8_t x; 

  x = PINB;         // Daten einlesen

  // Darstellungsvarianten aufbereiten
  bcd_hex    = PINC & (1<<PINC4);  // Schalter Darstellung DEZ / BCD_HEX
  inverted   = PINC & (1<<PINC5);  // Input invertieren, je nach angelieferter Logik
  if (inverted) x = ~x; 

  if(!bcd_hex)
  { 
    // Zerlegung 0...255 in dezimale Einzelstellen
    ziffern[2] =  x/100 ;
    ziffern[1] = (x - 100*ziffern[2])/10 ; 
    ziffern[0] =  x - 100*ziffern[2] - 10*ziffern[1];
  }
  else 
  {
    // Zerlegung in BCD bzw. HEX
    ziffern[2] = 0; // blank - Null schreiben
    ziffern[1] = (x & 0xF0) >> 4;
    ziffern[0] =  x & 0x0F; 
  }
}

/*************************************************************************************************/
int main()
{

  PORTB = 0xFF; // Pulls
  DDRB  = 0x00; // Input Datenwort für Anzeige

  PORTD = 0xFF; // Start mit HIGH, Segmente sind AUS
  DDRD  = 0xFF; // Output für Segmentansteuerung, 

  PORTC = 0xFF; // Pulls / Start mit HIGH, Spaltentreiber sind aus
  DDRC  = 0x0F; // obere 4 sind Inputs (BCD_HEX/DEZ, invertiert/nichtinvertiert), untere 4 für Anodentreiber über PNP

  while(1)
  {
    get_value();  // hole hier neuen Wert via PORTB
    show_value(); // anzeigen via Multiplex über PORTC (Spalten) und PORTD (7 Segmente)
  }
}