[darex120]

Witam mam pewien problem , mianowicie , podpięte mam krańcówki pod pin D7 i D8 i nie mogę ogarnąć tego
aby po naciśnięciu krańcówki D7 oraz D8 uruchamiał się dalszy program jak ruszę krańcówką D7 czyli najpierw
nacisnę a potem puszczę program rusza jeśli krańcówka jest cały czas naciśnieta nie rusza i teraz pytanie
gdzie tkwi problem poniżej przesyłam kod

Kod:

const byte led[10] = {0, 1, 2, 3, A0, A1, A2, A5, A4, A3}; //numery pinow diod zaczynajac od diody 1  w miejscu led[5] wpisac rowniez ilosc diod
byte ledMax = 10; //liczba diod

const byte Switch[10] = {4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; //numery pinow wlacznikow zaczynajac od wlacznika 1 itd. mozna dodac wiecej pozycji po przecinki w miejscu Switch[8] wpisac rowniec ilosc wlacznikow
byte switchMax = 10;   //lczba wlacznikow
/*
  ledy :
  1 silnik drzwi lewych OTWIERANIE
  2 silnik drzwi prawych OTWIERANIE
  3 silnik drzwi lewych ZAMYKANIE
  4 silnik drzwi prawych ZAMYKANIE
  5 koło cały czas ma się kręcic
  6 kołyska cały czas ma się kręcic
  7 mp3 i światło cały czas właczone
  8 dzwon
  9 dzwonnik w LEWO
  10 dzwonnik w PRAWO

  przyciski:

  1 przycisk start
  2 krańcówka drzwi lewych otwarcie
  3 krańcówka drzwi prawych otwarcie
  4 krancowka dzwonnika w lewo
  5 krańcówka dzwonnika w prawo
  6 krańcówka drzwi lewych zamknięcie
  7 krańcówka drzwi prawych zamknięcie
  8 przycisk stop
  9
  10
*/
bool switchStan_1;   // stan wlacznika 1 przycisk start
bool switchStan_2;   // stan wlacznika 2 krancowka otwarcia drzwi lewych
bool switchStan_3;   // stan wlacznika 3 krancowka otwarcia drzwi prawych
bool switchStan_4;   // stan wlacznika 4 krancowka dzwonnika w lewo
bool switchStan_5;   // stan wlacznika 5 krancowka dzwonnika w prawo
bool switchStan_6;   // stan wlacznika 6 krancowka zamkniecia drzwi lewych
bool switchStan_7;   // stan wlacznika 7 krancowka zamniecia drzwi prawych
bool switchStan_8;   // stan wlacznika 8 przycisk stop

bool ringingManPermit;  // zezwolenie na cykl dzwonnika
bool stopSequencePermit; // zezwolenie za wykonanie cyklu zakończenia sekwencji

bool startPermit = 1; // zezwolenie na start

bool couting_1;   // zezwolenie odliczania wlaczenia swiatla i mp3 po wyzwoleniu wlacznika 2 i 3
bool couting_2;   // zezwolenie odliczania wlaczenia kolyski
bool couting_3;   // zezwolenie odliczania wlaczenia kola
bool couting_4;   // zezwolenie odliczania wlaczenia dzwonnika w lewo
bool couting_5;   // zezwolenie odliczania bicia dzwona
bool couting_6;   // zezwolenie odliczania czekania dzwonnika na kolejny ruch

long timeCouting_1 = 1000;  // czas po ktorym ma wlaczyc sie swiatlo po otwarciu drzwi
long timeCouting_2 = 1000;  // czas po ktorym ma wlaczyc sie kolyska po wlaczeniu swiatla
long timeCouting_3 = 1000;  // czas po ktorym ma wlaczyc sie kolo po wlaczeniu swiatla
long timeCouting_4 = 1000;  // czas po ktorym ma wlaczyc sie dzwonnik po wlaczeniu kola
long timeCouting_5 = 2000;  // czas bicia dzwona
long timeCouting_6 = 3000;  // czas czekania dzownnika do kolejnego przejazdu do dzwona

long timeStop_1 = 1000; // czas po ktorym ma sie wylaczyc kolo od czasu powortu dzownnika
long timeStop_2 = 1000; // czas po ktorym ma sie wylaczyc kolyska po wylaczeniu kola
long timeStop_3 = 1000; // czas po ktorym ma sie wylaczyc swiatlo i mp3 po wylaczeniu kolyski
long timeStop_4 = 1000; // czas po ktorym maja sie zamknac drzwi po wylaczeniu swiatla


unsigned long newTime;    // aktualny czas od uruchomienia urzadzenia

unsigned long oldTime_1;  // przechowywanie czasu swiatla i mp3
unsigned long oldTime_2;  // przechowywanie czasu kolyski
unsigned long oldTime_3;  // przechowywanie czasu kola
unsigned long oldTime_4;  // przechowywanie czasu dzwonnika
unsigned long oldTime_5;  // przechowywanie czasu dzwona
unsigned long oldTime_6;  // przechowywanie czasu oczekiwania dzwonnika

unsigned long oldTimeState;


void setup() {
  //  Serial.begin(9600);
  for (byte i = 0; i < switchMax; i++) {   //ustawienie pinow jako wejscie wlacznikow z podciagnieciem do zasilania (PULLUP)
    pinMode(Switch[i], INPUT_PULLUP);
  }
  for (byte i = 0; i < ledMax; i++) {  //ustawienie pinow jako wyjscie diod
    pinMode(led[i], OUTPUT);
  }
}

void loop() {

  switching_1();  // funkcja wlacznika 1
  if (startPermit && !stopSequencePermit) {
    switching_2();  // funkcja wlacznika 2 i 3
    ringingMan();   // funkcja dzwonnika
  }
  if ((!digitalRead(Switch[7])) && (startPermit)) {
    startPermit = false;
    stopSequencePermit = true;
  }
  if ((!startPermit) && (stopSequencePermit)) {
    stopSequence();   //funkcja koncowa
  }

  if (!startPermit) {
    if (!digitalRead(Switch[5])) {
      digitalWrite(led[2], LOW);
    }
    if (!digitalRead(Switch[6])) {
      digitalWrite(led[3], LOW);
    }
  }
  if (!digitalRead(Switch[3])) {
    digitalWrite(led[8], LOW);
  }
  if (!digitalRead(Switch[4])) {
    digitalWrite(led[9], LOW);
  }
  stateTimes();             // funkja wykonawcza po wyzwoleniu odliczania
  // outputsAndInputsStateControl();
}
void switching_1() {

  if (digitalRead(Switch[0])) {
    switchStan_1 = false;
  }
  if ((!digitalRead(Switch[0])) && (!switchStan_1)) {
    delay(20);
    if ((!digitalRead(Switch[0])) && (!switchStan_1)) {
      switchStan_1 = true;
      digitalWrite(led[0], HIGH);
      digitalWrite(led[1], HIGH);
      digitalWrite(led[2], LOW);
      digitalWrite(led[3], LOW);
      startPermit = true;
    }
  }
}

void switching_2() {
  if (digitalRead(Switch[1])) {
    switchStan_2 = false;
  }
  if (digitalRead(Switch[2])) {
    switchStan_3 = false;
  }
  if (!digitalRead(Switch[1])) {
    digitalWrite(led[0], LOW);
  }
  if (!digitalRead(Switch[2])) {
    digitalWrite(led[1], LOW);
  }
  if ((!digitalRead(Switch[1])) && (!digitalRead(Switch[2]))) {
    delay(20);
    if ((!digitalRead(Switch[1])) && (!digitalRead(Switch[1]))) {
      digitalWrite(led[0], LOW);
      digitalWrite(led[1], LOW);
      switchStan_2 = true, switchStan_3 = true;
      couting_1 = true;
      oldTime_1 = millis();
    }
  }
  else {
    if (couting_1 == false) {
      oldTime_1 = millis();
    }
  }
}

void ringingMan() {
  if (ringingManPermit) {
    if ((!digitalRead(Switch[3])) && (!switchStan_5)) {
      digitalWrite(led[8], LOW);
      digitalWrite(led[7], HIGH);
      couting_5 = true;
      switchStan_5 = true;
      switchStan_6 = false;
      oldTime_5 = millis();
    }
    if ((!digitalRead(Switch[4])) & (!switchStan_6)) {
      digitalWrite(led[9], LOW);
      couting_6 = true;
      switchStan_6 = true;
      oldTime_6 = millis();
    }
  }
}

void stopSequence() {
  digitalWrite(led[7], LOW);
  digitalWrite(led[0], LOW);
  digitalWrite(led[1], LOW);
  if (digitalRead(Switch[4])) {
    digitalWrite(led[9], HIGH);
    digitalWrite(led[8], LOW);
  }
  while (digitalRead(Switch[4]) == HIGH) {
  }
  if (!digitalRead(Switch[4])) {
    Serial.println("wylaczono");
    digitalWrite(led[9], LOW);
    digitalWrite(led[8], LOW);
  }
  delay(timeStop_1);
  digitalWrite(led[4], LOW);
  delay(timeStop_2);
  digitalWrite(led[5], LOW);
  delay(timeStop_3);
  digitalWrite(led[6], LOW);
  delay(timeStop_4);
  digitalWrite(led[2], HIGH);
  digitalWrite(led[3], HIGH);

  couting_1 = false;
  couting_2 = false;
  couting_3 = false;
  couting_4 = false;
  couting_5 = false;
  couting_6 = false;
  stopSequencePermit = false;
}

void stateTimes() {

  newTime = millis();

  if (couting_1 == true) {
    if ((newTime - oldTime_1) >= timeCouting_1) {    // czas po ktorym nastapi wlaczanie swiatla i mp3 po otwarciu drzwi
      digitalWrite(led[6], HIGH);
      couting_1 = false;
      couting_2 = true;
      oldTime_2 = newTime;
    }
  }

  if (couting_2 == true) {
    if ((newTime - oldTime_2) >= timeCouting_2) {    // czas po ktorym nastapi wlaczanie kolyski po wlaczeniu swiatla
      digitalWrite(led[5], HIGH);
      couting_2 = false;
      couting_3 = true;
      oldTime_3 = newTime;
    }
  }

  if (couting_3 == true) {
    if ((newTime - oldTime_3) >= timeCouting_3) {    // czas po ktorym nastapi wlaczanie kola po wlaczeniu kolyski
      digitalWrite(led[4], HIGH);
      couting_3 = false;
      couting_4 = true;
      oldTime_4 = newTime;
    }
  }

  if (couting_4 == true) {
    if ((newTime - oldTime_4) >= timeCouting_4) {    // czas po ktorym nastapi wlaczanie dzwonnika w lewo po wlaczeniu kola
      digitalWrite(led[8], HIGH);
      ringingManPermit = true;
      couting_4 = false;
      switchStan_5 = false;
    }
  }

  if (couting_5 == true) {
    if ((newTime - oldTime_5) >= timeCouting_5) {    // czas bicia dzwona
      digitalWrite(led[7], LOW);
      digitalWrite(led[9], HIGH);
      switchStan_5 = true;
      couting_5 = false;
      switchStan_6 = false;
    }
  }

  if (couting_6 == true) {
    if ((newTime - oldTime_6) >= timeCouting_6) {    // czas oczekiwania dzwonnika na kolejny ruch
      digitalWrite(led[8], HIGH);
      switchStan_5 = false;
      couting_6 = false;
    }
  }
}

void outputsAndInputsStateControl() {


  byte x = 1;
  byte y = 1;
  newTime = millis();
  if (newTime - oldTimeState >= 1000) {
    for (byte i = 0; i < ledMax; i++) {
      Serial.print("LED:");
      Serial.print(x);
      Serial.print(" = ");
      Serial.println(digitalRead(led[i]));
      x++;
    }
    for (byte i = 0; i < switchMax; i++) {
      Serial.print("Switch:");
      Serial.print(y);
      Serial.print(" = ");
      Serial.println(digitalRead(Switch[i]));
      y++;
    }
    oldTimeState = newTime;
  }
}

//******* koniec programu **********

[kaczakat]

Pewnie w swojej głowie masz to pokładane jak to ma działać, ale przekazanie tu wyrwanych paru informacji nie wystarczy, bo ja w głowie nie mam reszty tego co Ty masz w swojej.
Na pewno nie pomyliłeś numerów pinów z numerami porządkowymi indeksów tablicy? Może kod będzie bardziej czytelny gdy dodasz typ wyliczeniowy enum
enum wejscia { kr_start, kr_drzwiL_ON, kr_drzwiP_ON, itd};
Potem możesz użyć
if (digitalRead(Switch[kr_start]))
Teraz masz numerowanie w tablicy od 0-9, pinów od 4-13, a opis tych wejść od 1-10.

[darex120]

Jeśli chodzi o pomyłkę z pinami to jest to nie możliwe ponieważ w chwili obecnej wszystko działa , oprócz właśnie startu dalszego programy , postaram się to opisać naciskam przycisk start uruchamiają mi się dwie diody które odpowiedzialne są za sterowanie silnikami od otwarcia drzwi , drzwi się otwierają do momentu dotknięcia krańcówek , i właśnie w tym momencie kiedy drzwi dotkną krańcówek po zadanym czasie ma się uruchamiać dalszy ciąg programu , a tak nie jest do momentu kiedy zejdę z krańcówki z drzwi lewych , wtedy program zaczyna działać , jak nacisnę przycisk stop to wszystko po kolei się wyłącza i drzwi się zamykają do momentu dotknięcia krańcówek zamkniecią takze po stronie stopu i zamknięcia jest wszystko ok

[kaczakat]

Wszystko działa, tylko że nie działa.
Może napisz to inaczej.
W loop daj funkcję
obsługaDrzwiL();
W funkcji obsługaDrzwiL drzwi napisz
void obsługaDrzwiL()

{
static uint8_t stanDrzwiL=0
switch (stanDrzwiL)
{

case Otwieranie:
Chyba dobrze zacząć od tego, jak program się włącza i nie wiesz gdzie są drzwi to może lepiej je otworzyć,
jak są w stanie otwartym to program wykrywa krańcówkę i od razu przechodzi do stanu dalej.
sprawdzasz czy zadziała krańcówka, jeśli nie to włączasz silnik,  jesli tak to wyłacz i sanDrzwiL++
break;

case Otwarte:
sprawdzasz czy zacząć zamykac, jeśli tak to sanDrzwiL++;

break;

case Zamykanie:
włączasz silnik i sprawdzasz czy zadziała krańcówka, jesli tak to sanDrzwiL++;
break;

case Zamknięte:
sprawdzasz czy zacząć otwierać, jeśli tak to sanDrzwiL=0;
break;

case Awaria:
co zrobisz, gdy wykryjesz stan awaryjny
break;

default:
break;
}
}

Wtedy możesz też dodać wtedy sprawdzanie czasu, że jak masz stan otwieranie, silnik pracuje, to drzwi powinny się otworzyć w 5s, jak nie to pewnie w coś walnęło, silnik się zatarł, cofnij drzwi przez 2s i wyłącz w stan awarii. Albo jest włączona krańcówka otwarcia, zamykasz drzwi, to też się powinna zwolnić po np. 2s.
Żeby za słowami Otwieranie, Zamykanie,itd. kryły się liczby to już w poprzednim poście masz enum.
Inne czynności wykonujesz, gdy czekasz na włączenie krańcówki bo drzwi się otwierają/zamykają, a inne gdy oczekujesz na otwieranie/zamykanie, bo drzwi są oparte na krańcach zatrzymane.

Przykładowy program, tylko to akurat był siłownik liniowy i miał wbudowane krańcówki, sterowanie jest czasem, ale pokazuje jak można łatwo zliczać czas robiąc coś gdy w loop pojawi sie flaga 1s, zliczając sekundy, albo podobnie, gdy sie chce większą rozdzielczość, można zliczać dziesiątki ns, eliminując z programu DELAY:

Kod:

#include <AnalogKeypad.h>

const int KeypadMap[] = {0, 50, 100, 200, 400};

const uint16_t KeypadHoldTimeMs = 1000;
const uint8_t KeypadAnalogPin = A0;

AnalogKeypad keypad(KeypadAnalogPin, KeypadMap, countof(KeypadMap), KeypadHoldTimeMs);

//******************************************Silnik
enum rozdzialy { zamkniety, otwieranie, otwarty, zamykanie, awaria };
const uint8_t s1=4,s2=5;
uint8_t etap;

//******************************************CZAS

uint32_t czasTeraz,czasPoprzedni,tik=10;
uint8_t nTik,sekundy,minuty,godziny,dni;
bool fnTik,fsekundy,fminuty,fgodziny,fdni;



void setup() {
  // put your setup code here, to run once:
pinMode(s1,OUTPUT);
pinMode(s2,OUTPUT);
Serial.begin(115200);

}

void loop() {
czas();

  if(fnTik) //zamiast dely 10 to mozna sprawdzac stan przyciskow co 10ms
{
  keypad.loop(ButtonHandler); //
//  keypadAction();
}
  // put your main code here, to run repeatedly:
if(fnTik) drzwi();
if(fsekundy) Serial.println(etap);
}



void drzwi()
// zamkniety, otwieranie, otwarty, zamykanie

{
  static uint8_t czaspracy=0;
switch (etap)
{
case zamkniety:
sStop();
//if (fminuty) etap++; //czasowe dzialanie do testow
break;

case otwieranie:
if (fsekundy)
{
  sOtwieraj();
  czaspracy++;
}
if(czaspracy>=50)
{
  czaspracy=0;
  etap++;
}
break;

case otwarty:
//if (fminuty) etap++; //czasowe dzialanie do testow
break;

case zamykanie:
if (fsekundy)
{
  sZamykaj();
  czaspracy++;
}
if(czaspracy>=50)
{
  czaspracy=0;
  etap=0;
}
break;

case awaria:
sStop();
break;


default:
sStop();

break;     
}
}


void sOtwieraj()
{
digitalWrite(s1, HIGH);
digitalWrite(s2, LOW); 
}
void sZamykaj()
{
digitalWrite(s1, LOW);
digitalWrite(s2, HIGH);   
}

void sStop()
{
digitalWrite(s1, LOW);
digitalWrite(s2, LOW);
}

void ButtonHandler(const ButtonParam& param)
{
//  Serial.print(param.button);
//  Serial.print(" ");
 
  switch (param.state)
  {
    case ButtonState_Up:
//    Serial.print("Up");
    break;
   
    case ButtonState_Down:
//    Serial.print("Down");
    break;
   
    case ButtonState_Click:
//    Serial.print("Click");
// 0 3 4
if(   param.button==0) etap=otwieranie;
if(   param.button==3) etap=zamykanie;
if(   param.button==4) etap=zamkniety;
//     Serial.print(param.button);
    break;
   
    case ButtonState_DoubleClick:
//    Serial.print("Double Click");
    break;
   
    case ButtonState_Hold:
//    Serial.print("Hold");
    break;
  }
 
//  Serial.println();
}


void czas()
{
  czasTeraz=millis();
fnTik=fsekundy=fminuty=fgodziny=fdni=0;
if((uint32_t)(czasTeraz-czasPoprzedni)>=tik)
{
  czasPoprzedni=czasTeraz;
  fnTik=1;
  nTik++;
  if(nTik>=(1000/tik))
  {
    nTik=0;
    sekundy++;
    fsekundy=1;
     if (sekundy>=60)
    {
      sekundy=0;
      minuty++;
      fminuty=1;
      if (minuty>=60)
      {
        minuty=0;
        godziny++;
        fgodziny=1;
        if (godziny>=24)
        {
          godziny=0;
          fdni=1;
          dni++;
   
        }
      }
    }
  }
}
}

Tak samo ze switch case można obsługiwać miganie LED, debounce przycisków (choć jest tyle gotowych bibliotek), czy włączenie na określony czas muzyki. 
Zamiast definiować zmienne globalne możesz w funkcji zrobić zmienną static, działa tak samo, przenosi wartość do kolejnego wywołania tej funkcji, ale jest widoczna tylko wewnątrz tej funkcji, możesz zrobić 10 takich funkcji, do różnych czynności i każda może mieć taką samą zmienną "czaspracy", która będzie osobno zmieniać swoje wartości dla każdej funkcji niezależnie.

[darex120]

Wszystko ładnie pięknie opisane dziękuje , ale jak ja mam to zmienić w programie , bo za nic w świecie narazie to ja jestem w przedszkolu jeśli chodzi o programowanie , ogólnie jest to program do sterowania sterownikiem do żłobka

[kaczakat]

Chyba nie to chcesz usłyszeć, ale napisz go od nowa używając moich wskazówek, albo po prostu poczekaj, może ktoś inny będzie miał lepszy pomysł.
Za drugim razem szybciej leci.
Poza tym nie używasz pinów 12 i 13, a użyłeś 0 i 1, te dwa lepiej zostawić na koniec, 0 i 1 są podłączone do UART/USB, jak coś tam podłączysz nie halo to można uwalić płytkę albo konwerter UART/USB, ty mu np. wystawiasz tam 1, a UART próbuje 0, prąd leci.

[darex120]

Oj tylko nie to swięta tuż tuż :-) co do 0,1 to podłączone są tam tylko diody led także nic się nie stanie , co do napisania programu od początku to słabo to widzę bynajmniej ja nie dam rady , może kolego masz messengera lub mail , to wysłałbym Ci dokumentacje oraz filmik jak to w tej chwili pracuje

[kaczakat]

Maila mam, ale sam mam zaległości, dlatego wrzuciłem Ci przykład jak sam robiłem otwieranie drzwi, tak jak podpatrzyłem w cudzych programach, by nie robić delay.
Filmik możesz nagrać i wrzucić na youtube, ustawić prywatny czy jakoś tak, nikt nie zobaczy jeśli tu w poście nie trafi na link do niego.
Jeżeli jakieś dłużej trwające procesy można podzielić na etapy to dzielę je na etapy.

[darex120]

podaje link do filmiku https://youtu.be/nyYNlHMe-L0

[kaczakat]

Obejrzałem film i dalej nie wiem, którą krańcówkę odblokowałeś, żeby program ruszył jak chcesz. Ruszyłeś drzwiami lewymi czy prawymi?  Jak widzę, że na filmie ruszyłeś lewymi, ale dla Jezuska to są prawe, w samochodzie byłyby to prawe, w Castoramie do salonu lewe.
Rozumiesz jak prezentujesz swoje myśli w filmie i w programie i dlaczego nic z nich nie wiadomo?



W funkcji switching_2 masz wyłączenie drzwi lewych i prawych , potem wyłączenie ze sprawdzeniem drgań, ale już cyferki się w oczach mienią i zrobiłeś błędy, okolice linii 159.
Pisanie programu w taki sposób jak pisałem we wcześniejszych postach to jak przebieranie maku z popiołu, a każda linijka więcej kodu, to większa kupka do przebrania.

Kod:

const byte led[10] = {0, 1, 2, 3, A0, A1, A2, A5, A4, A3}; //numery pinow diod zaczynajac od diody 1  w miejscu led[Lkolyska] wpisac rowniez ilosc diod
byte ledMax = 10; //liczba diod
enum Ledy { LSilnikLOtwieranie, LSilnikPOtwieranie,LSilnikLZamykanie,LSilnikPZamykanie,LKolo,Lkolyska,LMP3,LDzwon,LDzwonnikL, LDzwonnikP };

const byte Switch[10] = {4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; //numery pinow wlacznikow zaczynajac od wlacznika 1 itd. mozna dodac wiecej pozycji po przecinki w miejscu Switch[8] wpisac rowniec ilosc wlacznikow
enum wejscia { WStart, WDrzwiLOpen, WDrzwiPOpen, WDzwonnikL,WDzwonnikP,WDrzwiLClose, WDrzwiPClose,WStop};
byte switchMax = 10;   //lczba wlacznikow
/*
  ledy :
  0 silnik drzwi lewych OTWIERANIE
  1 silnik drzwi prawych OTWIERANIE
  2 silnik drzwi lewych ZAMYKANIE
  3 silnik drzwi prawych ZAMYKANIE
  4 koło cały czas ma się kręcic
  5 kołyska cały czas ma się kręcic
  6 mp3 i światło cały czas właczone
  7 dzwon
  8 dzwonnik w LEWO
  9 dzwonnik w PRAWO

  przyciski:

  0 przycisk start
  1 krańcówka drzwi lewych otwarcie
  2 krańcówka drzwi prawych otwarcie
  3 krancowka dzwonnika w lewo
  4 krańcówka dzwonnika w prawo
  5 krańcówka drzwi lewych zamknięcie
  6 krańcówka drzwi prawych zamknięcie
  7 przycisk stop
  8
  9
*/
bool switchStan_Start;   // stan wlacznika 1 przycisk start
bool switchStan_DrzwiLOpen;   // stan wlacznika 2 krancowka otwarcia drzwi lewych
bool switchStan_DrzwiPOpen;   // stan wlacznika 3 krancowka otwarcia drzwi prawych
bool switchStan_DzwonnikL;   // stan wlacznika 4 krancowka dzwonnika w lewo
bool switchStan_DzwonnikP;   // stan wlacznika 5 krancowka dzwonnika w prawo
bool switchStan_DrzwiLClose;   // stan wlacznika 6 krancowka zamkniecia drzwi lewych
bool switchStan_DrzwiPClose;   // stan wlacznika 7 krancowka zamniecia drzwi prawych
bool switchStan_Stop;   // stan wlacznika 8 przycisk stop

bool ringingManPermit;  // zezwolenie na cykl dzwonnika
bool stopSequencePermit; // zezwolenie za wykonanie cyklu zakończenia sekwencji

bool startPermit  ; // zezwolenie na start PO CO TU 1 skoro i tak wylacza pierwsza funkcja LOOP

bool couting_1;   // zezwolenie odliczania wlaczenia swiatla i mp3 po wyzwoleniu wlacznika 2 i 3
bool couting_2;   // zezwolenie odliczania wlaczenia kolyski
bool couting_3;   // zezwolenie odliczania wlaczenia kola
bool couting_4;   // zezwolenie odliczania wlaczenia dzwonnika w lewo
bool couting_5;   // zezwolenie odliczania bicia dzwona
bool couting_6;   // zezwolenie odliczania czekania dzwonnika na kolejny ruch

long timeCouting_1 = 1000;  // czas po ktorym ma wlaczyc sie swiatlo po otwarciu drzwi
long timeCouting_2 = 1000;  // czas po ktorym ma wlaczyc sie kolyska po wlaczeniu swiatla
long timeCouting_3 = 1000;  // czas po ktorym ma wlaczyc sie kolo po wlaczeniu swiatla
long timeCouting_4 = 1000;  // czas po ktorym ma wlaczyc sie dzwonnik po wlaczeniu kola
long timeCouting_5 = 2000;  // czas bicia dzwona
long timeCouting_6 = 3000;  // czas czekania dzownnika do kolejnego przejazdu do dzwona

long timeStop_1 = 1000; // czas po ktorym ma sie wylaczyc kolo od czasu powortu dzownnika
long timeStop_2 = 1000; // czas po ktorym ma sie wylaczyc kolyska po wylaczeniu kola
long timeStop_3 = 1000; // czas po ktorym ma sie wylaczyc swiatlo i mp3 po wylaczeniu kolyski
long timeStop_4 = 1000; // czas po ktorym maja sie zamknac drzwi po wylaczeniu swiatla


unsigned long newTime;    // aktualny czas od uruchomienia urzadzenia

unsigned long oldTime_1;  // przechowywanie czasu swiatla i mp3
unsigned long oldTime_2;  // przechowywanie czasu kolyski
unsigned long oldTime_3;  // przechowywanie czasu kola
unsigned long oldTime_4;  // przechowywanie czasu dzwonnika
unsigned long oldTime_5;  // przechowywanie czasu dzwona
unsigned long oldTime_6;  // przechowywanie czasu oczekiwania dzwonnika

unsigned long oldTimeState;


void setup() {
  //  Serial.begin(9600);
  for (byte i = 0; i < switchMax; i++) {   //ustawienie pinow jako wejscie wlacznikow z podciagnieciem do zasilania (PULLUP)
    pinMode(Switch[i], INPUT_PULLUP);
  }
  for (byte i = 0; i < ledMax; i++) {  //ustawienie pinow jako wyjscie diod
    pinMode(led[i], OUTPUT);
  }
}

void loop() {

  switching_1();  // funkcja wlacznika 1
  if (startPermit && !stopSequencePermit) {
    switching_2();  // funkcja wlacznika 2 i 3
    ringingMan();   // funkcja dzwonnika
  }
  if ((!digitalRead(Switch[WStop])) && (startPermit)) {
    startPermit = false;
    stopSequencePermit = true;
  }
  if ((!startPermit) && (stopSequencePermit)) {
    stopSequence();   //funkcja koncowa
  }

  if (!startPermit) {
    if (!digitalRead(Switch[WDrzwiLClose])) {
      digitalWrite(led[LSilnikLZamykanie], LOW);
    }
    if (!digitalRead(Switch[WDrzwiPClose])) {
      digitalWrite(led[LSilnikPZamykanie], LOW);
    }
  }
  if (!digitalRead(Switch[WDzwonnikP])) {
    digitalWrite(led[LDzwonnikL], LOW);
  }
  if (!digitalRead(Switch[WDzwonnikL])) {
    digitalWrite(led[LDzwonnikP], LOW);
  }
  stateTimes();             // funkja wykonawcza po wyzwoleniu odliczania
  // outputsAndInputsStateControl();
}




void switching_1() {

  if (digitalRead(Switch[WStart])) { //nie wcisniety
    switchStan_Start = false;
  }
  if ((!digitalRead(Switch[WStart])) && (!switchStan_Start)) { //bounce
    delay(20);
    if ((!digitalRead(Switch[WStart])) && (!switchStan_Start)) {
      switchStan_Start = true;
      digitalWrite(led[LSilnikLOtwieranie], HIGH); //Otwieranie drzwi
      digitalWrite(led[LSilnikPOtwieranie], HIGH);
      digitalWrite(led[LSilnikLZamykanie], LOW);
      digitalWrite(led[LSilnikPZamykanie], LOW);
      startPermit = true;
    }
  }
}

void switching_2() {
  if (digitalRead(Switch[WDrzwiLOpen])) {
    switchStan_DrzwiLOpen = false;
  }
  if (digitalRead(Switch[WDrzwiPOpen])) {
    switchStan_DrzwiPOpen = false;
  }
  if (!digitalRead(Switch[WDrzwiLOpen])) { //drzwi otwarte, zatrzymanie silnika
    digitalWrite(led[LSilnikLOtwieranie], LOW);
  }
  if (!digitalRead(Switch[WDrzwiPOpen])) { //drzwi otwarte, zatrzymanie silnika
    digitalWrite(led[LSilnikPOtwieranie], LOW);
  }
  if ((!digitalRead(Switch[WDrzwiLOpen])) && (!digitalRead(Switch[WDrzwiPOpen]))) { //znowu sprawdzanie czy drzwi otwarte ale z bouncingiem
    delay(20);
    if ((!digitalRead(Switch[WDrzwiLOpen])) && (!digitalRead(Switch[WDrzwiLOpen]))) {
      digitalWrite(led[LSilnikLOtwieranie], LOW);
      digitalWrite(led[LSilnikPOtwieranie], LOW);
      switchStan_DrzwiLOpen = true, switchStan_DrzwiPOpen = true;
      couting_1 = true;
      oldTime_1 = millis();
    }
  }
  else {
    if (couting_1 == false) {
      oldTime_1 = millis();
    }
  }
}

void ringingMan() {
  if (ringingManPermit) {
    if ((!digitalRead(Switch[WDzwonnikP])) && (!switchStan_DzwonnikP)) {
      digitalWrite(led[LDzwonnikL], LOW);
      digitalWrite(led[LDzwon], HIGH);
      couting_5 = true;
      switchStan_DzwonnikP = true;
      switchStan_DrzwiLClose = false;
      oldTime_5 = millis();
    }
    if ((!digitalRead(Switch[WDzwonnikL])) & (!switchStan_DrzwiLClose)) {
      digitalWrite(led[LDzwonnikP], LOW);
      couting_6 = true;
      switchStan_DrzwiLClose = true;
      oldTime_6 = millis();
    }
  }
}

void stopSequence() {
  digitalWrite(led[LDzwon], LOW);
  digitalWrite(led[LSilnikLOtwieranie], LOW);
  digitalWrite(led[LSilnikPOtwieranie], LOW);
  if (digitalRead(Switch[WDzwonnikL])) {
    digitalWrite(led[LDzwonnikP], HIGH);
    digitalWrite(led[LDzwonnikL], LOW);
  }
  while (digitalRead(Switch[WDzwonnikL]) == HIGH) {
  }
  if (!digitalRead(Switch[WDzwonnikL])) {
//    Serial.println("wylaczono");
    digitalWrite(led[LDzwonnikP], LOW);
    digitalWrite(led[LDzwonnikL], LOW);
  }
  delay(timeStop_1);
  digitalWrite(led[LKolo], LOW);
  delay(timeStop_2);
  digitalWrite(led[Lkolyska], LOW);
  delay(timeStop_3);
  digitalWrite(led[LMP3], LOW);
  delay(timeStop_4);
  digitalWrite(led[LSilnikLZamykanie], HIGH);
  digitalWrite(led[LSilnikPZamykanie], HIGH);

  couting_1 = false;
  couting_2 = false;
  couting_3 = false;
  couting_4 = false;
  couting_5 = false;
  couting_6 = false;
  stopSequencePermit = false;
}

void stateTimes() {

  newTime = millis();

  if (couting_1 == true) {
    if ((newTime - oldTime_1) >= timeCouting_1) {    // czas po ktorym nastapi wlaczanie swiatla i mp3 po otwarciu drzwi
      digitalWrite(led[LMP3], HIGH);
      couting_1 = false;
      couting_2 = true;
      oldTime_2 = newTime;
    }
  }

  if (couting_2 == true) {
    if ((newTime - oldTime_2) >= timeCouting_2) {    // czas po ktorym nastapi wlaczanie kolyski po wlaczeniu swiatla
      digitalWrite(led[Lkolyska], HIGH);
      couting_2 = false;
      couting_3 = true;
      oldTime_3 = newTime;
    }
  }

  if (couting_3 == true) {
    if ((newTime - oldTime_3) >= timeCouting_3) {    // czas po ktorym nastapi wlaczanie kola po wlaczeniu kolyski
      digitalWrite(led[LKolo], HIGH);
      couting_3 = false;
      couting_4 = true;
      oldTime_4 = newTime;
    }
  }

  if (couting_4 == true) {
    if ((newTime - oldTime_4) >= timeCouting_4) {    // czas po ktorym nastapi wlaczanie dzwonnika w lewo po wlaczeniu kola
      digitalWrite(led[LDzwonnikL], HIGH);
      ringingManPermit = true;
      couting_4 = false;
      switchStan_DzwonnikP = false;
    }
  }

  if (couting_5 == true) {
    if ((newTime - oldTime_5) >= timeCouting_5) {    // czas bicia dzwona
      digitalWrite(led[LDzwon], LOW);
      digitalWrite(led[LDzwonnikP], HIGH);
      switchStan_DzwonnikP = true;
      couting_5 = false;
      switchStan_DrzwiLClose = false;
    }
  }

  if (couting_6 == true) {
    if ((newTime - oldTime_6) >= timeCouting_6) {    // czas oczekiwania dzwonnika na kolejny ruch
      digitalWrite(led[LDzwonnikL], HIGH);
      switchStan_DzwonnikP = false;
      couting_6 = false;
    }
  }
}

void outputsAndInputsStateControl() {


  byte x = 1;
  byte y = 1;
  newTime = millis();
  if (newTime - oldTimeState >= 1000) {
    for (byte i = 0; i < ledMax; i++) {
//      Serial.print("LED:");
//      Serial.print(x);
//      Serial.print(" = ");
//      Serial.println(digitalRead(led[i]));
      x++;
    }
    for (byte i = 0; i < switchMax; i++) {
//      Serial.print("Switch:");
//      Serial.print(y);
//      Serial.print(" = ");
//      Serial.println(digitalRead(Switch[i]));
      y++;
    }
    oldTimeState = newTime;
  }
}

//******* koniec programu **********

Tu jest tak wiele do poprawy, że serio to lepiej napisać od nowa. Po co wszędzie masz digitalWrite po kilka razy by coś wysłać do silnika, jeszcze te błędne opisy, że pin startuje silnik w lewo,  a drugi w prawo, gdy to ma być ich odpowiednia sekwencja , powinny być funkcje silnikPrawyOtiweranie, SilnikPrawyZamykanie, silnikPrawyStop, itd., teraz masz pół tej sekwencji w jednej funkcji, gdzieś tam drugie. Przeczytaj książkę,  gotowe programy, które Ci się podobają, jak zbierzesz więcej wiedzy będą większe szanse na sukces.
Poza tym fajna szopka.