Hallo zusammen,
ich baue einen Umschalter für ein Projekt. Der Sketch funktioniert auch schon genau so, wie er soll. Bis auf (Hoffentlich) eine "Kleinigkeit". Ich weiß leider nicht, wie ich vorgehen muss.
Wenn ich inputSwitchC1 schalte, dann schaltet auch der dazugehörige Ausgang outputC1.
Wenn ich inputSwitchC2 schalte, dann schaltet der dazugehörige Ausgang outputC1 und outputCIO.
Ich möchte mit den beiden InputSwitchC1 und InputSwitchC2 zwei Ausgänge von outputC1 gleichzeitig schalten.
Z.B Pin 38, 39. Wenn Pin 39 durch inputSwitchC2 ausgelöst wird, soll auch Pin 52 von outputCIO geschaltet sein.
Könnt Ihr mir helfen?
const byte inputSwitchG1 [6] = {A5, A4, A3, A2, A1, A0};
const byte inputSwitchG2 [6] = {A13, A12, A11, A10, A9, A8};
const byte inputSwitchC1 [6] = {8, 9, 10, 11, 12, 13};
const byte inputSwitchC2 [6] = {2, 3, 4, 5, 6, 7};
const byte outputG1 [6] = {27, 26, 25, 24, 23, 22};
const byte outputC1 [6] = {43, 42, 41, 40, 39, 38};
const byte outputGIO [6] = {32, 33, 34, 35, 36, 37};
const byte outputCIO [6] = {48, 49, 50, 51, 52, 53};
const byte sperrPin [6] = {19, 18, 17, 16, 15, 14};
const byte noOfButtonssperr = 6;
const byte noOfButtons = 6;
//-------------------------------------------------
void setup()
{
for (byte a = 0; a < noOfButtons; a++)
{
pinMode(inputSwitchG1[a], INPUT);
pinMode(inputSwitchG2[a], INPUT);
pinMode(inputSwitchC1[a], INPUT);
pinMode(inputSwitchC2[a], INPUT);
pinMode(outputG1[a], OUTPUT);
pinMode(outputC1[a], OUTPUT);
pinMode(outputGIO[a], OUTPUT);
pinMode(outputCIO[a], OUTPUT);
digitalWrite(outputG1[a], HIGH);
digitalWrite(outputC1[a], HIGH);
digitalWrite(outputGIO[a], HIGH);
digitalWrite(outputCIO[a], HIGH);
}
for (byte z = 0; z < noOfButtonssperr; z++)
{
pinMode(sperrPin[z], INPUT);
}
}
//--------------------------------------------------
void loop()
{
bool merker1 = HIGH;
bool merker2 = HIGH;
for (byte b = 0; b < sizeof(inputSwitchG1); b++) // durchlaufe alle Pins von inputSwitchG1
{
for (byte f = 0; f < sizeof(outputC1) // durchlaufe alle Pins von outputC1
/ sizeof(outputC1[0]); f++) // wenn ein outputC1 auf LOW liegt,
{
if (!digitalRead(outputC1[f])) // wenn outputC1 auf LOW
{
merker1 = LOW; // merke, das ein PIN LOW ist
if (digitalRead(inputSwitchG1[b])) // wenn Taster inputSwitchG1 gedrückt
{
delay(200);
schalteG1(b); // gehe zu schalteG1
}
}
}
}
for (byte c = 0; c < sizeof(inputSwitchC1); c++) // durchlaufe alle Pins von inputSwitchC1
{
if (digitalRead(sperrPin[c])) // sperre gesetzt?
{
digitalWrite(outputC1[c], HIGH);
}
else if (digitalRead(inputSwitchC1[c])) // Taste inputSwitchC1 gedrückt?
{
delay(200);
schalteC1(c); //springe zu void schalteC1
}
}
for (byte d = 0; d < sizeof(inputSwitchG2); d++) // durchlaufe alle Pins von inputSwitchG2
{
for (byte g = 0; g < sizeof(outputC1) // durchlaufe alle Pins von outputC1
/ sizeof(outputC1[0]); g++) // wenn ein outputC1 auf LOW liegt,
{
if (!digitalRead(outputC1[g])) // wenn outputC1 auf LOW
{
merker2 = LOW; // merke, das ein PIN LOW ist
if (digitalRead(inputSwitchG2[d])) // wenn Taster inputSwitchG2 gedrückt
{
delay(200);
schalteG2(d); // gehe zu schalteG2
}
}
}
}
for (byte e = 0; e < sizeof(inputSwitchC2); e++) // durchlaufe alle Pins von inputSwitchC2
{
if (digitalRead(sperrPin[e])) // sperre gesetzt?
{
digitalWrite(outputC1[e], HIGH);
}
else if (digitalRead(inputSwitchC2[e])) // Taste inputSwitchC2 gedrückt?
{
delay(200);
schalteC2(e); //springe zu void schalteC2
}
}
allesHigh1(merker1);
allesHigh2(merker2);
}
//--------------------------------------------------
void allesHigh1(const bool neuMerker1) // Übergeben wird der merker
{
static bool lastMerker1 = LOW; // Inhalt darf nicht verloren gehen
if (neuMerker1 != lastMerker1) // neuer Status?....
{
lastMerker1 = neuMerker1; // .... Status merken UND ....
if (neuMerker1) // .... nur wenn HIGH
for (byte b = 0; b < sizeof(outputG1)
/ sizeof(outputG1[0]); b++)
{
digitalWrite(outputG1[b], HIGH);
}
}
}
//--------------------------------------------------
void allesHigh2(const bool neuMerker2) // Übergeben wird der merker
{
static bool lastMerker2 = LOW; // Inhalt darf nicht verloren gehen
if (neuMerker2 != lastMerker2) // neuer Status?....
{
lastMerker2 = neuMerker2; // .... Status merken UND ....
if (neuMerker2) // .... nur wenn HIGH
for (byte b = 0; b < sizeof(outputG1)
/ sizeof(outputG1[0]); b++)
{
digitalWrite(outputG1[b], HIGH);
}
}
}
//--------------------------------------------------
void schalteG1(const byte aPin) // übergeben werden die Pins
{
for (byte i = 0; i < sizeof(inputSwitchG1); i++) // durchlaufe Pins
{
if (i != aPin) // ist i ungleich Taster aus Loop
digitalWrite(outputG1[i], HIGH); // dann lösche den Status
else
{
digitalWrite(outputG1[i], LOW); // wenn der Pin stimmt, dann setze ihn
digitalWrite(outputGIO[i], HIGH);
}
}
}
//--------------------------------------------------
void schalteG2(const byte bPin) // übergeben werden die Pins
{
for (byte i = 0; i < sizeof(inputSwitchG2); i++) // durchlaufe Pins
{
if (i != bPin) // ist i ungleich Taster aus Loop
digitalWrite(outputG1[i], HIGH) ; // dann lösche den Status
else
{
digitalWrite(outputG1[i], LOW); // wenn der Pin stimmt, dann setze ihn
digitalWrite(outputGIO[i], LOW);
}
}
}
//--------------------------------------------------
void schalteC1(const byte cPin) // übergeben wird der Pin
{
for (byte j = 0; j < sizeof(inputSwitchC1); j++) // durchlaufe Pins
{
if (j != cPin) // ist j ungleich Taster aus Loop
digitalWrite(outputC1[j], HIGH); // dann lösche den Status
else
{
digitalWrite(outputC1[j], LOW); // wenn der Pin stimmt, dann setze ihn
digitalWrite(outputCIO[j], HIGH);
}
}
}
//--------------------------------------------------
void schalteC2(const byte dPin) // übergeben wird der Pin
{
for (byte j = 0; j < sizeof(inputSwitchC2); j++) // durchlaufe Pins
{
if (j != dPin) // ist j ungleich Taster aus Loop
digitalWrite(outputC1[j], HIGH); // dann lösche den Status
else
{
digitalWrite(outputC1[j], LOW); // wenn der Pin stimmt, dann setze ihn
digitalWrite(outputCIO[j], LOW);
}
}
}
