• Die Forumsregeln und Nutzungsbedingungen findet ihr in der Navbar unter Impressum !
    Bitte unbedingt beachten!
    Wie überall im Leben gibt es Spielregeln, so auch hier!
    Die Datenschutzerklärung zum DSGVO findet ihr ebenfalls in der Navbar unter Datenschutzerklärung !
    Hinweis nach DSGVO :
    Es ist hier keinerlei Angabe erforderlich. Alle Angaben in diesem Bereich sind öffentlich sichtbar und werden freiwillig gemacht. Mit einem Eintrag in diesem Bereich erkenne ich dieses an, und bestätige die Datenschutzerklärung zur DSGVO für das Forum gelesen zu haben.

    Danke
  • Hallo Gast, beschränke dich hier bitte auf den Bereich der Elektronik. Die Fahrzeuge oder Gebäude, wo diese Elektronik eingebaut wird bitte in dem passenden Fachbereiich behandeln. Auch wenn Teile des Projektes dadurch im Forum doppelt vorhanden sind! Danke.

Arduino Kanalschalter per Arduino

Registriert
16.02.2010
Beiträge
386
Hallo zusammen,

hat schon mal jemand einen 4-fach Kanalschalter (ähnlich die von CTI) mittels Arduino realisiert?
Also sowas wie:

Knüppel links lang -> Funktion 1
Knüppel links kurz -> Funktion 2
Knüppel rechts lang -> Funktion 3
Knüppel rechts kurz -> Funktion 4


Mir fehlt da irgendwie der richtige Ansatz, bin aber auch noch recht neu im Bereich Arduino.
 
Hallo Basti,

ich habe hier schon mal so etwas programmiert.
 
Hallo Bert,

danke das habe ich während meiner Suche wohl übersehen.
Dann werd ich mich da mal reinarbeiten :)
 
Moin Basti,

ich hatte so etwas mal für einen ATTiny geschrieben, daher habe ich ihn kurz für den Uno bzw. Mini Pro (ATMega328) umgeschrieben.

Code:
#define	PinChannelInput				0
#define	PinChannel1Output			1
#define	PinChannel2Output			2
#define	PinChannel3Output			3
#define	PinChannel4Output			4

#define	ChannelPositionUp			0
#define	ChannelPositionCenter		1
#define	ChannelPositionDown			2

			uint16_t		MeasuredCenter						= 1500;
			uint8_t			IntensityValues[4]					= {0, 0, 0, 0};

		//	Speichervariablen zur Glaettung des Servowerts

volatile	uint16_t		ReceivedChannelValues[4]			= {1500, 1500, 1500, 1500};
volatile	uint16_t		ReceivedChannelValuesSum			= 6000;
volatile	uint8_t			ReceivedChannelValuesIndex			= 0;

volatile	uint32_t		LastChannelChange					= micros();
volatile	uint16_t		ActualMeasuredChannelValue			= 0;

volatile	uint8_t			LastInterruptState					= PIND;

			uint8_t			PositionUpCounter					= 0;
			uint8_t			PositionDownCounter					= 0;
			uint32_t		PositionCounterTimeout				= 0;

			uint8_t			LastChannelPosition					= ChannelPositionDown;
			uint8_t			ActualChannelPosition				= ChannelPositionCenter;

void ChannelPositionInterrupt() 
{
	uint32_t    nMicros		= micros();
	uint16_t    nDifference  = (uint16_t)(nMicros - LastChannelChange);

	LastChannelChange	= nMicros;

	if ( (nDifference > 900) && ( nDifference < 2100))
	{

		ReceivedChannelValuesSum							-= ReceivedChannelValues[ReceivedChannelValuesIndex];
		ReceivedChannelValues[ReceivedChannelValuesIndex]	 = nDifference;
		ReceivedChannelValuesSum							+= nDifference;
		ReceivedChannelValuesIndex							 = ( ( ReceivedChannelValuesIndex + 1 ) & 0x03 );	//	Index erhoehen und ggf. von 4 auf 0 springen
		nDifference											 = ( ReceivedChannelValuesSum >> 2 );	//	durch 4 teilen
		ActualMeasuredChannelValue							 = nDifference;
	}
}

void setup()
{

	pinMode( PinChannelInput, INPUT );

	pinMode( PinChannel1Output, OUTPUT );
	pinMode( PinChannel2Output, OUTPUT );
	pinMode( PinChannel3Output, OUTPUT );
	pinMode( PinChannel4Output, OUTPUT );

	digitalWrite(PinChannel1Output, LOW);
	digitalWrite(PinChannel2Output, LOW);
	digitalWrite(PinChannel3Output, LOW);
	digitalWrite(PinChannel4Output, LOW);

	PCICR	|= (1 << PCIE2);
	PCMSK2	|= (1<<PCINT18);	//	Function (Pin2)

	sei();
}

void loop()
{
	if (ActualMeasuredChannelValue != 0)
	{
		//	Erst einmal pruefen ob der letzte Kanalwechsel laenger als 500ms her ist
		if (PositionCounterTimeout != 0)
		{
			if ( PositionCounterTimeout < millis())
			{
				switch(PositionUpCounter)
				{
					case 1:		IntensityValues[0]	= !IntensityValues[0];	digitalWrite(PinChannel1Output, IntensityValues[0]);	break;
					case 2:		IntensityValues[1]	= !IntensityValues[1];	digitalWrite(PinChannel2Output, IntensityValues[1]);	break;
				}
				switch(PositionDownCounter)
				{
					case 1:		IntensityValues[2]	= !IntensityValues[2];	digitalWrite(PinChannel3Output, IntensityValues[2]);	break;
					case 2:		IntensityValues[3]	= !IntensityValues[3];	digitalWrite(PinChannel4Output, IntensityValues[3]);	break;
				}
				PositionUpCounter		= 0;
				PositionDownCounter		= 0;
				PositionCounterTimeout	= 0;
			}
		}
		LastChannelPosition		= ActualChannelPosition;
		ActualChannelPosition	= ChannelPositionCenter;

		if ( ActualMeasuredChannelValue > (MeasuredCenter + 200))
			ActualChannelPosition	= ChannelPositionUp;
		else
		{
			if ( ActualMeasuredChannelValue < (MeasuredCenter - 200))
				ActualChannelPosition	= ChannelPositionDown;
		}
		if ((ActualChannelPosition == ChannelPositionCenter) && (LastChannelPosition != ActualChannelPosition))
		{
			//	Es gab einen Positionswechsel im Schaltkanal
			if ( LastChannelPosition == ChannelPositionUp)
			{
				PositionUpCounter++;
				PositionDownCounter	= 0;
			}
			else
			{
				PositionUpCounter	= 0;
				PositionDownCounter++;
			}
			if ((PositionUpCounter == 2) || (PositionDownCounter == 2))
				PositionCounterTimeout	= millis();
			else
				PositionCounterTimeout	= millis() + 1000;
		}
	}
	delay(15);
}

ISR(PCINT2_vect)
{
	uint8_t	PinState	= PIND;
	uint8_t	PinChanges	= PinState ^ LastInterruptState;

	if (PinChanges & (1<<PCINT18))
		ChannelPositionInterrupt();

	LastInterruptState	= PinState;
}
 

Hallo Bert,

ich habe Deinen Code mal etwas eingekürzt (Bremslicht etc. benötige ich ja nicht) sowie auf meine PINs angepasst.

Soweit funktioniert das auch wie gewünscht,allerdings sind die beiden Ausgänge für die Blinker ja immer noch Blinker.
Was muss ichändern, wenn ich diese beiden Ausgänge vom Verhalten her genau so haben möchte wie die Lichtausgänge?

Irgendwie steige ich durch Deinen Code noch nicht zu 100% durch :)

Vielleicht kannst Du mir da weiterhelfen?

Leider kriege ich den Code hier nicht eingefügt, ich bekomme immer die Meldung "Bild-Links zu Filehostern und anderen Forum sind in diesem Forum nicht erlaubt".
 
Hallo Basti,
du kannst auch keinen Code vom Filehoster hochladen.
Du must ihne per "Copy / Paste" (Kopieren / Einfügen) (STRG-C / STRG-V) von deinem PC in den Code-Tag kopieren.
 
Leider kann ich den Code hier weder in die CODE Tags setzen noch als Dateianhang hochladen.
 
Mal testen Code:

Code:
/*     Simple Stepper Motor Control Exaple Code

    
   19500 1/16  Steps gleich 9 mm, voller Weg - Tempo 1
   9750  1/8   Steps gleich 9 mm, voller Weg - Tempo 2
   4875  1/4   Steps gleich 9 mm, voller Weg - Tempo 3
   2438  1/2   Steps gleich 9 mm, voller Weg - Tempo 4
   1219  volle Steps gleich 9 mm, voller Weg - Tempo 5
*/
// defines pins numbers
const int stepPin = 3;
const int dirPin = 4;
const int MS1Pin = 5;
const int MS2Pin = 6;
const int MS3Pin = 7;
const int enablePin = 8;
const int stopPin = 9;
int steps = 0;

void setup() {
  // Sets the two pins as Outputs
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  pinMode(MS1Pin, OUTPUT);
  pinMode(MS2Pin, OUTPUT);
  pinMode(MS3Pin, OUTPUT);
  pinMode(enablePin, OUTPUT);
  pinMode(stopPin, INPUT);
  // define Steps
  steps = 0;

  const int Tempo = 4;

  if (Tempo == 1) {
    steps = 19500;
    digitalWrite(MS1Pin, HIGH);
    digitalWrite(MS2Pin, HIGH);
    digitalWrite(MS3Pin, HIGH);
  }

Bei mir geht´s einwandfrei :hm?
 
Hallo Basti,
:hm?
ich verstehe im Moment nicht, was bei dir falsch läuft.
Bei Gismow geht es ja, und bei Bulli16 auch.
Ich habe gerade noch mal kontrolliert. Beide User sind mit gleichem Status wie Du, nämlich "User", und gleichen Berechtigungen hier gespeichert.
Ich sehe auf deinem Bild leider nur einen Teil des im Editor eingetragenen Textes. Hast du am Ende des Code-Tags auch [/CODE] eingesetzt??

Was mir auffällt, ist folgendes:

Unbenannt+++.png

Betroffener Link: in/aus
Das sieht so aus, wie ein Fehler im Text oder Tag, so dass dieser falsch ausgewertet wird. :frage
Irgendwo im Editor muss dieser Teil stehen, den die Software so als IMG-Tag auswertet.
 
Hallo Winni,

ja im Code waren Kommentare wie z.B. "Blinker links ein / aus (ohne Leerzeichen)" :)
Hier der Code:

Code:
const byte PIN_RC3 = 2; // das ist INT 1 aber Pin 3 wo das Empfängersignal Blinker eingelesen wird
volatile int ReceivedSpeedValues3[8] = {1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500}; // Array mit 8 Werten für die gemessenen Werte
volatile int Summe3 = 12000; // Summe aus dem Array 8x1500, als Anfangswert
volatile int Mittelwert3 =1500; // Mittelwert aus der Summe 
volatile int Zeiger3 =0; // Zeiger für das Array, fängt mit 0 an
volatile long LastSpeedChange3 =0;
volatile long nMicros3 =0;
volatile long nDifference3 =0;

// Für Rückfahrwarner und Bremslicht
unsigned long zeit = 0;       // Systemzeit

// Für den Blinker und Fahrlicht
const byte Blink_re=8;        // pin 7 - Blinker rechts
const byte Blink_li=11;        // pin 8 - Blinker links
const byte Licht_re=9;        // pin 9 - Licht rechts
const byte Licht_li=10;       // pin 10 - Links links

unsigned long Dauer_re =0;    // Dauer wie lange Knüppel rechts war
unsigned long Pos_zeit_re =0; // Positionszeit rechts
unsigned long Dauer_li =0;    // Dauer wie lange Knüppel links war
unsigned long Pos_zeit_li =0; // Positionszeit links
unsigned long Takt =0;        // Hilfszeit für Blinktakt

bool Umschaltsperre_re = false;  // Knüppelposition wird abgefragt
bool Umschaltsperre_li = false;  // Knüppelposition wird abgefragt
bool Blink_re_an = false;        // Blinkfunktion rechts ein
bool Blink_li_an = false;        // Blinkfunktion links ein
bool Blink_re_Status = false;    // Blink LED rechts AN/AUS
bool Blink_li_Status = false;    // Blink LED rechts AN/AUS
byte i = 0;                      // Zähler für die Blinktakte
bool WarnBlink = false;          // Warnblinker
bool Licht_re_an = false;
bool Licht_li_an = false;
bool Licht_re_Sperre = false;     //Einschaltsperre Dauerlicht
bool Licht_li_Sperre = false;     //Einschaltsperre Dauerlicht

void setup() 
{ 
pinMode (Blink_re, OUTPUT);  // Blinker rechts
pinMode (Blink_li, OUTPUT);  // Blinker links
pinMode (Licht_re, OUTPUT);  // Licht rechts
pinMode (Licht_li, OUTPUT);  // Licht links

pinMode(PIN_RC3, INPUT);     // Eingang für Empfängersignal an Pin 3  

attachInterrupt( 0, SpeedPositionInterrupt3, CHANGE); // 0=Interrupt 0,also Pin2 / NAME der Interruptroutine / springe zum Interrupt wenn der Wert an Pin 2 sich ändert

Serial.begin(9600); // nur für debugging und Test
} 


void SpeedPositionInterrupt3() //Interrupt fragt Pin 3 ab
{
  nMicros3 = micros();  // die aktuelle Prozessorzeit wird in der variablen nMicros abgespeichert, dann geht der Zugriff schneller
  nDifference3  = (nMicros3 - LastSpeedChange3); // hier wird geprüft wie lange der letzte Pegelwechsel her ist

  if ( (nDifference3 > 900 ) && ( nDifference3 < 2100)) // liegt die Zeitdifferenz zwischen 0,9 und 2,1 ms, so ist es ein HIGH Pegal
  {
    Summe3 -= ReceivedSpeedValues3[Zeiger3]; // Summe = Summe - ReceivedSpeedValues[Zeiger];// substrahiere letzte Messung aus dem Array
    ReceivedSpeedValues3[Zeiger3] = nDifference3; // Array mit 8 Werten für die gemessenen Wert 
    Summe3 += nDifference3; //Summe = Summe + ReceivedSpeedValues[Zeiger]; // addiere Wert zur Summe  
    Zeiger3   = ( ( Zeiger3 + 1 ) & 0x07 ); //  Index erhoehen und ggf. von 8 auf 0 springen
    Mittelwert3 = ( Summe3 >> 3 );  //der Befehl >>3 ist bit shift left um drei bit, das ist wie durch 8 teilen
  }
  LastSpeedChange3 = nMicros3;

}

void loop() 
{ 
zeit = millis ();    // aktuelle Systemzeit in zeit1 schreiben


//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

// Ansteuerung Blinker RECHTS für 8x blinken 420 ms / 420 ms + Licht
      
if ((Mittelwert3 >= 1800) && (Umschaltsperre_re == false)) { // Knüppelposition erreicht und Umschaltsperre ist frei 
    Pos_zeit_re = millis ();        // aktueller Zeitwert wird geschrieben -> Auswertung der Verweildauer Knüppel 
    Umschaltsperre_re = true;       // Umschaltsperre einschalten, Knüppel muss erst mal wieder nach Null
    } 
    
if (Umschaltsperre_re == true){                           // Umschaltsperre ausschalten wenn der Knüppel in Null ist
    Dauer_re = (millis () - Pos_zeit_re);                 //hier wird die Verweildauer rechts ausgewertet

      if ((Dauer_re <= 800) && (Mittelwert3 <= 1650)) {   //Verweildauer kleiner 800 UND Knüppel wieder in Null -> Blinker ein
          Blink_re_an = true;                             //Blinker rechts an
         }
      if ((Dauer_re >= 1001)&& (Licht_re_Sperre == false)) { //Verweildauer größer 1001 -> Licht ein
         Licht_re_an = true;
         Dauer_re = 0;                                       //Verweildauer löschen
         }
     if ((Dauer_re >= 1001)&& (Licht_re_Sperre == true)) {  //Verweildauer größer 1001 UND Licht war an -> Licht aus
         Licht_re_an = false;
         Dauer_re = 0;                                       //Verweildauer löschen
         }  
       }

if (Mittelwert3 <= 1650){                                 //Knüppel in der Mitte -> Umschaltsperre löschen
          Umschaltsperre_re = false;  
          }

if ((Mittelwert3 <= 1650) && (Licht_re_an == true)) {     //Knüppel in der Mitte + Licht AN -> Lichtsperre einschalten
          Licht_re_Sperre = true;  
          }
          
if ((Mittelwert3 <= 1650) && (Licht_re_an == false)) {     //Knüppel in der Mitte + Licht AUS -> Lichtsperre löschen
          Licht_re_Sperre = false;  
          }
 
if ((Blink_re_an == true) && (Blink_li_an == false)&& (WarnBlink == false)) {     //Blinken ein
   
    if (millis () - Takt > 420){                           //Blinktatkt 420 ms ein / aus
      Takt = millis ();                                    //
      Blink_re_Status = !Blink_re_Status;                  //Ausgangsstatus invertieren
      i++;                                                 //Zähler 1 erhöhen  
     }
  }
    if (i > 15) {                                          //der Blinker blinkt 8 mal, aber der Zähler zählt ja auch die Pause mit (8 Blink + 7 Pause = 15)
      Blink_re_an = false;                                 //Blinker rechts aus
      Blink_re_Status = false;                             //Ausgangsstatus Blinker rechts auf LOW
      i = 0;                                               //Zähler zurücksetzen
    }
      
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

// Ansteuerung Blinker LINKS für 8x blinken 420 ms / 420 ms + Licht

if ((Mittelwert3 <= 1150) && (Umschaltsperre_li == false)) { // Knüppelposition erreicht und Umschaltsperre ist frei 
    Pos_zeit_li = millis ();        // aktueller Zeitwert wird geschrieben -> Auswertung der Verweildauer Knüppel 
    Umschaltsperre_li = true;       // Umschaltsperre einschalten, Knüppel muss erst mal wieder nach Null
    } 
    
if (Umschaltsperre_li == true){                           
    Dauer_li = (millis () - Pos_zeit_li);                 //hier wird die Verweildauer rechts ausgewertet

      if ((Dauer_li <= 800) && (Mittelwert3 >= 1350)) {   //Verweildauer kleiner 800 UND Knüppel wieder in der Mitte -> Blinker ein
          Blink_li_an = true;                             //Blinker links an                         
         }
      if ((Dauer_li >= 1001)&& (Licht_li_Sperre == false)) {  //Verweildauer größer 1011 -> Licht ein
         Licht_li_an = true;
         Dauer_li = 0;                                      //Verweildauer löschen
         }
     if ((Dauer_li >= 1001)&& (Licht_li_Sperre == true)) {  //Verweildauer größer 1001 UND Licht war an -> Licht aus
         Licht_li_an = false;
         Dauer_li = 0;                                      //Verweildauer löschen
         }  
   }

if (Mittelwert3 >= 1350){                                 //Knüppel in der Mitte -> Umschaltsperre löschen
          Umschaltsperre_li = false;  
          }

if ((Mittelwert3 >= 1350) && (Licht_li_an == true)) {     //Knüppel in der Mitte + Licht AN -> Lichtsperre einschalten
          Licht_li_Sperre = true;  
          }
          
if ((Mittelwert3 >= 1350) && (Licht_li_an == false)) {     //Knüppel in der Mitte + Licht AUS -> Lichtsperre löschen
          Licht_li_Sperre = false;  
          }
          
if ((Blink_li_an == true) && (Blink_re_an == false)&& (WarnBlink == false)) {     // Blinken ein
      if (millis () - Takt > 420){                         //Blinktatkt 420 ms ein / aus
      Takt = millis ();                                    //
      Blink_li_Status = !Blink_li_Status;                  //Ausgangsstatus invertieren
      i++;                                                 //Zähler 1 erhöhen  
     }
  }
    if (i > 15) {                                          //der Blinker blinkt 8 mal, aber der Zähler zählt ja auch die Pause mit (8 Blink + 7 Pause = 15)
      Blink_li_an = false;                                 //Blinker links aus
      Blink_li_Status = false;                               //Ausgangsstatus Blinker links auf LOW
      i = 0;                                               //Zähler zurücksetzen
    }
    
 //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 //  Warnblinker Logik
   
 if ((Blink_li_an == true) && (Blink_re_an == true) && (WarnBlink == false)) {  // Warnblinker ein wenn der andere Blinker schon blinkt
      WarnBlink = true;                                     //Warnblinker gesetzt
      Blink_li_an = false;                                  //Blinker links aus
      Blink_re_an = false;                                  //Blinker rechts aus
      Blink_li_Status = false;                              //LED erst mal aus wegen synchronisation
      Blink_re_Status = false;                              //LED erst mal aus wegen synchronisation
      i = 0;                                                //Zähler zurücksetzen     
      }
      
 if (WarnBlink == true) {
      if (millis () - Takt > 420){                         //Blinktatkt 420 ms ein / aus
      Takt = millis ();                                    //
      Blink_re_Status = !Blink_re_Status;                  //Ausgangsstatus invertieren
      Blink_li_Status = !Blink_li_Status;                      
      }
      }

if ((WarnBlink == true) && (Blink_re_Status == false) && (Blink_li_Status == false) && ((Blink_li_an == true) || (Blink_re_an == true))) {    
                                                         // wird nur abgeschaltet wenn LED aus (Pause)
      WarnBlink = false;
      Blink_li_an = false;                                //Blinker links aus
      Blink_re_an = false;                                //Blinker rechts aus
      Blink_li_Status = false;                            //LED aus
      Blink_re_Status = false;                            //LED aus
    }
    
    digitalWrite (Blink_li,Blink_li_Status); // Blinker links 
    digitalWrite (Blink_re,Blink_re_Status); // Blinker rechts
     
    digitalWrite (Licht_li,Licht_li_an); // Licht links 
    digitalWrite (Licht_re,Licht_re_an); // Licht rechts
}

Bert kannst Du hier weiterhelfen?
Im Prinzip will ich keine Blinker sondern hier auch nur einen Ausgang ein oder aus schalten.
 
Hallo Basti,

ist einfach so wie beim Licht. Da must du eine Sperre definieren.
Warnblinktimer bitte auch löschen.
Hier der Code für den rechten Blinker (jetzt Dauerlicht)

Code:
void setup() {
  // put your setup code here, to run once:

bool Blink_re_Sperre = false;     //Einschaltsperre Dauerlicht
bool Blink_li_Sperre = false;     //Einschaltsperre Dauerlicht

}

void loop() {
  // put your main code here, to run repeatedly:

//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

// Ansteuerung Blinker RECHTS  + Licht
      
if ((Mittelwert3 >= 1800) && (Umschaltsperre_re == false)) { // Knüppelposition erreicht und Umschaltsperre ist frei 
    Pos_zeit_re = millis ();        // aktueller Zeitwert wird geschrieben -> Auswertung der Verweildauer Knüppel 
    Umschaltsperre_re = true;       // Umschaltsperre einschalten, Knüppel muss erst mal wieder nach Null
    } 
    
if (Umschaltsperre_re == true){                           // Umschaltsperre ausschalten wenn der Knüppel in Null ist
    Dauer_re = (millis () - Pos_zeit_re);                 //hier wird die Verweildauer rechts ausgewertet

      if ((Dauer_re <= 800) && (Mittelwert3 <= 1650) && (Blink_re_Sperre == false) {   //Verweildauer kleiner 800 UND Knüppel wieder in Null -> Blinker ein
          Blink_re_an = true;                             //Blinker rechts an
          Dauer_re = 0;                                   //Verweildauer löschen
         }
     if ((Dauer_re <= 800) && (Mittelwert3 <= 1650) && (Blink_re_Sperre == true) {   //Verweildauer kleiner 800 UND Knüppel wieder in Null -> Blinker aus
          Blink_re_an = false;                             //Blinker rechts aus
          Dauer_re = 0;                                   //Verweildauer löschen
         }    
      if ((Dauer_re >= 1001)&& (Licht_re_Sperre == false)) { //Verweildauer größer 1001 -> Licht ein
         Licht_re_an = true;
         Dauer_re = 0;                                       //Verweildauer löschen
         }
     if ((Dauer_re >= 1001)&& (Licht_re_Sperre == true)) {  //Verweildauer größer 1001 UND Licht war an -> Licht aus
         Licht_re_an = false;
         Dauer_re = 0;                                       //Verweildauer löschen
         }  
       }

if (Mittelwert3 <= 1650){                                 //Knüppel in der Mitte -> Umschaltsperre löschen
          Umschaltsperre_re = false;  
          }

if ((Mittelwert3 <= 1650) && (Blink_re_an == true)) {     //Knüppel in der Mitte + Blink AN -> Blinksperre einschalten
          Blink_re_Sperre = true;  
          }
          
if ((Mittelwert3 <= 1650) && (Blink_re_an == false)) {     //Knüppel in der Mitte + Blink AUS -> Blinksperre löschen
          Blink_re_Sperre = false;  
          }

if ((Mittelwert3 <= 1650) && (Licht_re_an == true)) {     //Knüppel in der Mitte + Licht AN -> Lichtsperre einschalten
          Licht_re_Sperre = true;  
          }
          
if ((Mittelwert3 <= 1650) && (Licht_re_an == false)) {     //Knüppel in der Mitte + Licht AUS -> Lichtsperre löschen
          Licht_re_Sperre = false;  
          }
      
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 
Hallo Bert,

irgendwie will das noch nicht. Wenn ich den Knüppel rechts kurz betätige passiert gar nichts, bei Kurz links geht der Blinker links an (weil der Codeabschnitt ja noch nicht geändert ist).
Hier zur Info mein bisheriger Code mit der von Dir bereitgestellten Passage:

Code:
const byte PIN_RC3 = 2; // das ist INT 1 aber Pin 3 wo das Empfängersignal Blinker eingelesen wird
volatile int ReceivedSpeedValues3[8] = {1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500}; // Array mit 8 Werten für die gemessenen Werte
volatile int Summe3 = 12000; // Summe aus dem Array 8x1500, als Anfangswert
volatile int Mittelwert3 =1500; // Mittelwert aus der Summe 
volatile int Zeiger3 =0; // Zeiger für das Array, fängt mit 0 an
volatile long LastSpeedChange3 =0;
volatile long nMicros3 =0;
volatile long nDifference3 =0;

// Für Rückfahrwarner und Bremslicht
unsigned long zeit = 0;       // Systemzeit

// Für den Blinker und Fahrlicht
const byte Blink_re=8;        // pin 7 - Blinker rechts
const byte Blink_li=11;        // pin 8 - Blinker links
const byte Licht_re=9;        // pin 9 - Licht rechts
const byte Licht_li=10;       // pin 10 - Links links

unsigned long Dauer_re =0;    // Dauer wie lange Knüppel rechts war
unsigned long Pos_zeit_re =0; // Positionszeit rechts
unsigned long Dauer_li =0;    // Dauer wie lange Knüppel links war
unsigned long Pos_zeit_li =0; // Positionszeit links
unsigned long Takt =0;        // Hilfszeit für Blinktakt

bool Umschaltsperre_re = false;  // Knüppelposition wird abgefragt
bool Umschaltsperre_li = false;  // Knüppelposition wird abgefragt
bool Blink_re_an = false;        // Blinkfunktion rechts ein
bool Blink_li_an = false;        // Blinkfunktion links ein
bool Blink_re_Status = false;    // Blink LED rechts AN/AUS
bool Blink_li_Status = false;    // Blink LED rechts AN/AUS

bool Blink_re_Sperre = false;     //Einschaltsperre Dauerlicht
bool Blink_li_Sperre = false;     //Einschaltsperre Dauerlicht

byte i = 0;                      // Zähler für die Blinktakte
bool WarnBlink = false;          // Warnblinker
bool Licht_re_an = false;
bool Licht_li_an = false;
bool Licht_re_Sperre = false;     //Einschaltsperre Dauerlicht
bool Licht_li_Sperre = false;     //Einschaltsperre Dauerlicht

void setup() 
{ 
pinMode (Blink_re, OUTPUT);  // Blinker rechts
pinMode (Blink_li, OUTPUT);  // Blinker links
pinMode (Licht_re, OUTPUT);  // Licht rechts
pinMode (Licht_li, OUTPUT);  // Licht links

pinMode(PIN_RC3, INPUT);     // Eingang für Empfängersignal an Pin 3  

attachInterrupt( 0, SpeedPositionInterrupt3, CHANGE); // 0=Interrupt 0,also Pin2 / NAME der Interruptroutine / springe zum Interrupt wenn der Wert an Pin 2 sich ändert

Serial.begin(9600); // nur für debugging und Test
} 


void SpeedPositionInterrupt3() //Interrupt fragt Pin 3 ab
{
  nMicros3 = micros();  // die aktuelle Prozessorzeit wird in der variablen nMicros abgespeichert, dann geht der Zugriff schneller
  nDifference3  = (nMicros3 - LastSpeedChange3); // hier wird geprüft wie lange der letzte Pegelwechsel her ist

  if ( (nDifference3 > 900 ) && ( nDifference3 < 2100)) // liegt die Zeitdifferenz zwischen 0,9 und 2,1 ms, so ist es ein HIGH Pegal
  {
    Summe3 -= ReceivedSpeedValues3[Zeiger3]; // Summe = Summe - ReceivedSpeedValues[Zeiger];// substrahiere letzte Messung aus dem Array
    ReceivedSpeedValues3[Zeiger3] = nDifference3; // Array mit 8 Werten für die gemessenen Wert 
    Summe3 += nDifference3; //Summe = Summe + ReceivedSpeedValues[Zeiger]; // addiere Wert zur Summe  
    Zeiger3   = ( ( Zeiger3 + 1 ) & 0x07 ); //  Index erhoehen und ggf. von 8 auf 0 springen
    Mittelwert3 = ( Summe3 >> 3 );  //der Befehl >>3 ist bit shift left um drei bit, das ist wie durch 8 teilen
  }
  LastSpeedChange3 = nMicros3;

}

void loop() 
{ 
zeit = millis ();    // aktuelle Systemzeit in zeit1 schreiben


//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

// Ansteuerung Blinker RECHTS  + Licht
      
if ((Mittelwert3 >= 1800) && (Umschaltsperre_re == false)) { // Knüppelposition erreicht und Umschaltsperre ist frei 
    Pos_zeit_re = millis ();        // aktueller Zeitwert wird geschrieben -> Auswertung der Verweildauer Knüppel 
    Umschaltsperre_re = true;       // Umschaltsperre einschalten, Knüppel muss erst mal wieder nach Null
    } 
    
if (Umschaltsperre_re == true){                           // Umschaltsperre ausschalten wenn der Knüppel in Null ist
    Dauer_re = (millis () - Pos_zeit_re);                 //hier wird die Verweildauer rechts ausgewertet

      if ((Dauer_re <= 800) && (Mittelwert3 <= 1650) && (Blink_re_Sperre == false)) {   //Verweildauer kleiner 800 UND Knüppel wieder in Null -> Blinker ein
          Blink_re_an = true;                             //Blinker rechts an
          Dauer_re = 0;                                   //Verweildauer löschen
         }
     if ((Dauer_re <= 800) && (Mittelwert3 <= 1650) && (Blink_re_Sperre == true)) {   //Verweildauer kleiner 800 UND Knüppel wieder in Null -> Blinker aus
          Blink_re_an = false;                             //Blinker rechts aus
          Dauer_re = 0;                                   //Verweildauer löschen
         }    
      if ((Dauer_re >= 1001)&& (Licht_re_Sperre == false)) { //Verweildauer größer 1001 -> Licht ein
         Licht_re_an = true;
         Dauer_re = 0;                                       //Verweildauer löschen
         }
     if ((Dauer_re >= 1001)&& (Licht_re_Sperre == true)) {  //Verweildauer größer 1001 UND Licht war an -> Licht aus
         Licht_re_an = false;
         Dauer_re = 0;                                       //Verweildauer löschen
         }  
       }

if (Mittelwert3 <= 1650){                                 //Knüppel in der Mitte -> Umschaltsperre löschen
          Umschaltsperre_re = false;  
          }

if ((Mittelwert3 <= 1650) && (Blink_re_an == true)) {     //Knüppel in der Mitte + Blink AN -> Blinksperre einschalten
          Blink_re_Sperre = true;  
          }
          
if ((Mittelwert3 <= 1650) && (Blink_re_an == false)) {     //Knüppel in der Mitte + Blink AUS -> Blinksperre löschen
          Blink_re_Sperre = false;  
          }

if ((Mittelwert3 <= 1650) && (Licht_re_an == true)) {     //Knüppel in der Mitte + Licht AN -> Lichtsperre einschalten
          Licht_re_Sperre = true;  
          }
          
if ((Mittelwert3 <= 1650) && (Licht_re_an == false)) {     //Knüppel in der Mitte + Licht AUS -> Lichtsperre löschen
          Licht_re_Sperre = false;  
          }
      
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

// Ansteuerung Blinker LINKS für 8x blinken 420 ms / 420 ms + Licht

if ((Mittelwert3 <= 1150) && (Umschaltsperre_li == false)) { // Knüppelposition erreicht und Umschaltsperre ist frei 
    Pos_zeit_li = millis ();        // aktueller Zeitwert wird geschrieben -> Auswertung der Verweildauer Knüppel 
    Umschaltsperre_li = true;       // Umschaltsperre einschalten, Knüppel muss erst mal wieder nach Null
    } 
    
if (Umschaltsperre_li == true){                           
    Dauer_li = (millis () - Pos_zeit_li);                 //hier wird die Verweildauer rechts ausgewertet

      if ((Dauer_li <= 800) && (Mittelwert3 >= 1350)) {   //Verweildauer kleiner 800 UND Knüppel wieder in der Mitte -> Blinker ein
          Blink_li_an = true;                             //Blinker links an                         
         }
      if ((Dauer_li >= 1001)&& (Licht_li_Sperre == false)) {  //Verweildauer größer 1011 -> Licht ein
         Licht_li_an = true;
         Dauer_li = 0;                                      //Verweildauer löschen
         }
     if ((Dauer_li >= 1001)&& (Licht_li_Sperre == true)) {  //Verweildauer größer 1001 UND Licht war an -> Licht aus
         Licht_li_an = false;
         Dauer_li = 0;                                      //Verweildauer löschen
         }  
   }

if (Mittelwert3 >= 1350){                                 //Knüppel in der Mitte -> Umschaltsperre löschen
          Umschaltsperre_li = false;  
          }

if ((Mittelwert3 >= 1350) && (Licht_li_an == true)) {     //Knüppel in der Mitte + Licht AN -> Lichtsperre einschalten
          Licht_li_Sperre = true;  
          }
          
if ((Mittelwert3 >= 1350) && (Licht_li_an == false)) {     //Knüppel in der Mitte + Licht AUS -> Lichtsperre löschen
          Licht_li_Sperre = false;  
          }
          
if ((Blink_li_an == true) && (Blink_re_an == false)&& (WarnBlink == false)) {     // Blinken ein
      if (millis () - Takt > 420){                         //Blinktatkt 420 ms ein / aus
      Takt = millis ();                                    //
      Blink_li_Status = !Blink_li_Status;                  //Ausgangsstatus invertieren
      i++;                                                 //Zähler 1 erhöhen  
     }
  }
    if (i > 15) {                                          //der Blinker blinkt 8 mal, aber der Zähler zählt ja auch die Pause mit (8 Blink + 7 Pause = 15)
      Blink_li_an = false;                                 //Blinker links aus
      Blink_li_Status = false;                               //Ausgangsstatus Blinker links auf LOW
      i = 0;                                               //Zähler zurücksetzen
    }
    
 //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 //  Warnblinker Logik
   
 
  
  
    if ((Blink_li_an == true) && (Blink_re_an == true) && (WarnBlink == false)) {  // Warnblinker ein wenn der andere Blinker schon blinkt
      WarnBlink = true;                                     //Warnblinker gesetzt
      Blink_li_an = false;                                  //Blinker links aus
      Blink_re_an = false;                                  //Blinker rechts aus
      Blink_li_Status = false;                              //LED erst mal aus wegen synchronisation
      Blink_re_Status = false;                              //LED erst mal aus wegen synchronisation
      i = 0;                                                //Zähler zurücksetzen     
      }
      
 if (WarnBlink == true) {
      if (millis () - Takt > 420){                         //Blinktatkt 420 ms ein / aus
      Takt = millis ();                                    //
      Blink_re_Status = !Blink_re_Status;                  //Ausgangsstatus invertieren
      Blink_li_Status = !Blink_li_Status;                      
      }
      }

if ((WarnBlink == true) && (Blink_re_Status == false) && (Blink_li_Status == false) && ((Blink_li_an == true) || (Blink_re_an == true))) {    
                                                         // wird nur abgeschaltet wenn LED aus (Pause)
      WarnBlink = false;
      Blink_li_an = false;                                //Blinker links aus
      Blink_re_an = false;                                //Blinker rechts aus
      Blink_li_Status = false;                            //LED aus
      Blink_re_Status = false;                            //LED aus
    }

    
    digitalWrite (Blink_li,Blink_li_Status); // Blinker links 
    digitalWrite (Blink_re,Blink_re_Status); // Blinker rechts
     
    digitalWrite (Licht_li,Licht_li_an); // Licht links 
    digitalWrite (Licht_re,Licht_re_an); // Licht rechts
}
 
Hallo Basti,

Code:
   if ((Dauer_re <= 800) && (Mittelwert3 <= 1650) && (Blink_re_Sperre == false)) {   //Verweildauer kleiner 800 UND Knüppel wieder in Null -> Blinker ein
          Blink_re_an = true;                             //Blinker rechts an
          Dauer_re = 850;                                   //Verweildauer setzen, sonst geht das Licht gleich wieder aus
         }

Das ist die notwendige Änderung:
Dauer_re = 850; //Verweildauer setzen, sonst geht das Licht gleich wieder aus
 
Hallo Bert,

danke für Deine Hilfe. Ich habe den Code noch ein wenig umgeschrieben und alle ungenutzten Variablen entfernt.
Was soll ich sagen? Es funktioniert jetzt alles so wie es soll. Vielen lieben Dank für Deine Unterstützung.

Der Vollständigkeit halber - falls noch jemand mal nen 4-fach RC-Schalter sucht - hier der Code:

Code:
// Eingangs-PIN (Empfängersignal)
const byte PIN_RC = 2;                                                                        // das ist INT 1 aber Pin 2 an dem das Empfängersignal eingelesen wird

// Ausgangs-PINs
const byte Ausgang1 = 10;                                                                     // PIN 10 - Knüppel links lang
const byte Ausgang2 = 11;                                                                     // PIN 8 - Knüppel links  kurz
const byte Ausgang3 = 9;                                                                      // PIN 9 - Knüppel rechts lang
const byte Ausgang4 = 8;                                                                      // PIN 7 - Knüppel rechts kurz

//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXunsigned long Dauer_rechts =0;                                                                // Dauer wie lange Knüppel rechts war
unsigned long Dauer_rechts = 0;                                                               // Dauer wie lange Knüppel rechts war
unsigned long Dauer_links = 0;                                                                // Dauer wie lange Knüppel links war
unsigned long Zeit_rechts = 0;                                                                // Positionszeit rechts
unsigned long Zeit_links =0;                                                                  // Positionszeit links
bool Umschaltsperre_rechts = false;                                                           // Knüppelposition wird abgefragt
bool Umschaltsperre_links = false;                                                            // Knüppelposition wird abgefragt
bool Ausgang1_an = false;
bool Ausgang2_an = false;       
bool Ausgang3_an = false;
bool Ausgang4_an = false;       
bool Ausgang1_Sperre = false;                                                                 //Einschaltsperre Ausgang 1
bool Ausgang2_Sperre = false;                                                                 //Einschaltsperre Ausgang 2
bool Ausgang3_Sperre = false;                                                                 //Einschaltsperre Ausgang 3
bool Ausgang4_Sperre = false;                                                                 //Einschaltsperre Ausgang 4
unsigned long Zeit = 0;                                                                       // Systemzeit
volatile int ReceivedSpeedValues3[8] = {1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500};      // Array mit 8 Werten für die gemessenen Werte
volatile int Summe = 12000;                                                                   // Summe aus dem Array 8x1500, als Anfangswert
volatile int Mittelwert = 1500;  
volatile int Zeiger = 0;
volatile long LastSpeedChange = 0;
volatile long nMicros = 0;
volatile long nDifference =0;

void setup() 
{ 
  pinMode (PIN_RC, INPUT);                                                                    // Eingang für Empfängersignal
  pinMode (Ausgang1, OUTPUT);
  pinMode (Ausgang2, OUTPUT);
  pinMode (Ausgang3, OUTPUT);
  pinMode (Ausgang4, OUTPUT);
  attachInterrupt( 0, SpeedPositionInterrupt, CHANGE); // 0=Interrupt 0,also Pin2 / NAME der Interruptroutine / springe zum Interrupt wenn der Wert an Pin 2 sich ändert
} 


void SpeedPositionInterrupt()                                                                   // Interrupt fragt Empfängersignal-PIN ab
{
  nMicros = micros();                                                                           // die aktuelle Prozessorzeit wird in der variablen nMicros abgespeichert, dann geht der Zugriff schneller
  nDifference  = (nMicros - LastSpeedChange);                                                   // hier wird geprüft wie lange der letzte Pegelwechsel her ist
  if ( (nDifference > 900 ) && ( nDifference < 2100))                                           // liegt die Zeitdifferenz zwischen 0,9 und 2,1 ms, so ist es ein HIGH Pegal
  { 
    Summe -= ReceivedSpeedValues3[Zeiger];                                                      // Summe = Summe - ReceivedSpeedValues[Zeiger];// substrahiere letzte Messung aus dem Array
    ReceivedSpeedValues3[Zeiger] = nDifference;                                               // Array mit 8 Werten für die gemessenen Wert 
    Summe += nDifference;                                                                   // Summe = Summe + ReceivedSpeedValues[Zeiger]; // addiere Wert zur Summe  
    Zeiger   = ( ( Zeiger + 1 ) & 0x07 );                                                     //  Index erhoehen und ggf. von 8 auf 0 springen
    Mittelwert = ( Summe >> 3 );                                                                // der Befehl >>3 ist bit shift left um drei bit, das ist wie durch 8 teilen
  }
  LastSpeedChange = nMicros;
}

void loop() 
{ 
  Zeit = millis ();                                                                             // aktuelle Systemzeit in Variable "Zeit" schreiben

//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// Ansteuerung Knüppel RECHTS
      
  if ((Mittelwert >= 1800) && (Umschaltsperre_rechts == false))                                 // Knüppelposition erreicht und Umschaltsperre ist frei 
  {
      Zeit_rechts = millis ();                                                                  // aktueller Zeitwert wird geschrieben -> Auswertung der Verweildauer Knüppel 
      Umschaltsperre_rechts = true;                                                             // Umschaltsperre einschalten, Knüppel muss erst mal wieder nach Null
  } 
    
  if (Umschaltsperre_rechts == true)                                                            // Umschaltsperre ausschalten wenn der Knüppel in Null ist
  {                           
    Dauer_rechts = (millis () - Zeit_rechts);                                                   // hier wird die Verweildauer rechts ausgewertet
    if ((Dauer_rechts <= 800) && (Mittelwert <= 1650) && (Ausgang4_Sperre == false))            // Verweildauer kleiner 800 UND Knüppel wieder in Null -> Ausgang 4 schalten
    {
      Ausgang4_an = true;
      Dauer_rechts = 0;
    }
  
    if ((Dauer_rechts <= 800) && (Mittelwert <= 1650) && (Ausgang4_Sperre == true))             // Verweildauer kleiner 800 UND Knüppel wieder in Null -> Ausgang 4 aus
    {
      Ausgang4_an = false;
      Dauer_rechts = 0;
    }    
  
    if ((Dauer_rechts >= 1001)&& (Ausgang3_Sperre == false))                                    // Verweildauer größer 1001 UND Knüppel wieder in Null -> Ausgang 3 schalten
    {                      
      Ausgang3_an = true;
      Dauer_rechts = 0;                                                                         // Verweildauer löschen
    }
  
    if ((Dauer_rechts >= 1001)&& (Ausgang3_Sperre == true))                                     // Verweildauer größer 1001 UND Ausgang war an -> Ausgang ausschalten
    {
      Ausgang3_an = false;
      Dauer_rechts = 0;                                                                         // Verweildauer löschen
    }  
  }


  if (Mittelwert <= 1650)                                                                       // Knüppel in der Mitte -> Umschaltsperre löschen
  {
    Umschaltsperre_rechts = false;  
  }

  if ((Mittelwert <= 1650) && (Ausgang4_an == true))                                            // Knüppel in der Mitte + Ausgang 4 AN -> Sperre Ausgang 4 einschalten
  {
    Ausgang4_Sperre = true;  
  }
          
  if ((Mittelwert <= 1650) && (Ausgang4_an == false))                                           // Knüppel in der Mitte + Ausgang 4 AUS -> Sperre Ausgang 4 löschen
  {
    Ausgang4_Sperre = false;  
  }

  if ((Mittelwert <= 1650) && (Ausgang3_an == true))                                            // Knüppel in der Mitte + Ausgang 3 AN -> Sperre Ausgang 3einschalten
  {
    Ausgang3_Sperre = true;  
  }
          
  if ((Mittelwert <= 1650) && (Ausgang3_an == false))                                           //Knüppel in der Mitte + Ausgang 3 AUS -> Sperre Ausgang 3 löschen
  {
    Ausgang3_Sperre = false;  
  }


      
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// Ansteuerung Knüppel LINKS

  if ((Mittelwert <= 1150) && (Umschaltsperre_links == false))                                  // Knüppelposition erreicht und Umschaltsperre ist frei 
  { 
    Zeit_links = millis ();                                                                     // aktueller Zeitwert wird geschrieben -> Auswertung der Verweildauer Knüppel 
    Umschaltsperre_links = true;                                                                // Umschaltsperre einschalten, Knüppel muss erst mal wieder nach Null
  } 
    
  if (Umschaltsperre_links == true)
  {                           
    Dauer_links = (millis () - Zeit_links);                                                     // hier wird die Verweildauer rechts ausgewertet
    if ((Dauer_links <= 800) && (Mittelwert >= 1350) && (Ausgang2_Sperre == false))             // Verweildauer kleiner 800 UND Knüppel wieder in der Mitte -> Blinker ein
    {
      Ausgang2_an = true;                                                                       // Ausgang 2 EIN
      Dauer_links = 0;
    }
  
    if ((Dauer_links <=800) && (Mittelwert <= 1350) && (Ausgang2_Sperre == true))               // Verweildauer kleiner 800 UND Knüppel wieder in Null -> Ausgang 2 aus
    {
      Ausgang2_an = false;
      Dauer_links = 0;
    }

    if ((Dauer_links >= 1001)&& (Ausgang1_Sperre == false))                                     // Verweildauer größer 1011 -> Ausgang 1 ein
    {
      Ausgang1_an = true;
      Dauer_links = 0;                                                                          // Verweildauer löschen
    }
  
    if ((Dauer_links >= 1001)&& (Ausgang1_Sperre == true))                                      // Verweildauer größer 1001 UND Licht war an -> Ausgang 1 aus
    {
      Ausgang1_an = false;
      Dauer_links = 0;                                                                          // Verweildauer löschen
    }  
  }

  if (Mittelwert >= 1350)                                                                       // Knüppel in der Mitte -> Umschaltsperre löschen
  {
    Umschaltsperre_links = false;  
  }
      
  if ((Mittelwert >= 1350) && (Ausgang2_an == true))                                            // Knüppel in der Mitte + Ausgang 2 AN -> Sperre Ausgang 2 einschalten
  {
    Ausgang2_Sperre = true;  
  }
          
  if ((Mittelwert >= 1350) && (Ausgang2_an == false))                                           // Knüppel in der Mitte + Blink AUS -> Blinksperre löschen
  {
    Ausgang2_Sperre = false;  
  }

  if ((Mittelwert >= 1350) && (Ausgang1_an == true))                                            // Knüppel in der Mitte + Ausgang 1 AN -> Sperre Ausgang 1 einschalten
  {
    Ausgang1_Sperre = true;  
  }
          
  if ((Mittelwert >= 1350) && (Ausgang1_an == false))                                           // Knüppel in der Mitte + Licht AUS -> Lichtsperre löschen
  {
    Ausgang1_Sperre = false;  
  }

  digitalWrite (Ausgang1,Ausgang1_an); // Licht links 
  digitalWrite (Ausgang2,Ausgang2_an); // Blinker links 
  digitalWrite (Ausgang3,Ausgang3_an); // Licht rechts
  digitalWrite (Ausgang4,Ausgang4_an); // Blinker rechts
}
 
Danke für den Code:
Ich werde ihn nochmal als separaten Thread unter dem Namen einstellen.(kopieren)
 

Servonaut
Zurück
Oben Unten