/*
*******************************************************************

Autor: 			Beck Martin (mit Vorlagen von Tobias Schneider)
Taktfrequenz:	8 MHz
Chip:			Atmel atMega 8
Datum:			August 2015

Bezeichnung:	2 Kanal 20 Funktionen Multiswitch - 2k20fms
Hintergund:		Grund für dieses Prgramm war die fehlende kostenguenstige Moeglichkeit mir nur
					2 Schaltknueppeln (jeweils 3 Wege Schalter) die 20 Funktionen meines
					meines Schleppschiffs = Rettungsschiffs zu steuern.

Funktionsbeschreibung:

Wenn ein Schalter von 0 = Neutralstellung in eine Endlage = 100 oder -100 gebracht wird, wird dies
als Schaltimpuls gewertet und dabei entweder als "lang" oder "kurz" gewertet.
Voreingestellt ist hier 500 ms = 0,5 Sekunden, was eine vernünftige Schaltfrequenz sein dürfte.

Beispiel:

- Schalter vom RC Sender auf 100 % für eine kurze Zeit von 0,35 s schaltet Ausgang 1

- Schalter vom RC Sender auf -100 % für eine kurze Zeit von 0,35 s schaltet Ausgang 2
 
- Schalter vom RC Sender auf 100 % für eine lange Zeit von >0,35 s schaltet Ausgang 3
 
- Schalter vom RC Sender auf -100 % für eine lange Zeit von >0,35 s schaltet Ausgang 4
 
Der Zustand bleibt bestehen (Memory) bis erneut der entsprechende Ausgang geschalten wurde.
Wahlweise kann der Ausgang auch "tastend" sein, was jedoch nur bei den "direkten" Schaltzustaenden
ohne Kombination wirklich sinnvoll ist.

Ausgelegt ist die Schaltung für 2 Schalter mit je 2 Tastfunktionen (oben / unten)
Sie mueßte jedoch auch mit Schaltern funktionieren, wurde jedoch nicht getestet.

Mein Test: Graupner MX-20 (Schalterumbau) mit 6 Kanalempfaenger
		   Futaba FX-30 (Schalterumbau) mit 12 Kanalempfaenger



*******************************************************************
Wichtiger Hinweis zum Schluß:
 
__ -- Die vorliegende Software ist für private Zwecke frei verwendbar,  	      -- __
__ -- jedoch ist eine kommerzielle Verwendung, egal welcher Art nicht gestattet.  -- __

*******************************************************************

	                            +------------+
	       (PCINT14/RESET) PC6 -| 1       28 |- PC5 (ADC5/SCL/PCINT13)
	         (PCINT16/RXD) PD0 -| 2       27 |- PC4 (ADC4/SDA/PCINT12)
	         (PCINT17/TXD) PD1 -| 3       26 |- PC3 (ADC3/PCINT11)
	         PCINT18/INT0) PD2 -| 4       25 |- PC2 (ADC2/PCINT10)
	   (PCINT19/OC2B/INT1) PD3 -| 5       24 |- PC1 (ADC1/PCINT9)
	      (PCINT20/XCK/T0) PD4 -| 6       23 |- PC0 (ADC0/PCINT8)
	                       VCC -| 7       22 |- GND
	                       GND -| 8       21 |- AREF
	  (PCINT6/XTAL1/TOSC1) PB6 -| 9       20 |- AVCC
	  (PCINT7/XTAL2/TOSC2) PB7 -| 10      19 |- PB5 (SCK/PCINT5)
	     (PCINT21/OC0B/T1) PD5 -| 11      18 |- PB4 (MISO/PCINT4)
	(PCIN	T22/OC0A/AIN0) PD6 -| 12      17 |- PB3 (MOSI/OC2A/PCINT3)
     		(PCINT23/AIN1) PD7 -| 13      16 |- PB2 (SS/OC1B/PCINT2)
  	    (PCINT0/CLKO/ICP1) PB0 -| 14      15 |- PB1 (OC1A/PCINT1)
   					            +------------+
   					            
   					           
Verwendung in diesem Programm:
   					            
   					            
                            	+------------+
	           n.b.---  <- PC6 -| 1       28 |- PC5 -> A_6
	               A_7  <- PD0 -| 2       27 |- PC4 -> A_5
	               A_8  <- PD1 -| 3       26 |- PC3 -> A_4
	             * E_1  -> PD2 -| 4       25 |- PC2 -> A_3
	             * E_2  -> PD3 -| 5       24 |- PC1 -> A_2
	               A_9  <- PD4 -| 6       23 |- PC0 -> A_1
	                       VCC -| 7       22 |- GND
	                       GND -| 8       21 |- AREF
	               A_19 <- PB6 -| 9       20 |- AVCC
	               A_20 <- PB7 -| 10      19 |- PB5 -> A_18
	               A_10 <- PD5 -| 11      18 |- PB4 -> A_17
	               A_11 <- PD6 -| 12      17 |- PB3 -> A_16
	               A_12 <- PD7 -| 13      16 |- PB2 -> A_15
	               A_13 <- PB0 -| 14      15 |- PB1 -> A_14
   					            +------------+   	            
   					            

*******************************************************************
*/


// *******************************************************************
// Hardwarespezifische Parameter - nur bei Bedarf und bewußt aendern!! - Bei Veraenderungen wird
// das Programm ggf. in dieser Form unbrauchbar und muß abgeaendert werden!!


// *******************************************************************
//
// allgemeine und Chip spezifische Parameter
//
// *******************************************************************



// --- Hardware definieren

#define F_CPU	8000000 // 8000000UL

// --- notwendige Hilfsdateien einbeinden

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include <util\delay.h>


// *******************************************************************
//
// selbst zu definierende Eingaenge, Ausgaenge und Parameter
//
// *******************************************************************

// --- Die Eingaenge ---  selbst zu definieren

#define TASTERPORT PINC
#define TASTERBIT PINC1

#define  E_1_Bit 	PD2  	//  Eingangssignal 1 vom Empfaenger (Kanal 4)
#define  E_1_Pin 	PIND  	//  PIN des Eingangssignals 1 vom Empfaenger (Kanal 4)
#define  E_1_Port 	PORTD  	//  Port des Eingangssignals 1 vom Empfaenger (Kanal 4)

#define  E_2_Bit 	PD3	 	//  Eingangssignal 2 vom Empfaenger (Kanal 5)
#define  E_2_Pin 	PIND	//  PIN des Eingangssignals 2 vom Empfaenger (Kanal 5)
#define  E_2_Port 	PORTD  	//  Port des Eingangssignals 2 vom Empfaenger (Kanal 5)

#define  E_DirReg	DDRD   	//  Richtungsregister des Eingangssignals 1 und 2 vom Empfaenger (Kanal 4 und 5)


// --- Die Ausgaenge ---  selbst zu definieren -- ggf. im Hauptprogramm Ports anpassen

#define  A_1 PC0  //  Vor Rueck auf Rechts Links -> umschalten (an / aus)
#define  A_2 PC1  //  Schraube auf Geblaese -> umschalten (an / aus)
#define  A_3 PC2  //  Rettungsmaßnahme einholen -> ein / aus = automatischer Stop
#define  A_4 PC3  //  Rettungsmaßnahme 1 Abschuß -> ein / aus = automatischer Stop
#define  A_5 PC4  //  Rettungsmaßnahme 2 Abschuß -> ein / aus = automatischer Stop
#define  A_6 PC5  //  Licht innen (unten) -> an /aus

// #define A_21 PC6  //  -- nicht belegt da Reset

#define  A_7 PD0  //  Rauchgenerator -> an / aus - oder mit Fuellstandssensor bei "an")
#define  A_8 PD1  //  Ankerwinde -> auf / ab / Freier Fall (= Tastsignal auf Tiny übergeben)
#define  A_9 PD4  //  Sound Voegel / Geraeusche -> an / aus
#define A_10 PD5  //  Fahrtmusik von MP3 Spieler -> an = Tastsignal an Tiny - Fahrtmusik / Diverse Musik / aus
#define A_11 PD6  //  Nebelhorn - Sound (PIN = "tastend") MP3 Spieler -> an / aus
#define A_12 PD7  //  Licht Abschleppbereich (Heck) und Arbeitsbereich (Bug) -> an / aus

#define A_13 PB0  //  Positionslichter -> an / aus ("an" mit Helligkeitssensor)
#define A_14 PB1  //  Licht Suchscheinwerfer -> an / aus
#define A_15 PB2  //  Licht Steuerhaus -> an / aus
#define A_16 PB3  //  Licht Steuerkonsole -> an / aus
#define A_17 PB4  //  Querstahlruder -> an = Motor Querstahlruder Bug + Heck => Loeschmonitor A19 und A20 aus! / aus -> A19 mögl. ein
#define A_18 PB5  //  Loeschwasserpumpe -> an = Servo 1 = Monitor 1 drehen + Servo 2 = Monitor 2 drehen - nur wenn A18 und A20 aus! / aus 
#define A_19 PB6  //  Servo fuer Rettungsmaßnahme rechts / links -> nur wenn A18 aus und A19 aus !!
#define A_20 PB7  //  Kontroll LED für Microkontroller IC Feedback automatisch und Ton Feedback für Steuersignal (mit Jumper Signal ein / aus)

#define  A_1_6_Port 	PORTC	//  Port des Ausgangssignals 1 bis 6
#define  A_7_12_Port 	PORTD	//  Port des Ausgangssignals 7 bis 12
#define  A_13_20_Port 	PORTB	//  Port des Ausgangssignals 16 bis 20


// --- Parameter ---  selbst zu definieren

volatile unsigned int schaltdauer = 350; // x10 ms;   	// Zeit bis zum Wechsel des Schaltzustandes in ms für "langen Schaltzustand"
											// Wert als vielfaches von 10

// *******************************************************************
//
// diverse sonstige Variablen im Programm
//
// *******************************************************************


volatile unsigned int impuls_E1= 0;   	// Impuls Signal Eingang 1
volatile unsigned int impuls_E2= 0;   	// Impuls Signal Eingang 2
volatile unsigned int signal_1 = 0;  	// Impulslänge Signal Eingang 1
volatile unsigned int signal_2 = 0;  	// Impulslänge Signal Eingang 2

volatile unsigned int schaltzeit_cnt = 0;  			// Zaehler für Schaltzeit
volatile unsigned int schaltzeit_cnt1 = 0;			// Zaehler für Schaltzeit E1
volatile unsigned int schaltzeit_cnt2 = 0;			// Zaehler für Schaltzeit E1
volatile unsigned char aus_E1 = 0;				// Aus Signal E1 kommend
volatile unsigned char aus_E2 = 0;				// Aus Signal E2 kommend



volatile unsigned char schaltzustand = 0;			// Allgemeiner Schaltzustand
volatile unsigned char schaltzustand_1 = 0; 		// Schaltzusand E1 / E2 (je max. 255 Stück!!)
volatile unsigned char schaltzustand_2 = 0;			
// volatile unsigned int schaltzustand_ausgabe = 0;	// Ausgabe des Schaltzustandes für Hauptprogramm
volatile unsigned int schaltzyklus_cnt = 0;			// Zaehler für komplette Schaltzyklen
volatile unsigned int schalt_cnt_1_o = 0;			// Zaehler fuer Schaltzustaende E1_oben
volatile unsigned int schalt_cnt_1_u = 0;			// Zaehler fuer Schaltzustaende E1_unten
volatile unsigned int schalt_cnt_2_o = 0;			// Zaehler fuer Schaltzustaende E2_oben
volatile unsigned int schalt_cnt_2_u = 0;			// Zaehler fuer Schaltzustaende E2_unten
volatile unsigned int schaltzeit = 0;



volatile unsigned int   mid_1 = 0;			// signal_mittelwert_1 / 2
volatile unsigned int   mid_2 = 0;
volatile unsigned char  i1;				// Zählvariable Signal 1 / 2
volatile unsigned char  i2;				
volatile unsigned char  wechselabwarten_1 = 0;  	// warten auf mittelstellung_1 / 2
volatile unsigned char  wechselabwarten_2 = 0;	
volatile unsigned char  t1 = 0;			// Merker fuer Schalter als TipTaster 1 - 10
volatile unsigned char  t2 = 0;
volatile unsigned char  t3 = 0;
volatile unsigned char  t4 = 0;
volatile unsigned char  t5 = 0;
volatile unsigned char  t6 = 0;
volatile unsigned char  t7 = 0;
volatile unsigned char  t8 = 0;
volatile unsigned char  t9 = 0;
volatile unsigned char t10 = 0;
volatile unsigned int  t_zaehler = 0;	// Zaehler fuer TipTaster Merker 
volatile unsigned char ton = 0;			// Merker fuer Signalhorn / Warnton 
volatile unsigned int  ton_zaehler = 0;	// Zaehler fuer Signalhorn / Warnton  



volatile unsigned char sound = 0;
volatile unsigned int soundpresc = 0;
volatile unsigned char watch = 0;
volatile unsigned int fail = 0;


// *******************************************************************
//
// Unterprogramme (void), Timer und Interrupts
//
// *******************************************************************


// Interrupts

ISR (TIMER1_COMPA_vect)	// 100.000 Hz = 10.000 mySekundy
{

	if(PIND & (1<<PD2))		// Signallänge messen -> an E1 = Kanal 1 empfangen
	{	
		impuls_E1++;
	}
	else if(impuls_E1!=0)
	{
		if(impuls_E1>255)
		signal_1=0;
		else
		signal_1=impuls_E1;
		impuls_E1=0;
	}
	
	if(PIND & (1<<PD3))		// Signallänge messen -> an E2 = Kanal 2 empfangen
	{	
		impuls_E2++;
	}
	else if(impuls_E2!=0)
	{
	
		if(impuls_E2>255)
		signal_2=0;
		else
		signal_2=impuls_E2;
		impuls_E2=0;
	}
	
	
	watch = 1;				//Signal fuer Hauptschlaeife, den (Wach)Hund zu fuettern
	fail++;					//Zeitramen fuer Plausibilitaetstest erhoehen
	// --- noch implementieren
			
													
																									
}


ISR (TIMER2_OVF_vect)	//Alle 10 ms
{

	schaltzeit_cnt++;

TCNT2 = 178; // = 0b10110010 = 0xB2                 // TCNT2 = 0x06; // = 6
OCR2 = 77 ;  // = 0b01001101 = 0x4D  



}



// *******************************************************************
// Timer




void startTimer1() 		// alle 10 uSec = 100.000 Hz
{
	TCNT1 = 0b1111111111110110;
	TCCR1B |= (1 << CS11) | (1 << WGM12); // | (1 << CS10) 	//Timer1 CTC /8
	OCR1B = 0x0009;
	TIMSK |= (1 << OCIE1A) | (1<<TOIE1) ;  //| (1<<OCIE2) |(1 << OCIE1B) ;
	
	
	
}


void startTimer2()   	// als Abfrage 500 ms als vielfaches von 10 (9.9840) ms
{						// 500 / 10 ms = 50 mal

	schaltzeit_cnt = 0;
	schaltzeit_cnt1 = 0;
	schaltzeit_cnt2 = 0;

	TCCR2 |= (1 << CS22) | (1 << CS21) | (1 << CS20); // = 0b00000111              // TCCR2 |= (1 << CS22);   // 64 Prescaler 2 ms
 		
	TCNT2 = 178; // = 0b10110010 = 0xB2                 // TCNT2 = 0x06; // = 6
	OCR2 = 77 ;  // = 0b01001101 = 0x4D                 // OCR2 = 0xF9;  // = 249 
 	TIMSK |= (1 << OCIE2) | (1<<TOIE2) ;

	
}









void stopTimer1() 
{
  TCCR1B  = 0b00000000;         // Prescaler auf 0 -> stopt Timer1
}

void stopTimer2() 
{
  TCCR2  = 0b00000000;         // Prescaler auf 0 -> stopt Timer2
}








// *******************************************************************
// Unterprogramme


void reset_zaehler ()
{
	schalt_cnt_1_u = 0;
	schalt_cnt_1_o = 0;
	schalt_cnt_2_u = 0;
	schalt_cnt_2_o = 0;
	
	schaltzustand = 0;
	schaltzustand_1 = 0;
	schaltzustand_2 = 0;
	
	schaltzeit_cnt = 0;
	schaltzeit_cnt1 = 0;
	schaltzeit_cnt2 = 0;


}



// *******************************************************************
//
//                         Hauptprogramm
//
// *******************************************************************


int main(void)			// Hauptprogramm Start
{
	cli();				// Interrupts aus für Initialisierung
	
	
// *******************************************************************
// Ports definieren und ggf. vorbelegen
	
	DDRC  = 0b11111111;		// Alles Ausgänge
	PORTC = 0b00000000;		//Alles aus
		
	DDRB  = 0b11111111;		// Alles Ausgänge
	PORTB = 0b00000000;		//Alles aus
	
// Port D mit Eingangsbits 2k20f Programm vorbelegen 

	DDRD  = 0b11110011;		// Alles Ausgänge
	PORTD = 0b00000000;		//Alles aus
	
	
	// A_13_20_Port = (1<<A_20); 	 // Signal LED ein
	// A_13_20_Port ^= (1<<A_20);		// Siganl LED aus
	// --- noch implementieren
	
// *******************************************************************
// Initialisieren
	reset_zaehler();
	startTimer1();
	
	schaltzeit = (schaltdauer / 10);
	
	sei();
	// wdt_enable( WDTO_15MS);		//Watchdog einschalten
	// --- noch implementieren

	
// *******************************************************************
// Pulslänge mitteln E1 und E2
	
	
	for(i1=0;i1<60;i1++)		//Mittlere Periodenlaenge E1 ueber 60 Pulse messen
	{			
		while(!signal_1);
		mid_1 += signal_1;
	}
	mid_1 /= 60;
	
	
	for(i2=0;i2<60;i2++)		//Mittlere Periodenlaenge E2 ueber 60 Pulse messen
	{			
		while(!signal_2);
		mid_2 += signal_2;
	}
	mid_2 /= 60;
	
	
	
// *******************************************************************
// Hauptschleife
	
	
	while(1)			// Hauptschleife Start
	{
		
		
		
// *******************************************************************
// Abfrage und Verarbeitung Eingang 1
		
		
		
		if(signal_1!=0)		//Neuer Impuls E2 ?
		{							
			schaltzeit_cnt1 =0;
			
			if(signal_1>mid_1+20 && !wechselabwarten_1)  //Knueppel nach unten und vorher in Mittelstellung?
			{	
				schaltzeit_cnt1 =0;
				schaltzeit_cnt = 0;
								
				startTimer2();
										
				while((signal_1>mid_1+20) && !wechselabwarten_1)  //Knueppel nach unten und vorher in Mittelstellung?
				{			
					schaltzeit_cnt1 = schaltzeit_cnt;	
										
					if (schaltzeit_cnt1 >= schaltzeit)		// war Schaltzeit lang ?
					{
							
						schaltzeit_cnt1 = 0;		// Zuweisung Schaltzustand
						schaltzustand_1 = 1;
						
					}	
					
				}
				stopTimer2();	
					
				wechselabwarten_1 = 1;
			 	schalt_cnt_1_u++;	// Anzahl der Schaltvorgaenge
			 	
			 	if ((1<schaltzeit_cnt1) && (schaltzeit_cnt1< schaltzeit))
				{
					
					schaltzeit_cnt1 = 0;		// Zuweisung Schaltzustand
					schaltzustand_1 = 2;
					
					
				}
				else
				{
					schaltzeit_cnt1 = 0;
				}
			}
			
			schaltzeit_cnt1 =0;
			
			if(signal_1<mid_1-20 && !wechselabwarten_1)  //Knueppel nach unten und vorher in Mittelstellung?
			{	
				schaltzeit_cnt1 =0;
				schaltzeit_cnt = 0;
								
				startTimer2();
										
				while((signal_1<mid_1-20) && !wechselabwarten_1)  //Knueppel oben unten und vorher in Mittelstellung?
				{			
					schaltzeit_cnt1 = schaltzeit_cnt;	
							
				}
				stopTimer2();	
					
				wechselabwarten_1 = 1;
			 	schalt_cnt_1_o++;	// Anzahl der Schaltvorgaenge
			 	
			 	if ((1<schaltzeit_cnt1) && (schaltzeit_cnt1< schaltzeit))
				{
					
					schaltzeit_cnt1 = 0;		// Zuweisung Schaltzustand
					schaltzustand_1 = 4;
				}
				else if (schaltzeit_cnt1 >= schaltzeit)		
				{
					
					schaltzeit_cnt1 = 0;		// Zuweisung Schaltzustand
					schaltzustand_1 = 3;
				}	
								
				else
				{
					schaltzeit_cnt1 = 0;
				}
			}
			
				
			
			if(signal_1>mid_1-10 && signal_1<mid_1+10)		//Knueppel in Mittelstellung?
			{
				aus_E1 = 1;
				wechselabwarten_1 = 0;
			}
	
			fail=0;
			signal_1=0;
			
		}
		
			
			
// *******************************************************************
// Abfrage und Verarbeitung Eingang 2
		
				
								
		
		if(signal_2!=0)		//Neuer Impuls E2 ?
		{							
			schaltzeit_cnt2 =0;
			
			if(signal_2>mid_2+20 && !wechselabwarten_2)  //Knueppel nach unten und vorher in Mittelstellung?
			{	
				schaltzeit_cnt2 =0;
				schaltzeit_cnt = 0;
								
				startTimer2();
										
				while((signal_2>mid_2+20) && !wechselabwarten_2)   // Schaltzeit abwarten
				{			
					schaltzeit_cnt2 = schaltzeit_cnt;	
										
					if (schaltzeit_cnt2 >= schaltzeit)		// war Schaltzeit lang ?
					{
						schaltzeit_cnt2 = 0;        // Zuweisung Schaltzustand
						schaltzustand_2 = 1;
						
					}	
					
				}
				stopTimer2();	
					
				wechselabwarten_2 = 1;
			 	schalt_cnt_2_u++;	// Anzahl der Schaltvorgaenge
			 	
			 	if ((1<schaltzeit_cnt2) && (schaltzeit_cnt2< schaltzeit))  // war Schaltzeit kurz ?
				{
					
					schaltzeit_cnt2 = 0;		// Zuweisung Schaltzustand
					schaltzustand_2 = 2;
					
					
				}
				else
				{
					schaltzeit_cnt2 = 0;
				}
			}
			
			schaltzeit_cnt2 =0;
			
			if(signal_2<mid_2-20 && !wechselabwarten_2)  //Knueppel nach oben und vorher in Mittelstellung?
			{	
				schaltzeit_cnt2 =0;
				schaltzeit_cnt = 0;
								
				startTimer2();
										
				while((signal_2<mid_2-20) && !wechselabwarten_2)  // Schaltzeit abwarten
				{			
					schaltzeit_cnt2 = schaltzeit_cnt;	
							
				}
				stopTimer2();	
					
				wechselabwarten_2 = 1;
			 	schalt_cnt_2_o++;	// Anzahl der Schaltvorgaenge
			 	
			 	if ((1<schaltzeit_cnt2) && (schaltzeit_cnt2< schaltzeit))  // war Schaltzeit kurz ?
				{
					
					schaltzeit_cnt2 = 0;		// Zuweisung Schaltzustand
					schaltzustand_2 = 4;
				}
				else if (schaltzeit_cnt2 >= schaltzeit)		// war Schaltzeit lang ?
				{
					
					schaltzeit_cnt2 = 0;		// Zuweisung Schaltzustand
					schaltzustand_2 = 3;
				}	
								
				else
				{
					schaltzeit_cnt2 = 0;		// Zaehler Schaltzeit ruecksetzen
				}
			}
			
				
			
			if(signal_2>mid_2-10 && signal_2<mid_2+10)		//Knueppel in Mittelstellung?
			{
				aus_E2 = 1;

				wechselabwarten_2 = 0;
			}
	
			fail=0;
			signal_2=0;
			
		}	
		
			
// *******************************************************************
// Zuweisung Ausgabepin je nach Schaltzustand
		
			
		switch (schaltzustand_1)		// Abfrage nach Schaltzustand 
		{
			case 1:  {PORTB ^= (1<<PB0); schaltzustand_1=0;}	
			break;
			case 2:  {PORTB ^= (1<<PB1); schaltzustand_1=0;}	
			break;
			case 3:  {PORTB ^= (1<<PB2); schaltzustand_1=0;}
			break;
			case 4:  {PORTB ^= (1<<PB3); schaltzustand_1=0;}
			break;
		}
		
		
		
		switch (schaltzustand_2)		// Abfrage nach Schaltzustand
		{
			case 1:  {PORTB ^= (1<<PB4); schaltzustand_2=0;}	
			break;
			//case !1: {PORTB &= ~(1 << PB4); schaltzustand_2=0;}	// falls 'aktiv', dann PB4 tastend
			//break;
			case 2:  {PORTB ^= (1<<PB5); schaltzustand_2=0;}	
			break;
			case 3:  {PORTB ^= (1<<PB6); schaltzustand_2=0;}
			break;
			case 4:  {PORTB ^= (1<<PB7); schaltzustand_2=0;}
			break;
		}
		
	
		
		
// *******************************************************************
// Watchdog ueberpruefen und ggf. zuruecksetzen
			
		
		// --- noch implementieren

		
// *******************************************************************
// Fail safe 

		// --- noch implementieren
		
	}			// Hauptschleife Ende
}				// Hauptprogramm Ende