/********************************************************************************************/
/*                                                                                          */
/*     Programm:          Cynetik                                                           */
/*                                                                                          */
/*                                                                                          */
/*     Autor:             Constantin Alexandru Mauro                                        */
/*                                                                                          */
/*     Zielsystem:        Cynetik Mainboard, Prozessor: Atmega8535                          */
/*     IDE/C-Compiler:    AVR Studio 4                                                      */
/*                                                                                          */
/*     Letzte Änderung:   01.11.2015                                                        */
/*                                                                                          */
/*     Datei:             Cynetik.c                                                         */
/*                                                                                          */
/********************************************************************************************/

// Defines

#define F_CPU 4096000L
#define F_PWM         100L               // PWM-Frequenz in Hz
#define PWM_PRESCALER 8                  // Vorteiler für den Timer
#define PWM_STEPS     256                // PWM-Schritte pro Zyklus(1..256)
#define PWM_PORT      PORTD              // Port für PWM
#define PWM_DDR       DDRD               // Datenrichtungsregister für PWM
#define PWM_CHANNELS  8                  // Anzahl der PWM-Kanäle
#define T_PWM (F_CPU/(PWM_PRESCALER*F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt
#define max7219_PORT PORTB
#define max7219_DDR DDRB
#define max7219_CLK PB7
#define max7219_LOAD PB6
#define max7219_DIN PB5
#define PD3 3

#if ((T_PWM*PWM_PRESCALER)<(111+5))
    #error T_PWM zu klein, F_CPU muss vergrössert werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif

#if ((T_PWM*PWM_STEPS)>65535)
    #error Periodendauer der PWM zu gross! F_PWM oder PWM_PRESCALER erhöhen.
#endif

// Includes

#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <avr/interrupt.h>

// globale Variablen

uint8_t out;

uint16_t pwm_timing[PWM_CHANNELS+1];          // Zeitdifferenzen der PWM Werte
uint16_t pwm_timing_tmp[PWM_CHANNELS+1];

uint8_t  pwm_mask[PWM_CHANNELS+1];            // Bitmaske für PWM Bits, welche gelöscht werden sollen
uint8_t  pwm_mask_tmp[PWM_CHANNELS+1];        // ändern uint16_t oder uint32_t für mehr Kanäle

uint8_t  pwm_setting[PWM_CHANNELS];           // Einstellungen für die einzelnen PWM-Kanäle
uint8_t  pwm_setting_tmp[PWM_CHANNELS+1];     // Einstellungen der PWM Werte, sortiert
                                              // ändern auf uint16_t für mehr als 8 Bit Auflösung
volatile uint8_t pwm_cnt_max=1;               // Zählergrenze, Initialisierung mit 1 ist wichtig!
volatile uint8_t pwm_sync;                    // Update jetzt möglich

// Pointer

uint16_t *isr_ptr_time  = pwm_timing;
uint16_t *main_ptr_time = pwm_timing_tmp;

uint8_t *isr_ptr_mask  = pwm_mask;              // Bitmasken fuer PWM-Kanäle
uint8_t *main_ptr_mask = pwm_mask_tmp;          // ändern uint16_t oder uint32_t für mehr Kanäle

// Funktionen

void long_delay (uint8_t ms)
{
    for (; ms>0; ms--) _delay_ms (10);
}

void tausche_zeiger(void)
{
    uint16_t *tmp_ptr16;
    uint8_t *tmp_ptr8;                          // ändern uint16_t oder uint32_t für mehr Kanäle
    tmp_ptr16 = isr_ptr_time;
    isr_ptr_time = main_ptr_time;
    main_ptr_time = tmp_ptr16;
    tmp_ptr8 = isr_ptr_mask;
    isr_ptr_mask = main_ptr_mask;
    main_ptr_mask = tmp_ptr8;
}

void pwm_update(void)
{
    uint8_t i, j, k;
    uint8_t m1, m2, tmp_mask;                   // ändern uint16_t oder uint32_t für mehr Kanäle
    uint8_t min, tmp_set;                       // ändern auf uint16_t für mehr als 8 Bit Auflösung

    // PWM Maske für Start berechnen
    // gleichzeitig die Bitmasken generieren und PWM Werte kopieren

    m1 = 1;
    m2 = 0;

    for(i=1; i<=(PWM_CHANNELS); i++)
	{
        main_ptr_mask[i]=~m1;                       // Maske zum Löschen der PWM Ausgänge
        pwm_setting_tmp[i] = pwm_setting[i-1];
        if (pwm_setting_tmp[i]!=0) m2 |= m1;        // Maske zum setzen der IOs am PWM Start
        m1 <<= 1;
    }

    main_ptr_mask[0]=m2;                            // PWM Start Daten

    // PWM settings sortieren; Einfügesortieren

    for(i=1; i<=PWM_CHANNELS; i++)
	{
        min=PWM_STEPS-1;
        k=i;

        for(j=i; j<=PWM_CHANNELS; j++)
		{
            if (pwm_setting_tmp[j]<min)
			{
                k=j;                                // Index und PWM-setting merken
                min = pwm_setting_tmp[j];
            }
        }

        if (k!=i)
		{
            // ermitteltes Minimum mit aktueller Sortiertstelle tauschen
            tmp_set = pwm_setting_tmp[k];
            pwm_setting_tmp[k] = pwm_setting_tmp[i];
            pwm_setting_tmp[i] = tmp_set;
            tmp_mask = main_ptr_mask[k];
            main_ptr_mask[k] = main_ptr_mask[i];
            main_ptr_mask[i] = tmp_mask;
        }
    }

    // Gleiche PWM-Werte vereinigen, ebenso den PWM-Wert 0 löschen falls vorhanden

    k=PWM_CHANNELS;             // PWM_CHANNELS Datensätze
    i=1;                        // Startindex

    while(k>i)
	{
        while ( ((pwm_setting_tmp[i]==pwm_setting_tmp[i+1]) || (pwm_setting_tmp[i]==0))  && (k>i) )
		{
            // aufeinanderfolgende Werte sind gleich und können vereinigt werden
            // oder PWM Wert ist Null

            if (pwm_setting_tmp[i]!=0)
                main_ptr_mask[i+1] &= main_ptr_mask[i];        // Masken vereinigen

            // Datensatz entfernen,
            // Nachfolger alle eine Stufe hochschieben

            for(j=i; j<k; j++)
			{
                pwm_setting_tmp[j] = pwm_setting_tmp[j+1];
                main_ptr_mask[j] = main_ptr_mask[j+1];
            }
            k--;
        }
        i++;
    }

    // letzten Datensatz extra behandeln
    // Vergleich mit dem Nachfolger nicht möglich, nur löschen
    // gilt nur im Sonderfall, wenn alle Kanäle 0 sind
    if (pwm_setting_tmp[i]==0) k--;

    // Zeitdifferenzen berechnen

    if (k==0) { // Sonderfall, wenn alle Kanäle 0 sind
        main_ptr_time[0]=(uint16_t)T_PWM*PWM_STEPS/2;
        main_ptr_time[1]=(uint16_t)T_PWM*PWM_STEPS/2;
        k=1;
    }
    else {
        i=k;
        main_ptr_time[i]=(uint16_t)T_PWM*(PWM_STEPS-pwm_setting_tmp[i]);
        tmp_set=pwm_setting_tmp[i];
        i--;
        for (; i>0; i--) {
            main_ptr_time[i]=(uint16_t)T_PWM*(tmp_set-pwm_setting_tmp[i]);
            tmp_set=pwm_setting_tmp[i];
        }
        main_ptr_time[0]=(uint16_t)T_PWM*tmp_set;
    }

    // auf Sync warten

    pwm_sync=0;             // Sync wird im Interrupt gesetzt
    while(pwm_sync==0);

    // Zeiger tauschen
    cli();
    tausche_zeiger();
    pwm_cnt_max = k;
    sei();
}

void max7219_clock_out(unsigned char Data)
{
	char i;	
	for(i=0;i<8;i++) {	
		if(Data & (1<<7)) {
			max7219_PORT |= (1<<max7219_DIN);
		} else {
			max7219_PORT &= ~(1<<max7219_DIN);
		}
		Data <<= 1;
		max7219_PORT |= (1<<max7219_CLK); //Clock auf High, Daten werden übernommen
		max7219_PORT &= ~(1<<max7219_CLK); //Clock auf Low
	}
	return;
}

void max7219_send(unsigned char Data, unsigned char Register)
{
	//Register &= 0x0F; //Obere 4 Bits der Adresse werden nciht gelesen.
	max7219_PORT &= ~(1<<max7219_LOAD); // LOAD auf Low (Chip aktivieren)
	max7219_clock_out(Register); //Adresse senden
	max7219_clock_out(Data); //Daten senden
	max7219_PORT |= (1<<max7219_LOAD); // LOAD auf High. Steigende Flanke an High übernimmt Daten in Adressiertes Register.
}

void max7219_set_decodemode(unsigned char Decodemode) {max7219_send(Decodemode, 0x09);}
void max7219_intensity(unsigned char Intensity) {max7219_send(Intensity, 0x0A);}
void max7219_set_scanlimit(unsigned char Scanlimit) {max7219_send(Scanlimit, 0x0B);}

void max7219_shutdown(void) {max7219_send(0x00, 0x0C);}
void max7219_wakeup(void) {max7219_send(0x01, 0x0C);}

void max7219_displaytest_on(void) {max7219_send(0x01, 0x0F);}
void max7219_displaytest_off(void) {max7219_send(0x00, 0x0F);}

void max7219_nop(void) {max7219_send(0x00, 0x00);}

void max7219_clear(void)
{
	for(char i=1;i<9;i++){
		max7219_send(0b00000000, i);
	}
}

void max7219_init(void)
{
	max7219_DDR |= (1<<max7219_DIN) | (1<<max7219_LOAD) | (1<<max7219_CLK); // Die 3 Steurpins zu Ausgängen machen
	max7219_PORT &= ~( (1<<max7219_DIN) | (1<<max7219_CLK) ); // Clock und DIN auf Low Level
	max7219_PORT |= (1<<max7219_LOAD); //LOAD (CS bei 7221) auf High
	max7219_set_decodemode(0); //Keine BCD Wandler. Aller Segmente können individuell angesprochen werden.
	max7219_set_scanlimit(2); //Alle zeichen aktivieren
	max7219_intensity(15);	//Helligkeitsstufe 8 ist ein gutes Mittelmaß
//	max7219_displaytest_on();
//    long_delay (200);
//    max7219_displaytest_off();
	max7219_clear(); //Display zunächst leeren.
	max7219_wakeup();
}

//Tabelle für Hexadezimalzaheln
static const unsigned char Symbol[] = {0b01111110,0b00110000,0b01101101,0b01111001,0b00110011,0b01011011,0b01011111,0b01110000,0b01111111,0b01111011,0b01110111,0b00011111,0b01001110,0b00111101,0b01001111,0b01000111};

void max7219_hex(unsigned char Number, unsigned char Position)
{
	unsigned char Segments;

	if(Number > 15) {Segments = 0x00;}
	else {Segments = Symbol[Number];}

	max7219_send(Segments, Position);
}

void max7219_disp_uint8(uint8_t Number)
{
	char Digits = 3; //Maximal 3 Stellen (255)
		 if(Number<10)   {Digits = 1;}
	else if(Number<100)  {Digits = 2;}
	
	char i;
	
	for(i=1;i<=Digits;i++)
	{	
		max7219_hex(Number%10,i);
		Number/=10;
	}
	for(;i<=3;i++){max7219_send(0b00000000, i);} //Führende Nullen nicht anzeigen
}

void cap_button (void)
{
   if (PINB & 0x08)
	{
	    long_delay (40);
        if (!(PINC & 0x04))
		{
		    PORTC = 0xF7;
			out = 1;
		}
		else if (!(PINC & 0x08))
		{
            PORTC = 0xEF;
			out = 2;
        }
		else if (!(PINC & 0x10))
		{
            PORTC = 0xDF;
			out = 3;
        }
		else if (!(PINC & 0x20))
		{
		    PORTC = 0xBF;
			out = 4;
        }
		else if (!(PINC & 0x40))
		{
		    PORTC = 0x7F;
			out = 5;
        }
		else if (!(PINC & 0x80))
		{
		    PORTC = 0xFB;
			out = 0;
        }
    }
}

void ADC_Init (void)
{
    ADMUX = (1<<REFS0)|(1<<ADLAR);
	ADCSRA = (1<<ADPS2)|(1<<ADPS0);
	ADCSRA |= (1<<ADEN);
	ADCSRA |= (1<<ADSC);
	while (ADCSRA & (1<<ADSC)) { }
	(void) ADCW;
}

uint8_t ADC_Read (uint8_t channel)
{
    ADMUX = (ADMUX & ~(0x0F))|(channel & 0x0F);
	ADCSRA |= (1<<ADSC);
	while (ADCSRA & (1<<ADSC)) { }
	return ADCH;
}

ISR(TIMER2_COMP_vect)
{
    PORTB ^= (1<<PB4);
}

static uint8_t pwm_cnt;

ISR(TIMER1_COMPA_vect)
{
//    static uint8_t pwm_cnt;                     // ändern auf uint16_t für mehr als 8 Bit Auflösung
    uint8_t tmp;                                // ändern uint16_t oder uint32_t für mehr Kanäle

    OCR1A += isr_ptr_time[pwm_cnt];
    tmp    = isr_ptr_mask[pwm_cnt];

    if (pwm_cnt == 0)
	{
        PWM_PORT = tmp;                         // Ports setzen zu Begin der PWM
                                                // zusätzliche PWM-Ports hier setzen
        pwm_cnt++;
    }
    else
	{
        PWM_PORT &= tmp;                        // Ports löschen
                                                // zusätzliche PWM-Ports hier setzen
        if (pwm_cnt == pwm_cnt_max)
		{
            pwm_sync = 1;                       // Update jetzt möglich
            pwm_cnt  = 0;
        }
        else pwm_cnt++;
    }
}

/********************************************************************************************/
/*** Start des Hauptprogramms ***************************************************************/
/********************************************************************************************/

int main (void)
{
   DDRA  = 0xE0;
   DDRB  = 0xF3;
   DDRC  = 0xFF;
   PWM_DDR = 0xFB;         // Port als Ausgang


   PORTB = 0xFF;
   PORTC = 0xFB;
   PORTD = 0xFF;

   // Timer 2 konfigurieren
   TCCR2 |= (1<<CS20); // Prescaler 1
   TCCR2 |= (1<<WGM21); // CTC Modus
   // Compare Interrupt erlauben
   TIMSK |= (1<<OCIE2);
   // (1/80000)/(1/(4096000/1)) = 51
   OCR2 = 70-1;

   // Timer 1 OCRA1, als variablen Timer nutzen

   TCCR1B = 2;             // Timer läuft mit Prescaler 8
   TIMSK |= (1<<OCIE1A);   // Interrupt freischalten

   sei();                  // Interrupts global einschalten

   uint8_t adc0, adc1, adc2, temp=0, f0=0, f1=0, f2=0, reset=0, old_value=0, count=0;
   uint8_t result0=0, result1=0, result2=0, result3=0, result4=0, result5=0;
   uint8_t t1[8]={0, 0, 0, 0, 0, 0, 0, 0}, once0=0, once1=0, once2=0, once3=0, once4=0, s0=0, s2=0;
   volatile uint8_t tmp;

   max7219_init ();
   ADC_Init ();

   while(1)
   {

	   cap_button();
	
	   adc0 = ADC_Read (0);
      adc1 = ADC_Read (1);
	   adc2 = ADC_Read (2);

/*
       if (adc1 < 127)
	   {
	       max7219_send(0b11111111, 1);  // 7-Segment-Anzeige: 0%
	       max7219_send(0b10000000, 2);
	       max7219_send(0b11111111, 3);
       }
	   else
	   {
	       max7219_send(0b10000001, 1);  // 7-Segment-Anzeige: 100%
	       max7219_send(0b11001111, 2);
           max7219_send(0b11001111, 3);
       }
	   //long_delay (100);
*/

	   if (out==0)
	   {
	       temp = result0;
       }
	   else if (out==1)
	   {
	       temp = result1;
       }
	   else if (out==2)
	   {
	       temp = result2;
       }
	   else if (out==3)
	   {
	       temp = result3;
       }
	   else if (out==4)
	   {
	       temp = result4;
       }
	   else if (out==5)
	   {
	       temp = result5;
       }

       if (reset==0)
	   {
	       if ((adc0<230) && (once3==0) && (s2==0))
	       {
	          once3=1;
	
		       f0 = 0;
		       f1 = 0;
		       f2 = 0;
		       s0 = 1;
		
           }
	       else if ((adc2<230) && (once4==0) && (s0==0))
	       {
	          once4=1;
		       f0 = 1;
		       f1 = 1;
		       f2 = 1;
		       s2 = 1;
           }

	       if ((adc0<50) && (once0==0))
	       {
	         once0=1;
	         s2=0;
		       if (f0==0)
			   {
			       f0=1;
               }
			   else
			   {
			       f0=0;
               }
           }
	       else if ((adc1<50) && (f0==1) && (once1==0))
	       {
	          once1=1;
	           if (f1==0)
			   {
			       f1=1;
               }
			   else
			   {
			       f1=0;
               }
           }
           else if ((adc2<50) && (f0==1) && (f1==1) && (once2==0))
           {
             once2=1;
             s0=0;
	           if (f2==0)
			   {
			       f2=1;
               }
			   else
			   {
			       f2=0;
               }
           }

           if ((230>adc0) && (adc0>180) && (f0==0) && (temp==0 || temp==26))
	       {
	           temp = 0;
           }
	       else if ((180>adc0) && (adc0>110) && (f0==0) && (temp==0 || temp==26 || temp==51))
	       {
	           temp = 26;
	           once0=0;
           }
           else if ((adc0<110) && (temp==26 || temp==51 || temp==77))
           {
	           temp = 51;
           }
           else if ((230>adc0) && (adc0>110) && (f0==1) && (temp==51 || temp==77 || temp==102))
	       {
	           temp = 77;
	           once0=0;
           }
           else if ((230>adc1) && (adc1>110) && (f1==0) && (temp==77 || temp==102 || temp==128))
	       {
               temp = 102;
               once1=0;
           }
	       else if ((adc1<110) && (temp==102 || temp==128 || temp==153))
	       {
               temp = 128;
           }
	       else if ((230>adc1) && (adc1>110) && (f1==1) && (temp==128 || temp==153 || temp==179))
	       {
               temp = 153;
               once1=0;
           }
	       else if ((230>adc2) && (adc2>110) && (f2==0) && (temp==153 || temp==179 || temp==204))
	       {
               temp = 179;
               once2=0;
           }
	       else if ((adc2<110) && (temp==179 || temp==204 || temp==230))
	       {
               temp = 204;
           }
	       else if ((180>adc2) && (adc2>110) && (f2==1) && (temp==204 || temp==230 || temp==255))
	       {
               temp = 230;
               once2=0;
           }
	       else if ((230>adc2) && (adc2>180) && (f2==1) && (temp==230 || temp==255))
	       {
               temp = 255;
           }

	       if ((old_value==temp) && (adc0<230 || adc1<230 || adc2<230 || count>0))
	       {
	          PORTA=0xE0;
	           _delay_ms (10);
		       count++;
		       PORTA=0xC0;
		
           }
	       else
	       {
	           count = 0;
           }
       }

	   if ((count==50) || (reset==1)) //count==100 bzw. 2 Sekunden für die Überwachung
	   {
	       reset=1;
	       PORTA=0xE0;
		   _delay_ms (10);
		   count++;
		   PORTA=0xA0;
       }

	   if (count==100)           //count==200 bzw. 2 Sekunden für das forcen des Wertes
	   {
	      PORTA=0xE0;
	      _delay_ms (10);
	      PORTA=0x60;
	       reset=0;
		   count=0;
		   s0=0;
		   s2=0;
		   once0=0;
		   once1=0;
		   once2=0;
		   once3=0;
		   once4=0;
       }

	   old_value=temp;

	   if (temp==0)
	   {
           max7219_send(0b11111111, 1);  // 7-Segment-Anzeige: 0%
	       max7219_send(0b10000000, 2);
	       max7219_send(0b11111111, 3);
	   }
	   else if (temp==26)
	   {
           max7219_send(0b11001111, 1);  // 7-Segment-Anzeige: 10%
	       max7219_send(0b10110000, 2);
	       max7219_send(0b11111111, 3);
	   }
	   else if (temp==51)
	   {
           max7219_send(0b10010011, 1);  // 7-Segment-Anzeige: 20%
	       max7219_send(0b11101101, 2);
           max7219_send(0b11111110, 3);
	   }
	   else if (temp==77)
	   {
           max7219_send(0b10000111, 1);  // 7-Segment-Anzeige: 30%
	       max7219_send(0b11111001, 2);
	       max7219_send(0b11111110, 3);
	   }
	   else if (temp==102)
	   {
           max7219_send(0b11001101, 1);  // 7-Segment-Anzeige: 40%
	       max7219_send(0b10110011, 2);
	       max7219_send(0b11111110, 3);
	   }
	   else if (temp==128)
	   {
           max7219_send(0b10100101, 1);  // 7-Segment-Anzeige: 50%
	       max7219_send(0b11011011, 2);
	       max7219_send(0b11111110, 3);
	   }
	   else if (temp==153)
	   {
           max7219_send(0b10100001, 1);  // 7-Segment-Anzeige: 60%
	       max7219_send(0b11011111, 2);
	       max7219_send(0b11111110, 3);
	   }
	   else if (temp==179)
	   {
           max7219_send(0b10001111, 1);  // 7-Segment-Anzeige: 70%
	       max7219_send(0b11110000, 2);
	       max7219_send(0b11111111, 3);
	   }
	   else if (temp==204)
	   {
           max7219_send(0b10000001, 1);  // 7-Segment-Anzeige: 80%
	       max7219_send(0b11111111, 2);
	       max7219_send(0b11111110, 3);
	   }
	   else if (temp==230)
	   {
           max7219_send(0b10000101, 1);  // 7-Segment-Anzeige: 90%
	       max7219_send(0b11111011, 2);
	       max7219_send(0b11111110, 3);
	   }
	   else if (temp==255)
	   {
           max7219_send(0b10000001, 1);  // 7-Segment-Anzeige: 100%
	       max7219_send(0b11001111, 2);
           max7219_send(0b11001111, 3);
	   }

       if (out==0)
	   {
	       result0 = temp;
		   t1[0] = result0;
       }
	   else if (out==1)
	   {
	       result1 = temp;
		   t1[1] = result1;
       }
	   else if (out==2)
	   {
	       result2 = temp;
		   t1[4] = result2;
       }
	   else if (out==3)
	   {
	       result3 = temp;
           t1[5] = result3;
       }
       else if (out==4)
	   {
	       result4 = temp;
		   t1[6] = result4;
       }
	   else if (out==5)
	   {
	       result5 = temp;
		   t1[7] = result5;
       }

	   t1[2] = 0;
	   t1[3] = 0;

	   // Messung der Interruptdauer

       tmp =1;
       tmp =2;
       tmp =3;

       // Debug

       memcpy(pwm_setting, t1, 8);
       pwm_update();

/*
       max7219_send(0b11111111, 1);  // 7-Segment-Anzeige: 0%
	   max7219_send(0b10000000, 2);
	   max7219_send(0b11111111, 3);
	   long_delay (100);
       max7219_send(0b11001111, 1);  // 7-Segment-Anzeige: 10%
	   max7219_send(0b10110000, 2);
	   max7219_send(0b11111111, 3);
	   long_delay (100);
       max7219_send(0b10010011, 1);  // 7-Segment-Anzeige: 20%
	   max7219_send(0b11101101, 2);
	   max7219_send(0b11111110, 3);
	   long_delay (100);
       max7219_send(0b10000111, 1);  // 7-Segment-Anzeige: 30%
	   max7219_send(0b11111001, 2);
	   max7219_send(0b11111110, 3);
	   long_delay (100);
       max7219_send(0b11001101, 1);  // 7-Segment-Anzeige: 40%
	   max7219_send(0b10110011, 2);
	   max7219_send(0b11111110, 3);
	   long_delay (100);
       max7219_send(0b10100101, 1);  // 7-Segment-Anzeige: 50%
	   max7219_send(0b11011011, 2);
	   max7219_send(0b11111110, 3);
	   long_delay (100);
       max7219_send(0b10100001, 1);  // 7-Segment-Anzeige: 60%
	   max7219_send(0b11011111, 2);
	   max7219_send(0b11111110, 3);
	   long_delay (100);
       max7219_send(0b10001111, 1);  // 7-Segment-Anzeige: 70%
	   max7219_send(0b11110000, 2);
	   max7219_send(0b11111111, 3);
	   long_delay (100);
	   max7219_send(0b10000001, 1);  // 7-Segment-Anzeige: 80%
	   max7219_send(0b11111111, 2);
	   max7219_send(0b11111110, 3);
	   long_delay (100);
       max7219_send(0b10000101, 1);  // 7-Segment-Anzeige: 90%
	   max7219_send(0b11111011, 2);
	   max7219_send(0b11111110, 3);
	   long_delay (100);
       max7219_send(0b10000001, 1);  // 7-Segment-Anzeige: 100%
	   max7219_send(0b11001111, 2);
	   max7219_send(0b11001111, 3);
	   long_delay (100);
*/
/*
       max7219_hex (16, 1);
	   max7219_hex (16, 2);
       max7219_hex (0, 3);
	   long_delay (100);
       max7219_hex (16, 1);
	   max7219_hex (1, 2);
       max7219_hex (0, 3);
	   long_delay (100);
       max7219_hex (16, 1);
	   max7219_hex (2, 2);
       max7219_hex (0, 3);
	   long_delay (100);
       max7219_hex (16, 1);
	   max7219_hex (3, 2);
       max7219_hex (0, 3);
	   long_delay (100);
       max7219_hex (16, 1);
	   max7219_hex (4, 2);
       max7219_hex (0, 3);
	   long_delay (100);
       max7219_hex (16, 1);
	   max7219_hex (5, 2);
       max7219_hex (0, 3);
	   long_delay (100);
       max7219_hex (16, 1);
	   max7219_hex (6, 2);
       max7219_hex (0, 3);
	   long_delay (100);
	   max7219_hex (16, 1);
	   max7219_hex (7, 2);
       max7219_hex (0, 3);
	   long_delay (100);
       max7219_hex (16, 1);
	   max7219_hex (8, 2);
       max7219_hex (0, 3);
	   long_delay (100);
       max7219_hex (16, 1);
	   max7219_hex (9, 2);
       max7219_hex (0, 3);
	   long_delay (100);
       max7219_hex (1, 1);
	   max7219_hex (0, 2);
       max7219_hex (0, 3);
	   long_delay (100);
*/
   }
   return 0;
}


/********************************************************************************************/
/*** Ende des Hauptprogramms, d.h. Ende des gesamten Programms! *****************************/
/********************************************************************************************/