Suche Programieren fürs Beeden eines kleines Projektes

Joggu · June 4, 2017, 3:14pm

Wie im Titel schon geschrieben bin ich uf der Suche nach jemaden der Lust hat mit mir ein Projekt zu beenden das ich schon lage offen habe. Ich habe das Programieren unterschätz und ziehe mein Hut vor dene die das beherschen.

Das Projekt ist ein Warnlicht Balken mit Arbeitsscheinwerfer für auf ein PKW.

Hier hebe ich euch mal eine funktions erklährung und ein Abschluss Schema.

Ich bin für jede hilfe sehr dankbar. So das ich das Projekt zu Endebringe.

Funktions erklährung

S1: Haupttaster schaltet LED 1 ein und gibt die anderen Taster frei. Bei erneutem Drucken schaltet er alles aus.
S2: Schalter 2 schaltet LED 2 und Relais 1, bei erneutem drücken die LED und das Relais wieder aus.
S3: Schalter für die LED Blitzer schaltet die LED 3 und gibt die funkion des Tasters 4 frei, 1. Modus LED leuchtet, steuert die LED Blitzer mit dem Modus 1 an. Bei erneutem Drucken LED 2, Modus LEDs und Blitzer ausschalten.
S4: Ist der Modus schalter mit im wird zwischen den 3 Blink Modusen umgeschaltet, kann Modus LED 1,2&3 steueren. Gibt die Verschiedenen Blink Modusen an die LED Blitzer weiter.

S4: Schaltet LED 4 und Relais 2 ein und beim erneuten drücken wieder aus.
S5: Schaltet LEd 5 (Fehler auf Schema ist mit 4. angschrieben) und Relais 3 ein und beim erneuten drücken wieder aus.

Modus erklährung:

Modus 1 ist ein 4 fach wechsel Blinker mit 50 Milisekunden Pause heisst:

10 EIN, Pause 50, 10 AUS, Pause 50, 10 EIN, Pause 50, 10 AUS, Pause 50, 10 EIN, Pause 50, 10 AUS, Pause 50, 10 EIN, Pause 50, 10 AUS, Pause 50, 11EIN, Pause 50, 11 AUS, Pause 50, 11EIN, Pause 50, 11 AUS, Pause 50, 11EIN, Pause 50, 11 AUS, Pause 50, 11EIN, Pause 50, 11 AUS, Pause 50
mit endlosschlaufe

Modus 2 ist ein Wechsel Blinker mit 230 Milisekunden Pause heisst:

10 Ein, Pause 230, 10 AUS, 11 EIN, Pause 230, 11 AUS
mit endlosschlaufe

Modus 3 ist ein Warnblinker bei dem beide zusammen Blinken

10&11 EIN, Pause 500, 10&11 AUS, Pause 400
mit endlosschlaufe

Pause ist warscheindliche der falsche ausdruck, da ja sonst in dieser Zeit der Arduino blockiert ist. Und er sollte auch wenn ein blink muster aktiv ist noch andere Sachen ausführen können.

combie · June 4, 2017, 3:30pm

Wir können dir auf die Sprünge helfen.

z.B.: Eine handvoll endliche Automaten wäre wohl was für dich, nehme ich mal an.

gregorss · June 4, 2017, 5:51pm

Joggu:
... Ich bin für jede hilfe sehr dankbar. So das ich das Projekt zu Endebringe. ...

Wie Combie schon sagt, kann man das, was Du möchtest, wohl am besten mit einem endlichen Automaten erledigen. Dazu habe ich vor einiger Zeit mal das hier ins Netz gekippt. Vielleicht hilft Dir das, Dein Projekt doch noch selbst umzusetzen.

Was das Programmieren angeht: Ich helfe gerne bei konkreten Einzelfragen. Zum Schreiben ganzer Programme für andere Leute fehlt mir schlicht die Zeit. Die verbringe ich lieber mit meinen eigenen Bastel-/Programmierereien.

Gruß

Gregor

Joggu · June 4, 2017, 7:30pm

Danke schon mal.

Ich habe das mit den Automat mal angeschaut und bin am ausprobieren. was mir noch nicht ganz klar ist. Ist wie ich drei verschieden automaten in ein Sketch bringe und diese dann über den Modus taster auffrufen kann

gregorss · June 4, 2017, 8:13pm

Joggu:
Ich habe das mit den Automat mal angeschaut und bin am ausprobieren. was mir noch nicht ganz klar ist. Ist wie ich drei verschieden automaten in ein Sketch bringe und diese dann über den Modus taster auffrufen kann

Dass es schwierig ist, sein Vorhaben nach einem Strickmuster zu organisieren, halte ich für normal. Ich habe selbst erst vor relativ kurzer Zeit mein Vorhaben als so einen Automaten umgesetzt und hatte erstmal Probleme, die Abläufe, die ich im Kopf hatte, in „Phasen“ zu zerlegen oder zu formulieren.

Wie der Automat genau aussehen muss, den Du für Dein Vorhaben benötigst, kann ich so auf die Schnelle nicht sagen.

Wenn ich irgendwelche Modusänderungen realisieren wollte, würde ich zunächst die Verhaltensweisen nach Modus „sortieren“ und die Modi in Form separater Automaten handhaben.

Denke ich mir so ...

Gruß

Gregor

Joggu · June 4, 2017, 9:26pm

Ich konnte mir jetzt mal die Drei Blink Moden erstellen

Modus 1

enum Phase {ON1, OFF1, ON2, OFF2, ON3, OFF3, ON4, OFF4, ON5, OFF5, ON6, OFF6, ON7, OFF7, ON8, OFF8}; // "Namen" fuer die Phasen
int d[]={50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50}; // Dauer der Phasen in ms
Phase phase; // Enthaelt die aktuelle Phase
long int millisMem; // Merker fuer millis()

void setup()
{
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  phase=ON1;
  millisMem=millis();
}

void loop()
{
  switch(phase)  //Modus 1 Bliter
  {
    case ON1:
              if(millis()-millisMem < d[0])
              { digitalWrite(10, HIGH); }
              else
              { phase=OFF1; }
              break;
    case OFF1:
              if(millis()-millisMem < d[0]+d[1])
              { digitalWrite(10, LOW); }
              else
              { phase=ON2;}
              break;
   case ON2:
              if(millis()-millisMem < d[0]+d[1]+d[2])
              { digitalWrite(10, HIGH); }
              else
              { phase=OFF2; }
              break;
    case OFF2:
              if(millis()-millisMem < d[0]+d[1]+d[2]+d[3])
              { digitalWrite(10, LOW); }
              else
              { phase=ON3;}
              break;
              
    case ON3:
              if(millis()-millisMem < d[0]+d[1]+d[2]+d[3]+d[4])
              { digitalWrite(10, HIGH); }
              else
              { phase=OFF3; }
              break;
    case OFF3:
              if(millis()-millisMem < d[0]+d[1]+d[2]+d[3]+d[4]+d[5])
              { digitalWrite(10, LOW); }
              else
              { phase=ON4;}
              break;
 
    case ON4:
              if(millis()-millisMem < d[0]+d[1]+d[2]+d[3]+d[4]+d[5]+d[6])
              { digitalWrite(10, HIGH); }
              else
              { phase=OFF4; }
              break;
    case OFF4:
              if(millis()-millisMem  < d[0]+d[1]+d[2]+d[3]+d[4]+d[5]+d[6]+d[7])
              { digitalWrite(10, LOW); }
              else
              { phase=ON5;}
              break;
   
   case ON5:
              if(millis()-millisMem < d[0]+d[1]+d[2]+d[3]+d[4]+d[5]+d[6]+d[7]+d[8])
              { digitalWrite(11, HIGH); }
              else
              { phase=OFF5; }
              break;
    case OFF5:
              if(millis()-millisMem < d[0]+d[1]+d[2]+d[3]+d[4]+d[5]+d[6]+d[7]+d[8]+d[9])
              { digitalWrite(11, LOW); }
              else
              { phase=ON6;}
              break;
     
      case ON6:
              if(millis()-millisMem < d[0]+d[1]+d[2]+d[3]+d[4]+d[5]+d[6]+d[7]+d[8]+d[9]+d[10])
              { digitalWrite(11, HIGH); }
              else
              { phase=OFF6; }
              break;
    case OFF6:
              if(millis()-millisMem < d[0]+d[1]+d[2]+d[3]+d[4]+d[5]+d[6]+d[7]+d[8]+d[9]+d[10]+d[11])
              { digitalWrite(11, LOW); }
              else
              { phase=ON7;}
              break;
    case ON7:
              if(millis()-millisMem < d[0]+d[1]+d[2]+d[3]+d[4]+d[5]+d[6]+d[7]+d[8]+d[9]+d[10]+d[11]+d[12])
              { digitalWrite(11, HIGH); }
              else
              { phase=OFF7; }
              break;
    case OFF7:
              if(millis()-millisMem < d[0]+d[1]+d[2]+d[3]+d[4]+d[5]+d[6]+d[7]+d[8]+d[9]+d[10]+d[11]+d[12]+d[13])
              { digitalWrite(11, LOW); }
              else
              { phase=ON8; }
              break;
   case ON8:
              if(millis()-millisMem < d[0]+d[1]+d[2]+d[3]+d[4]+d[5]+d[6]+d[7]+d[8]+d[9]+d[10]+d[11]+d[12]+d[13]+d[14])
              { digitalWrite(11, HIGH); }
              else
              { phase=OFF8; }
              break;
    case OFF8:
              if(millis()-millisMem < d[0]+d[1]+d[2]+d[3]+d[4]+d[5]+d[6]+d[7]+d[8]+d[9]+d[10]+d[11]+d[12]+d[13]+d[14]+d[15])
              { digitalWrite(11, LOW); }
              else
              { phase=ON1; millisMem=millis();}
              break;
  }

 

}

Modus 2

enum Phase {ON1, OFF1, ON2, OFF2}; // "Namen" fuer die Phasen
int d[]={230, 230, 230, 230}; // Dauer der Phasen in ms
Phase phase; // Enthaelt die aktuelle Phase
long int millisMem; // Merker fuer millis()

void setup()
{
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  phase=ON1;
  millisMem=millis();
}

void loop()
{
  switch(phase)  //Modus 2 Wechsel Blinker
  {
    case ON1:
              if(millis()-millisMem < d[0])
              { digitalWrite(10, HIGH),digitalWrite(11, LOW); }
              else
              { phase=OFF1; }
              break;
    case OFF1:
              if(millis()-millisMem < d[0]+d[1])
              { digitalWrite(10, LOW),digitalWrite(11, HIGH); }
              else
              { phase=ON1; millisMem=millis();}
              break;
   
  }

 

}

Modus 3

enum Phase {ON1, OFF1}; // "Namen" fuer die Phasen
int d[]={500, 400}; // Dauer der Phasen in ms
Phase phase; // Enthaelt die aktuelle Phase
long int millisMem; // Merker fuer millis()

void setup()
{
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  phase=ON1;
  millisMem=millis();
}

void loop()
{
  switch(phase)  //Modus 3 Warnblinker
  {
    case ON1:
              if(millis()-millisMem < d[0])
              { digitalWrite(10, HIGH),digitalWrite(11, HIGH); }
              else
              { phase=OFF1; }
              break;
    case OFF1:
              if(millis()-millisMem < d[0]+d[1])
              { digitalWrite(10, LOW),digitalWrite(11, LOW); }
              else
              { phase=ON1; millisMem=millis();}
              break;
   
  }


}

Weis nicht ob alles so richtig ist. Aber die LEDs Blinken so wie sie sollten

Jetzt weiss ich einfach nicht wie ich die Moden richtig einsetzt so das ich sie über eine taster Aufrufen kann.

gregorss · June 4, 2017, 10:29pm

Joggu:
Ich konnte mir jetzt mal die Drei Blink Moden erstellen

Ui, Du hast Dir Mühe gegeben

Gucke ich mir garantiert an, aber erst morgen.

Gruß

Gregor

ardubu · June 5, 2017, 5:42am

das

long int millisMem; // Merker fuer millis()

solltest du in

unsigned long millisMem; // Merker fuer millis()

ändern, um einen Überlauf zu vermeiden

Joggu · June 5, 2017, 2:17pm

Ich habe mal etwas weiter Programiert, bin gerade daran die Taster für die Relais und kontroll LEDS zu Programmieren.
Jetzt habe ich nur das Problem wie ich am besten die Taster als Schalter Programieren kann.

#include <Wire.h>
#include <Adafruit_MCP23017.h>
 
Adafruit_MCP23017 mcp1; // Create MCP 1

 
void setup() {  
  mcp1.begin(0);      // Start MCP 1 on Hardware address 0x20

 
  mcp1.pinMode(7, INPUT); // Schalter 6
  mcp1.pullUp(7, HIGH);  // Pull-Up Schalter 6

  mcp1.pinMode(6, INPUT); // Schalter 5
  mcp1.pullUp(6, HIGH);  // Pull-UP Schalter 5
  
  mcp1.pinMode(5, INPUT); // Schalter 4
  mcp1.pullUp(5, HIGH);  // Pull-Up Schalter 4
  
  mcp1.pinMode(4, INPUT); // Schalter 3
  mcp1.pullUp(4, HIGH);  // Pull-Up Schalter 3

  mcp1.pinMode(3, INPUT); // Schalter 2
  mcp1.pullUp(3, HIGH);  // Pull-Up Schalter 2
  
  mcp1.pinMode(2, INPUT); // Schalter 1
  mcp1.pullUp(2, HIGH);  // Pull-Up Schalter 1
  
  mcp1.pinMode(8, OUTPUT); // Modus LED 3
  mcp1.pinMode(9, OUTPUT); // Modus LED 2
  mcp1.pinMode(10, OUTPUT); // Modus LED 1
  mcp1.pinMode(11, OUTPUT); // LED 5
  mcp1.pinMode(12, OUTPUT); // LED 4
  mcp1.pinMode(13, OUTPUT); // LED 3
  mcp1.pinMode(14, OUTPUT); // LED 2
  mcp1.pinMode(15, OUTPUT); // LED 1

  pinMode(14,OUTPUT); // Relais 1
  pinMode(15,OUTPUT); // Relais 2
  pinMode(16,OUTPUT); // Relais 3
  digitalWrite(14,HIGH); // Für Relais 1
  digitalWrite(15,HIGH); // Für Relais 2
  digitalWrite(16,HIGH); // Für Relais 3

} // End Setup
 
void loop() {
 
 
  if (mcp1.digitalRead(7) == LOW)             // Relais 3 + LED 5
  {
    mcp1.digitalWrite(11, HIGH); digitalWrite(16, LOW);}
    
  else
  {
    mcp1.digitalWrite(11, LOW); digitalWrite(16,HIGH); 
  }
  

   if (mcp1.digitalRead(6) == LOW)          // Relais 2 + LED 4
  {
    mcp1.digitalWrite(12, HIGH);digitalWrite(15,LOW);}
    
  else
  {
    mcp1.digitalWrite(12, LOW);digitalWrite(15,HIGH);
  }


   if (mcp1.digitalRead(3) == LOW)          // Relais 1 + LED 2
  {
    mcp1.digitalWrite(14, HIGH);digitalWrite(14,LOW);}
    
  else
  {
    mcp1.digitalWrite(14, LOW);digitalWrite(14,HIGH);
    
  }
} // End loop

agmue · June 5, 2017, 2:49pm

Nun waren wir parallel aktiv, wobei mein Fokus auf dem Zusammenlegen der verschiedenen Modi liegt. Das habe ich durch Verschachteln von switch/case gelöst:

#include <Wire.h>
#include "Adafruit_MCP23017.h"        // MCP23017 mittels I2C angeschlossen
Adafruit_MCP23017 mcp;
#define MCPI2CADR 0        // alle Adresspins an GND, Grundadresse 0x20 wird von der Bibliothek addiert.

const byte pinS4 = 5;
enum Modus {MODUS1, MODUS2, MODUS3};
byte modus = MODUS1;
enum Phase {ON1, OFF1, ON2, OFF2, ON3, OFF3, ON4, OFF4, ON5, OFF5, ON6, OFF6, ON7, OFF7, ON8, OFF8}; // "Namen" fuer die Phasen
byte phase = ON1; // Enthaelt die aktuelle Phase
unsigned int d1[] = {50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50}; // Dauer der Phasen in ms
unsigned int d2[] = {230, 230, 230, 230}; // Dauer der Phasen in ms
unsigned int d3[] = {500, 400}; // Dauer der Phasen in ms
unsigned long tastenMillis, millisMem; // Merker fuer millis()
bool altS4, aktS4, statS4;

void setup()
{
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  mcp.begin(MCPI2CADR);
  mcp.pinMode(pinS4, INPUT);
  mcp.pullUp(pinS4, HIGH);  // aktiviert 100k PullUp-Widerstand
}

void loop()
{
  statS4 = false;
  if (millis() - tastenMillis >= 50)
  {
    tastenMillis = millis();
    altS4 = aktS4;
    aktS4 = mcp.digitalRead(pinS4);
    if (!aktS4 && altS4)
    {
      statS4 = true;
      digitalWrite(10, LOW), digitalWrite(11, LOW);
      if (modus < MODUS3)
      {
        modus++;
      } else {
        modus = MODUS1;
      }
      phase = ON1; // Enthaelt die aktuelle Phase
    }
  }


  switch (modus)
  {
    case MODUS1:
      switch (phase) //Modus 1 Bliter
      {
        case ON1:
          if (millis() - millisMem < d1[0])
          {
            digitalWrite(10, HIGH);
          }
          else
          {
            phase = OFF1;
          }
          break;
        case OFF1:
          if (millis() - millisMem < d1[0] + d1[1])
          {
            digitalWrite(10, LOW);
          }
          else
          {
            phase = ON2;
          }
          break;
        case ON2:
          if (millis() - millisMem < d1[0] + d1[1] + d1[2])
          {
            digitalWrite(10, HIGH);
          }
          else
          {
            phase = OFF2;
          }
          break;
        case OFF2:
          if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3])
          {
            digitalWrite(10, LOW);
          }
          else
          {
            phase = ON3;
          }
          break;

        case ON3:
          if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4])
          {
            digitalWrite(10, HIGH);
          }
          else
          {
            phase = OFF3;
          }
          break;
        case OFF3:
          if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5])
          {
            digitalWrite(10, LOW);
          }
          else
          {
            phase = ON4;
          }
          break;

        case ON4:
          if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6])
          {
            digitalWrite(10, HIGH);
          }
          else
          {
            phase = OFF4;
          }
          break;
        case OFF4:
          if (millis() - millisMem  < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7])
          {
            digitalWrite(10, LOW);
          }
          else
          {
            phase = ON5;
          }
          break;

        case ON5:
          if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8])
          {
            digitalWrite(11, HIGH);
          }
          else
          {
            phase = OFF5;
          }
          break;
        case OFF5:
          if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9])
          {
            digitalWrite(11, LOW);
          }
          else
          {
            phase = ON6;
          }
          break;

        case ON6:
          if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10])
          {
            digitalWrite(11, HIGH);
          }
          else
          {
            phase = OFF6;
          }
          break;
        case OFF6:
          if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11])
          {
            digitalWrite(11, LOW);
          }
          else
          {
            phase = ON7;
          }
          break;
        case ON7:
          if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11] + d1[12])
          {
            digitalWrite(11, HIGH);
          }
          else
          {
            phase = OFF7;
          }
          break;
        case OFF7:
          if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11] + d1[12] + d1[13])
          {
            digitalWrite(11, LOW);
          }
          else
          {
            phase = ON8;
          }
          break;
        case ON8:
          if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11] + d1[12] + d1[13] + d1[14])
          {
            digitalWrite(11, HIGH);
          }
          else
          {
            phase = OFF8;
          }
          break;
        case OFF8:
          if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11] + d1[12] + d1[13] + d1[14] + d1[15])
          {
            digitalWrite(11, LOW);
          }
          else
          {
            phase = ON1;
            millisMem = millis();
          }
          break;
      }
      break;

    case MODUS2:
      switch (phase) //Modus 2 Wechsel Blinker
      {
        case ON1:
          if (millis() - millisMem < d2[0])
          {
            digitalWrite(10, HIGH), digitalWrite(11, LOW);
          }
          else
          {
            phase = OFF1;
          }
          break;
        case OFF1:
          if (millis() - millisMem < d2[0] + d2[1])
          {
            digitalWrite(10, LOW), digitalWrite(11, HIGH);
          }
          else
          {
            phase = ON1;
            millisMem = millis();
          }
          break;
      }
      break;

    case MODUS3:
      switch (phase) //Modus 3 Warnblinker
      {
        case ON1:
          if (millis() - millisMem < d3[0])
          {
            digitalWrite(10, HIGH), digitalWrite(11, HIGH);
          }
          else
          {
            phase = OFF1;
          }
          break;
        case OFF1:
          if (millis() - millisMem < d3[0] + d3[1])
          {
            digitalWrite(10, LOW), digitalWrite(11, LOW);
          }
          else
          {
            phase = ON1;
            millisMem = millis();
          }
          break;
      }
      break;
  }
}

Es gäbe noch Optimierungspotential, aber erstmal funktioniert das so.

gregorss · June 5, 2017, 2:57pm

agmue:
... Es gäbe noch Optimierungspotential, aber erstmal funktioniert das so. ...

Uh! Geil ... ich hatte die Sketche von Joggu erstmal ausgedruckt und überlegt, wie sich die drei Dinger mit möglichst geringem Aufwand verbinden lassen, und Du kommst mit der Lösung um die Ecke.

Ich hatte mir überlegt, die drei Sketche zunächst so zu ändern, dass es keine doppelten Variablen gibt, sie dann in separaten Tabs unterzubringen und einen neuen „Hauptsketch“ zu schreiben, der das mit der Modus-Umschaltung erledigt.

Das zu tun wäre zwar viel mehr gewesen, als ich sonst als „Forenhilfe“ tue, aber wer sich die Mühe gibt, mein Geschreibsel zu lesen und umzusetzen, hat meiner Meinung nach eine erstklassige Bedienung verdient.

Gruß

Gregor

Joggu · June 5, 2017, 4:36pm

Richtig Cool mit euch zusammen zu Arbeiten macht richtig viel spass. Ich Bedanke mich schon mal bei allen die mitarbeiten.

Ich habe mir den Sketch mal auf mein Arduino geladen und er funktioniert. Was jetzt noch fehlt sind die Modus kontrolllampen und das ein und ausschalten über Taster 3 und die kontrolllampe von Taster 3.
weis aber nicht recht wie und wo das ich die Modus LEDs im Sketch einsetzen muss und wie man das mit dem Tester 3 zum ein und ausschalten machen soll

gregorss · June 5, 2017, 4:50pm

Joggu:
Richtig Cool mit euch zusammen zu Arbeiten macht richtig viel spass. Ich Bedanke mich schon mal bei allen die mitarbeiten.

So ein Feedback gefällt mir Das ist besser als Karmapunkte (wobei auch die nicht soooo schlecht sind, gell ... wink!).

Joggu:
Ich habe mir den Sketch mal auf mein Arduino geladen und er funktioniert. Was jetzt noch fehlt sind die Modus kontrolllampen und das ein und ausschalten über Taster 3 und die kontrolllampe von Taster 3.
weis aber nicht recht wie und wo das ich die Modus LEDs im Sketch einsetzen muss und wie man das mit dem Tester 3 zum ein und ausschalten machen soll

Füge als jeweils erste Befehle nach jedem „case x:“ zwei Zeilen ein. In der ersten schaltest Du einfach alle LEDs aus, in der zweiten machst Du nur die eine Richtige an.

Das ist zwar ein bisschen „husch-husch“, aber es funktioniert.

Gruß

Gregor

agmue · June 5, 2017, 5:06pm

Bei den Tasten muß die Flanke abgefragt werden, was dann ein Flag (Merker) für einen Schleifendurchlauf setzt. Damit können dann Aktivitäten ausgelöst werden. Beim Einschalten passiert nichts, bis der Haupttaster S1 gdrückt wird:

#include <Wire.h>
#include "Adafruit_MCP23017.h"        // MCP23017 mittels I2C angeschlossen
Adafruit_MCP23017 mcp;
#define MCPI2CADR 0        // alle Adresspins an GND, Grundadresse 0x20 wird von der Bibliothek addiert.

const byte pinS1 = 2, pinS2 = 3, pinS3 = 4, pinS4 = 5, pinS5 = 6, pinS6 = 7, pinL2 = 14;
const byte pinB1 = 10, pinB2 = 11, pinR1 = 14, pinR2 = 15, pinR3 = 16;
enum Modus {MODUS1, MODUS2, MODUS3};
byte modus = MODUS1;
enum Phase {ON1, OFF1, ON2, OFF2, ON3, OFF3, ON4, OFF4, ON5, OFF5, ON6, OFF6, ON7, OFF7, ON8, OFF8}; // "Namen" fuer die Phasen
byte phase = ON1; // Enthaelt die aktuelle Phase
unsigned int d1[] = {50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50}; // Dauer der Phasen in ms
unsigned int d2[] = {230, 230, 230, 230}; // Dauer der Phasen in ms
unsigned int d3[] = {500, 400}; // Dauer der Phasen in ms
unsigned long tastenMillis, millisMem; // Merker fuer millis()
bool freigabe = false, aktS1, altS1, statS1, aktS2, altS2, statS2, aktS3, altS3, statS3, aktS4, altS4, statS4, aktS5, altS5, statS5, aktS6, altS6, statS6;

void setup()
{
  pinMode(pinB1, OUTPUT);
  pinMode(pinB2, OUTPUT);
  mcp.begin(MCPI2CADR);

  mcp.pinMode(pinS6, INPUT); // Schalter 6
  mcp.pullUp(pinS6, HIGH);  // Pull-Up Schalter 6

  mcp.pinMode(pinS5, INPUT); // Schalter 5
  mcp.pullUp(pinS5, HIGH);  // Pull-UP Schalter 5

  mcp.pinMode(pinS4, INPUT); // Schalter 4
  mcp.pullUp(pinS4, HIGH);  // Pull-Up Schalter 4

  mcp.pinMode(pinS3, INPUT); // Schalter 3
  mcp.pullUp(pinS3, HIGH);  // Pull-Up Schalter 3

  mcp.pinMode(pinS2, INPUT); // Schalter 2
  mcp.pullUp(pinS2, HIGH);  // Pull-Up Schalter 2

  mcp.pinMode(pinS1, INPUT); // Schalter 1
  mcp.pullUp(pinS1, HIGH);  // Pull-Up Schalter 1

  mcp.pinMode(8, OUTPUT); // Modus LED 3
  mcp.pinMode(9, OUTPUT); // Modus LED 2
  mcp.pinMode(10, OUTPUT); // Modus LED 1
  mcp.pinMode(11, OUTPUT); // LED 5
  mcp.pinMode(12, OUTPUT); // LED 4
  mcp.pinMode(13, OUTPUT); // LED 3
  mcp.pinMode(pinL2, OUTPUT); // LED 2
  mcp.pinMode(15, OUTPUT); // LED 1

  pinMode(pinR1, INPUT_PULLUP); // Relais 1
  pinMode(pinR1, OUTPUT);
  pinMode(pinR2, INPUT_PULLUP); // Relais 2
  pinMode(pinR2, OUTPUT);
  pinMode(pinR3, INPUT_PULLUP); // Relais 3
  pinMode(pinR3, OUTPUT);
}

void loop()
{
  statS1 = false;
  statS2 = false;
  statS3 = false;
  statS4 = false;
  statS5 = false;
  statS6 = false;
  if (millis() - tastenMillis >= 50)
  {
    tastenMillis = millis();
    altS1 = aktS1; aktS1 = mcp.digitalRead(pinS1);
    altS2 = aktS2; aktS2 = mcp.digitalRead(pinS2);
    altS3 = aktS3; aktS3 = mcp.digitalRead(pinS3);
    altS4 = aktS4; aktS4 = mcp.digitalRead(pinS4);
    altS5 = aktS5; aktS5 = mcp.digitalRead(pinS5);
    altS6 = aktS6; aktS6 = mcp.digitalRead(pinS6);
    if (!aktS1 && altS1) {
      statS1 = true;
    }
    if (!aktS2 && altS2) {
      statS2 = true;
    }
    if (!aktS3 && altS3) {
      statS3 = true;
    }
    if (!aktS4 && altS4) {
      statS4 = true;
    }
    if (!aktS5 && altS5) {
      statS5 = true;
    }
    if (!aktS6 && altS6) {
      statS6 = true;
    }
  }

  if (statS1)
  {
    freigabe = !freigabe;
  }

  if (freigabe)
  {
    if (statS2)
    {
      mcp.digitalWrite(pinL2, !mcp.digitalRead(pinL2)); // LED 2
      digitalWrite(pinR1, !digitalRead(pinR1)); // Relais 1
    }

    if (statS4)
    {
      digitalWrite(pinB1, LOW), digitalWrite(pinB2, LOW);
      if (modus < MODUS3)
      {
        modus++;
      } else {
        modus = MODUS1;
      }
      phase = ON1; // Enthaelt die aktuelle Phase
    }

agmue · June 5, 2017, 5:06pm

Fortsetzung:

    switch (modus)
    {
      case MODUS1:
        switch (phase) //Modus 1 Bliter
        {
          case ON1:
            if (millis() - millisMem < d1[0])
            {
              digitalWrite(pinB1, HIGH);
            }
            else
            {
              phase = OFF1;
            }
            break;
          case OFF1:
            if (millis() - millisMem < d1[0] + d1[1])
            {
              digitalWrite(pinB1, LOW);
            }
            else
            {
              phase = ON2;
            }
            break;
          case ON2:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2])
            {
              digitalWrite(pinB1, HIGH);
            }
            else
            {
              phase = OFF2;
            }
            break;
          case OFF2:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3])
            {
              digitalWrite(pinB1, LOW);
            }
            else
            {
              phase = ON3;
            }
            break;

          case ON3:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4])
            {
              digitalWrite(pinB1, HIGH);
            }
            else
            {
              phase = OFF3;
            }
            break;
          case OFF3:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5])
            {
              digitalWrite(pinB1, LOW);
            }
            else
            {
              phase = ON4;
            }
            break;

          case ON4:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6])
            {
              digitalWrite(pinB1, HIGH);
            }
            else
            {
              phase = OFF4;
            }
            break;
          case OFF4:
            if (millis() - millisMem  < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7])
            {
              digitalWrite(pinB1, LOW);
            }
            else
            {
              phase = ON5;
            }
            break;

          case ON5:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8])
            {
              digitalWrite(pinB2, HIGH);
            }
            else
            {
              phase = OFF5;
            }
            break;
          case OFF5:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9])
            {
              digitalWrite(pinB2, LOW);
            }
            else
            {
              phase = ON6;
            }
            break;

          case ON6:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10])
            {
              digitalWrite(pinB2, HIGH);
            }
            else
            {
              phase = OFF6;
            }
            break;
          case OFF6:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11])
            {
              digitalWrite(pinB2, LOW);
            }
            else
            {
              phase = ON7;
            }
            break;
          case ON7:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11] + d1[12])
            {
              digitalWrite(pinB2, HIGH);
            }
            else
            {
              phase = OFF7;
            }
            break;
          case OFF7:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11] + d1[12] + d1[13])
            {
              digitalWrite(pinB2, LOW);
            }
            else
            {
              phase = ON8;
            }
            break;
          case ON8:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11] + d1[12] + d1[13] + d1[14])
            {
              digitalWrite(pinB2, HIGH);
            }
            else
            {
              phase = OFF8;
            }
            break;
          case OFF8:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11] + d1[12] + d1[13] + d1[14] + d1[15])
            {
              digitalWrite(pinB2, LOW);
            }
            else
            {
              phase = ON1;
              millisMem = millis();
            }
            break;
        }
        break;

      case MODUS2:
        switch (phase) //Modus 2 Wechsel Blinker
        {
          case ON1:
            if (millis() - millisMem < d2[0])
            {
              digitalWrite(pinB1, HIGH), digitalWrite(pinB2, LOW);
            }
            else
            {
              phase = OFF1;
            }
            break;
          case OFF1:
            if (millis() - millisMem < d2[0] + d2[1])
            {
              digitalWrite(pinB1, LOW), digitalWrite(pinB2, HIGH);
            }
            else
            {
              phase = ON1;
              millisMem = millis();
            }
            break;
        }
        break;

      case MODUS3:
        switch (phase) //Modus 3 Warnblinker
        {
          case ON1:
            if (millis() - millisMem < d3[0])
            {
              digitalWrite(pinB1, HIGH), digitalWrite(pinB2, HIGH);
            }
            else
            {
              phase = OFF1;
            }
            break;
          case OFF1:
            if (millis() - millisMem < d3[0] + d3[1])
            {
              digitalWrite(pinB1, LOW), digitalWrite(pinB2, LOW);
            }
            else
            {
              phase = ON1;
              millisMem = millis();
            }
            break;
        }
        break;
    }
  } else {
    for (byte y = 8; y < 16; y++)
    {
      mcp.digitalWrite(y, LOW);
    }
    digitalWrite(pinB1, LOW);
    digitalWrite(pinB2, LOW);
    digitalWrite(pinR1, HIGH);
    digitalWrite(pinR2, HIGH);
    digitalWrite(pinR3, HIGH);
  }
}

Korrektur: Nur die Ausgänge werden auf LOW gesetzt, die Eingänge 0 bis 7 nicht:

    for (byte y = 8; y < 16; y++)

Joggu · June 5, 2017, 5:19pm

Habe das mal getestet mit den zwei Zeilen bei "Case X" funktioniert aber es gibt ein Problem und das ist das die LED beginne leicht zu fackern.
Am Strom verbraucht liegt es gloub ich nicht, weil wenn ich die Modus LED ausziehe ist das Problem immer noch vorhanden erst wenn ich es wieder aus dem Sketch lösche ist wieder gut

Joggu · June 5, 2017, 5:29pm

Habe jetzt mal auch noch die Relais in den Sketch auf genommen, und es funktioniert nicht schlecht.

Es ist bis jetzt einfach nur ein Taster und noch nicht ein Taster der als schalter funktioniert.

// http://forum.arduino.cc/index.php?topic=481621.msg3289409#msg3289409
// Suche Programieren fürs Beeden eines kleines Projektes

#include <Wire.h>
#include "Adafruit_MCP23017.h"        // MCP23017 mittels I2C angeschlossen
Adafruit_MCP23017 mcp;
#define MCPI2CADR 0        // alle Adresspins an GND, Grundadresse 0x20 wird von der Bibliothek addiert.

const byte pinS1 = 2, pinS2 = 3, pinS3 = 4, pinS4 = 5, pinS5 = 6, pinS6 = 7, pinL2 = 14;
const byte pinB1 = 10, pinB2 = 11, pinR1 = 14, pinR2 = 15, pinR3 = 16;
enum Modus {MODUS1, MODUS2, MODUS3};
byte modus = MODUS1;
enum Phase {ON1, OFF1, ON2, OFF2, ON3, OFF3, ON4, OFF4, ON5, OFF5, ON6, OFF6, ON7, OFF7, ON8, OFF8}; // "Namen" fuer die Phasen
byte phase = ON1; // Enthaelt die aktuelle Phase
unsigned int d1[] = {50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50}; // Dauer der Phasen in ms
unsigned int d2[] = {230, 230, 230, 230}; // Dauer der Phasen in ms
unsigned int d3[] = {500, 400}; // Dauer der Phasen in ms
unsigned long tastenMillis, millisMem; // Merker fuer millis()
bool freigabe = false, aktS1, altS1, statS1, aktS2, altS2, statS2, aktS3, altS3, statS3, aktS4, altS4, statS4, aktS5, altS5, statS5, aktS6, altS6, statS6;

void setup()
{
  pinMode(pinB1, OUTPUT);
  pinMode(pinB2, OUTPUT);
  mcp.begin(MCPI2CADR);

  mcp.pinMode(pinS6, INPUT); // Schalter 6
  mcp.pullUp(pinS6, HIGH);  // Pull-Up Schalter 6

  mcp.pinMode(pinS5, INPUT); // Schalter 5
  mcp.pullUp(pinS5, HIGH);  // Pull-UP Schalter 5

  mcp.pinMode(pinS4, INPUT); // Schalter 4
  mcp.pullUp(pinS4, HIGH);  // Pull-Up Schalter 4

  mcp.pinMode(pinS3, INPUT); // Schalter 3
  mcp.pullUp(pinS3, HIGH);  // Pull-Up Schalter 3

  mcp.pinMode(pinS2, INPUT); // Schalter 2
  mcp.pullUp(pinS2, HIGH);  // Pull-Up Schalter 2

  mcp.pinMode(pinS1, INPUT); // Schalter 1
  mcp.pullUp(pinS1, HIGH);  // Pull-Up Schalter 1

  mcp.pinMode(8, OUTPUT); // Modus LED 3
  mcp.pinMode(9, OUTPUT); // Modus LED 2
  mcp.pinMode(10, OUTPUT); // Modus LED 1
  mcp.pinMode(11, OUTPUT); // LED 5
  mcp.pinMode(12, OUTPUT); // LED 4
  mcp.pinMode(13, OUTPUT); // LED 3
  mcp.pinMode(pinL2, OUTPUT); // LED 2
  mcp.pinMode(15, OUTPUT); // LED 1

  pinMode(pinR1, INPUT_PULLUP); // Relais 1
  pinMode(pinR1, OUTPUT);
  pinMode(pinR2, INPUT_PULLUP); // Relais 2
  pinMode(pinR2, OUTPUT);
  pinMode(pinR3, INPUT_PULLUP); // Relais 3
  pinMode(pinR3, OUTPUT);
}

void loop()
{
  statS1 = false;
  statS2 = false;
  statS3 = false;
  statS4 = false;
  statS5 = false;
  statS6 = false;
  if (millis() - tastenMillis >= 50)
  {
    tastenMillis = millis();
    altS1 = aktS1; aktS1 = mcp.digitalRead(pinS1);
    altS2 = aktS2; aktS2 = mcp.digitalRead(pinS2);
    altS3 = aktS3; aktS3 = mcp.digitalRead(pinS3);
    altS4 = aktS4; aktS4 = mcp.digitalRead(pinS4);
    altS5 = aktS5; aktS5 = mcp.digitalRead(pinS5);
    altS6 = aktS6; aktS6 = mcp.digitalRead(pinS6);
    if (!aktS1 && altS1) {
      statS1 = true;
    }
    if (!aktS2 && altS2) {
      statS2 = true;
    }
    if (!aktS3 && altS3) {
      statS3 = true;
    }
    if (!aktS4 && altS4) {
      statS4 = true;
    }
    if (!aktS5 && altS5) {
      statS5 = true;
    }
    if (!aktS6 && altS6) {
      statS6 = true;
    }
  }

  if (statS1)
  {
    freigabe = !freigabe;
  }

  if (freigabe)
  {
    if (statS2)
    {
      mcp.digitalWrite(pinL2, !mcp.digitalRead(pinL2)); // LED 2
      digitalWrite(pinR1, !digitalRead(pinR1)); // Relais 1
    }

    if (statS4)
    {
      digitalWrite(pinB1, LOW), digitalWrite(pinB2, LOW);
      if (modus < MODUS3)
      {
        modus++;
      } else {
        modus = MODUS1;
      }
      phase = ON1; // Enthaelt die aktuelle Phase
    }

Joggu · June 5, 2017, 5:40pm

Teil 2

switch (modus)
    {
      case MODUS1:
        switch (phase) //Modus 1 Bliter
        {
          case ON1:
            if (millis() - millisMem < d1[0])
            {
              digitalWrite(pinB1, HIGH);
            }
            else
            {
              phase = OFF1;
            }
            break;
          case OFF1:
            if (millis() - millisMem < d1[0] + d1[1])
            {
              digitalWrite(pinB1, LOW);
            }
            else
            {
              phase = ON2;
            }
            break;
          case ON2:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2])
            {
              digitalWrite(pinB1, HIGH);
            }
            else
            {
              phase = OFF2;
            }
            break;
          case OFF2:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3])
            {
              digitalWrite(pinB1, LOW);
            }
            else
            {
              phase = ON3;
            }
            break;

          case ON3:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4])
            {
              digitalWrite(pinB1, HIGH);
            }
            else
            {
              phase = OFF3;
            }
            break;
          case OFF3:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5])
            {
              digitalWrite(pinB1, LOW);
            }
            else
            {
              phase = ON4;
            }
            break;

          case ON4:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6])
            {
              digitalWrite(pinB1, HIGH);
            }
            else
            {
              phase = OFF4;
            }
            break;
          case OFF4:
            if (millis() - millisMem  < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7])
            {
              digitalWrite(pinB1, LOW);
            }
            else
            {
              phase = ON5;
            }
            break;

          case ON5:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8])
            {
              digitalWrite(pinB2, HIGH);
            }
            else
            {
              phase = OFF5;
            }
            break;
          case OFF5:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9])
            {
              digitalWrite(pinB2, LOW);
            }
            else
            {
              phase = ON6;
            }
            break;

          case ON6:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10])
            {
              digitalWrite(pinB2, HIGH);
            }
            else
            {
              phase = OFF6;
            }
            break;
          case OFF6:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11])
            {
              digitalWrite(pinB2, LOW);
            }
            else
            {
              phase = ON7;
            }
            break;
          case ON7:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11] + d1[12])
            {
              digitalWrite(pinB2, HIGH);
            }
            else
            {
              phase = OFF7;
            }
            break;
          case OFF7:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11] + d1[12] + d1[13])
            {
              digitalWrite(pinB2, LOW);
            }
            else
            {
              phase = ON8;
            }
            break;
          case ON8:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11] + d1[12] + d1[13] + d1[14])
            {
              digitalWrite(pinB2, HIGH);
            }
            else
            {
              phase = OFF8;
            }
            break;
          case OFF8:
            if (millis() - millisMem < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7] + d1[8] + d1[9] + d1[10] + d1[11] + d1[12] + d1[13] + d1[14] + d1[15])
            {
              digitalWrite(pinB2, LOW);
            }
            else
            {
              phase = ON1;
              millisMem = millis();
            }
            break;
        }
        break;

      case MODUS2:
        switch (phase) //Modus 2 Wechsel Blinker
        {
          case ON1:
            if (millis() - millisMem < d2[0])
            {
              digitalWrite(pinB1, HIGH), digitalWrite(pinB2, LOW);
            }
            else
            {
              phase = OFF1;
            }
            break;
          case OFF1:
            if (millis() - millisMem < d2[0] + d2[1])
            {
              digitalWrite(pinB1, LOW), digitalWrite(pinB2, HIGH);
            }
            else
            {
              phase = ON1;
              millisMem = millis();
            }
            break;
        }
        break;

      case MODUS3:
        switch (phase) //Modus 3 Warnblinker
        {
          case ON1:
            
          
            if (millis() - millisMem < d3[0])
            {
              digitalWrite(pinB1, HIGH), digitalWrite(pinB2, HIGH);
            }
            else
            {
              phase = OFF1;
            }
            break;
          case OFF1:
            if (millis() - millisMem < d3[0] + d3[1])
            {
              digitalWrite(pinB1, LOW), digitalWrite(pinB2, LOW);
            }
            else
            {
              phase = ON1;
              millisMem = millis();
            }
            break;
        }
        break;
    }
  } else {
    for (byte y = 0; y < 16; y++)
    {
      mcp.digitalWrite(y, LOW);
    }
    digitalWrite(pinB1, LOW);
    digitalWrite(pinB2, LOW);
    digitalWrite(pinR1, HIGH);
    digitalWrite(pinR2, HIGH);
    digitalWrite(pinR3, HIGH);
  }

 
 
  if (mcp.digitalRead(7) == LOW)             // Relais 3 + LED 5
  {
    mcp.digitalWrite(11, HIGH); digitalWrite(16, LOW);}
    
  else
  {
    mcp.digitalWrite(11, LOW); digitalWrite(16,HIGH); 
  }
  

   if (mcp.digitalRead(6) == LOW)          // Relais 2 + LED 4
  {
    mcp.digitalWrite(12, HIGH);digitalWrite(15,LOW);}
    
  else
  {
    mcp.digitalWrite(12, LOW);digitalWrite(15,HIGH);
  }


   if (mcp.digitalRead(3) == LOW)          // Relais 1 + LED 2
  {
    mcp.digitalWrite(14, HIGH);digitalWrite(14,LOW);}
    
  else
  {
    mcp.digitalWrite(14, LOW);digitalWrite(14,HIGH);
    
  }
}

[/code]

agmue · June 5, 2017, 7:00pm

Joggu:
... aber es gibt ein Problem ...

Relais 1 + LED 2 ist auch von mir schon berücksichtigt, also doppelt, das beißt sich.

Joggu · June 5, 2017, 8:37pm

Habe es gerade gefunden im Sketch aber irgend wie tut sich nichts wenn ich den schalter drücke.
Weis aber nicht wie so.

Topic		Replies	Views
Arduinos über USB Verbinden Projekt Deutsch	25	4220	May 6, 2021
Projekt mit Taster, Schalter, LED - allgemeine Fragen Deutsch	12	2557	May 6, 2021
Programm funktioniert nicht Deutsch	24	2442	May 6, 2021
Anfänger, neu im Forum Deutsch	72	7631	May 6, 2021
LED Ausschaltung nach einer bestimmten Zeit Deutsch	7	1624	May 6, 2021

Suche Programieren fürs Beeden eines kleines Projektes

Related topics