Ovládání venkovních rolet

Nedaří se vám s projektem a nenašli jste vhodné místo, kde se zeptat? Napište sem.
Pravidla fóra
Tohle subfórum je určeno pro konzultaci ucelených nápadů, popřípadě řešení komplexnějších projektů, které opravdu není možné rozdělit na menší části.
Většinu problémů jde rozdělit na menší a ptát se na ně v konkrétních subfórech.
Uživatelský avatar
kiRRow
Příspěvky: 1152
Registrován: 07 kvě 2019, 07:03
Reputation: 0
Bydliště: Opava

Re: Ovládání venkovních rolet

Příspěvek od kiRRow » 02 pro 2021, 16:29

rcvel píše:
30 lis 2021, 20:50
Když zmáčknu tlačítko po dobu menší než 2s, tak se sepne relé na 1min.V případě že během té 1min opět stačím tlačítko tak se cyklus přeruší.
Pokud nebude ošetřen zákmit, tak při stisku tlačítka dojde k několikanásobnému sepnutí/odpadnutí relé a relé skončí v zcela náhodném stavu. Tohle by ještě delay zkouslo, ale ...
Když podržím tlačítko na dobu delší než 2s relé bude seplé po dobu jakou bude stlačené tlačítko.
Tohle bez millis ... leda co chvilku se zadelayovat na 25ms a počítat do dvou vteřin

Bez schémata, kódu a s přáním o jakoukoliv radu, neumím poradit nic jiného, než začít. Já bych začal tím, že tlačítko... a to je třeba správně vyhodnotit pro další správný běh programu.

AstroMiK
Příspěvky: 592
Registrován: 08 pro 2017, 19:05
Reputation: 0

Re: Ovládání venkovních rolet

Příspěvek od AstroMiK » 03 pro 2021, 19:05

Tak z toho zkuste udělat tu challenge.

---

Princip mého řešení:

Nepoužívám žádné millis(). O veškeré časování se stará delay(10) na konci hlavní smyčky.
Hlavní smyčka tak cykluje 100x za sekundu. To je dostatečně rychlé na vyhodnocování stisku tlačitek.

Odrušení zákmitů řeším jednoduchým delay(50). Po stisku nebo uvolnění tlačítka se program na 50ms zastaví a nechá tlačíko, ať si zakmitá jak potřebuje. Během té doby se prostě netestuje stav digitálního vstupu. Po 50ms už by mělo být tlačítko klidné.

V programu se pak v proměnné "stav_1" udržuje informace o aktuální fázi běhu (popis všech stavů je na začátku programu)
Proměnná "stav_1" se mění na základě stisků, nebo uvolnění tlačítka a v závislosti na předchozím stavu.
Příklad:
stav_1 = 3 znamená, že je program ve fázi, kdy motor běží v automatickém režimu. Když v tomto stavu dojde ke stisku tlačítka, změní proměnná "stav_1" hodnotu na 5, což namená, že byl automat přerušen.

Podprogram motor_1() pak na základě proměnné "stav_1" (a případně proměnné pro automatický odpočet) ovládá motor.

Serial.printy jsou pro chod programu nepodstatné. Zobrazují jen aktuální fáze běhu programu jako textová hlášení.


Při rozšíření programu o další tlačítka a motory stačí zkopírovat podprogramy "tlacitko_1()" a "motor_1()", změnit jim názvy a upravit v nich číslované proměnné (stav_1, pin_out_1, odpocet_pohybu_1 ....).
Nové proměnné je pak nutné přidat do bloku globálních proměnných a v setupu nastavit směr pinů.


Nevýhody řešení:
- Časování není úplně přesné. K delay se přidávají ještě zpoždění pro jednotlivé podprogramy. Při odrušování zákmitů se časování také prodlužuje.

- V programu neřeším eventuality, jako je například držení tlačítka po dobu delší než 655,35 sekund (to je asi 11 minut). Po té době dojde k přetečení proměnné.

- V programu byl použit velice jednoduchý princip odrušení tlačítek. Při hodně špatné kvalitě tlačítkek ale nemusí být účinný.
( viz viewtopic.php?f=19&t=2886 )

Kód: Vybrat vše

// Zadani: https://forum.hwkitchen.cz/viewtopic.php?f=37&t=2938
//------------------
// Když zmáčknu tlačítko po dobu menší než 2s, tak se sepne relé na 1min.
// V případě že během té 1min opět stačím tlačítko tak se cyklus přeruší.
// Když podržím tlačítko na dobu delší než 2s relé bude seplé po dobu jakou bude stlačené tlačítko.
//-----------------

#define pin_tl_1           5        // pin s tlacitkem proti GND
#define pin_out_1         13        // vystupni pin na motor
#define automat_cas     6000        // trvani automatickeho behu motoru v setinach sekundy


byte stav_1;                        // 0 = vychozi stav (motor stoji)
                                    // 1 = drzeni tlacitka pri zastavenm motoru - nacitani doby stisku (po 2 sekundach se prechazi do rezimu 4)
                                    // 2 = tlacitko bylo uvolneno, stisk musel byt kratky
                                    // 3 = motor se toci, tlacitko uvolneno (probiha minutovy odpocet)
                                    // 4 = motor se toci, tlacitko stisknuto (beh do doby, nez se tlacitko uvolni)
                                    // 5 = tlacitko stisknuto pri automatickem behu. Pri naslednem uvolneni se prechazi na stav 0

unsigned int delka_stisku_1;        // jak dlouho uz trva stisk tlacitka (v setinach sekundy)
unsigned int odpocet_pohybu_1;      // jak dlouho ma motor jeste bezet (v setinach sekundy)


//==========================================================================================================
void setup(void)
  {
    Serial.begin(9600);
    pinMode(pin_tl_1 , INPUT_PULLUP);
    pinMode(pin_out_1, OUTPUT);

    Serial.println("Zacatek programu - zakladni stav se zastavenym motorem");
  }


//==========================================================================================================
void loop(void)
  {
    tlacitko_1();                                                  // vyhodnocovani stavu prvniho tlacitka
    motor_1();                                                     // ovladani prvniho motoru

//    pripadne rozsireni o dalsi tlacitka a motory
//    tlacitko_2();                                                // vyhodnocovani stavu druheho tlacitka
//    motor_2();                                                   // ovladani druheho motoru



   delay(10);                                                      // zakladni casovani jedne smycky na setinu sekundy
  }
  
//==========================================================================================================



//=========================================================================
//----------------- vyhodnocovani stisku tlacitka --------------------------
void tlacitko_1(void)
  {
    if (digitalRead(pin_tl_1) == LOW and stav_1 == 0)              // Tlacitko bylo stisknuto behem zastaveneho motoru
      {
        delka_stisku_1 = 0;                                        // delka stisku tlacitka se vynuluje
        stav_1 = 1;                                                // drzeni tlacitka pri zastavenem motoru
        delay(50);                                                 // odruseni zakmitu pri sepnuti (po dobu, kdy zakmitava se procesor zastavi)
        Serial.println("prave stisknute tlacitko pri zastavenem motoru");
      }


    if (digitalRead(pin_tl_1) == LOW  and stav_1 == 1)             // Tlacitko je drzeno pri zastavenem motoru
      {
                                                                   // tady se zakmity tlacitka neodrusuji, protoze stisk trva
        delka_stisku_1 ++;                                         // pocitani doby drzeni v setinach sekundy 
        if (delka_stisku_1 > 200)                                  // po dvou sekundach drzeni se okamzite spousti motor
          {
            stav_1 = 4;
            Serial.println("dlouhy stisk - RUCNI OVLADANI MOTORU");
          }
      }


    if (digitalRead(pin_tl_1) == HIGH and stav_1 == 1)             // Tlacitko bylo uvolneno pri zastavenem motoru (musel to byt kratky stisk, jinak by neplatil stav_1 == 1)
      {
        delay(50);                                                 // odruseni zakmitu pri rozepinani tlacitka
        odpocet_pohybu_1 = automat_cas;                            // casovani pohybu se nastavi na 60 sekund
        stav_1 = 3;                                                // spustit motor v automatickem rezimu
        Serial.println("kratky stisk - MINUTOVY POHYB");
      }


    if (digitalRead(pin_tl_1) == HIGH and stav_1 == 4)             // Tlacitko bylo uvolneno pri rucne ovladanem motoru
      {
        delay(50);                                                 // odruseni zakmitu pri rozepnuti
        stav_1 = 0;
        odpocet_pohybu_1 = 0;
        Serial.println("preruseni rucniho ovladani");
        Serial.println("zakladni stav se zastavenym motorem");
      }

    
    if (digitalRead(pin_tl_1) == LOW and stav_1 == 3)              // Tlacitko bylo stisknuto pri automaticky bezicim motoru
      {
        delay(50);                                                 // odruseni zakmitu pri sepnuti
        stav_1 = 5;                                                // priprava na prechod do zakladniho stavu se zastavenym motorem
        odpocet_pohybu_1 = 0;                                      // predcasne preruseni casovani
        Serial.println("stisk tlacitka pri behu motoru - STOP");
      }


    if (digitalRead(pin_tl_1) == HIGH and stav_1 == 5)             // Tlacitko bylo uvolneno po predcasnem ukonceni behu
      {
        delay(50);                                                 // odruseni zakmitu pri uvolneni
        stav_1 = 0;                                                // prechod do zakladniho stavu se zastavenym motorem
        Serial.println("zakladni stav se zastavenym motorem");
      }

  }
//=========================================================================


//=========================================================================
//----------------- ovladani motoru podle promenne 'stav_1' ----------------
void motor_1(void)
  {
    if (stav_1 == 3)                                               // motor ma bezet s casovanim
      {
        if (odpocet_pohybu_1 > 0)
          {
            digitalWrite(pin_out_1, HIGH);                         // motor bezi
            odpocet_pohybu_1 --;                                   // casovani behu se snizi o setinu sekundy        
          }
        else                                                       // odpocet behu vyprsel
          {
            digitalWrite(pin_out_1, LOW);                          // motor se zastavi
            stav_1 = 0;                                            // prepne se do zakladniho stavu
            Serial.println("motor se prave zastavil");            
          }
      }


    if (stav_1 == 4)                                               // motor ma bezet s rucnim ovladanim
      {
        digitalWrite(pin_out_1, HIGH);                             // motor bezi
      }


    if (stav_1 == 0 or stav_1 == 5)                                // motor v zakladnim stavu, nebo pri preruseni automatickeho behu
      {
        digitalWrite(pin_out_1, LOW);                              // motor stoji
      }

  }
//=========================================================================



rcvel
Příspěvky: 3
Registrován: 30 lis 2021, 20:37
Reputation: 0

Re: Ovládání venkovních rolet

Příspěvek od rcvel » 07 pro 2021, 09:45

Dobrý den, dekuji moc za pomoc..
A omlouvám se jestli jsem někoho urazil.

Uživatelský avatar
kiRRow
Příspěvky: 1152
Registrován: 07 kvě 2019, 07:03
Reputation: 0
Bydliště: Opava

Re: Ovládání venkovních rolet

Příspěvek od kiRRow » 07 pro 2021, 20:33

Nikoho jsi neurazil, to spíš já bych se měl omluvit.
Nějaký pokrok s kódem, zapojením ? Dej nám co nejvíce informací můžeš, hodně nám to pomáhá pomáhat :) .

PS : Omlouvám se, ale ještě jednou dodám, pokud nejsi oprávněn pracovat s 230V, dokonči projekt výstupním relé, na otestování stačí led, nebo multimetr, finální zapojení nech na někom s odbornou kvalifikací.

rcvel
Příspěvky: 3
Registrován: 30 lis 2021, 20:37
Reputation: 0

Re: Ovládání venkovních rolet

Příspěvek od rcvel » 08 pro 2021, 20:35

Pokročil jsem hodně, tedy prakticky jsem vyšel z kódu od AstroMiK (za který mu mockrát děkuji, opravdu mi pomohl!!), vyzkoušel jsem zapojení na online webu https://www.tinkercad.com/, schéma zapojení níže. To samé zapojení jsem později sestavil i fyzicky, prvně s 12V a ventilátory.Po vyzkoušení i na samotných roletách(oprávnění mám :D ), tady jsem narazil na problém. Když na relé připojím 230V, po spuštění obou rolet se po pár spuštění arduino jakoby sekne a musím ho restartovat.

Ještě zde přikládám odkaz na použité relé a arduino
https://www.laskarduino.cz/4-kanaly-rel ... #ratingTab
https://www.laskarduino.cz/arduino-uno- ... 28p--klon/

Kód: Vybrat vše

// Zadani: https://forum.hwkitchen.cz/viewtopic.php?f=37&t=2938
//------------------
// Když zmáčknu tlačítko po dobu menší než 2s, tak se sepne relé na 1min.
// V případě že během té 1min opět stačím tlačítko tak se cyklus přeruší.
// Když podržím tlačítko na dobu delší než 2s relé bude seplé po dobu jakou bude stlačené tlačítko.
//-----------------

#define pin_tl_1           5        // pin s tlacitkem proti GND
#define pin_out_1         13        // vystupni pin na motor1
#define pin_tl_2	   4		// pin s tlacitkem proti GND
#define pin_out_2         12		// vystupni pin na motor2
#define pin_tl_3	   3		// pin s tlacitkem proti GND
#define pin_out_3         11		// vystupni pin na motor3
#define pin_tl_4	   2		// pin s tlacitkem proti GND
#define pin_out_4         10		// vystupni pin na motor4
#define automat_cas     6000        // trvani automatickeho behu motoru v setinach sekundy


byte stav_1;                        // 0 = vychozi stav (motor stoji)
                                    // 1 = drzeni tlacitka pri zastavenm motoru - nacitani doby stisku (po 2 sekundach se prechazi do rezimu 4)
                                    // 2 = tlacitko bylo uvolneno, stisk musel byt kratky
                                    // 3 = motor se toci, tlacitko uvolneno (probiha minutovy odpocet)
                                    // 4 = motor se toci, tlacitko stisknuto (beh do doby, nez se tlacitko uvolni)
                                    // 5 = tlacitko stisknuto pri automatickem behu. Pri naslednem uvolneni se prechazi na stav 0

byte stav_2;

byte stav_3;

byte stav_4;

unsigned int delka_stisku_1;        // jak dlouho uz trva stisk tlacitka (v setinach sekundy)
unsigned int odpocet_pohybu_1;      // jak dlouho ma motor jeste bezet (v setinach sekundy)


unsigned int delka_stisku_2;        
unsigned int odpocet_pohybu_2;


unsigned int delka_stisku_3;        
unsigned int odpocet_pohybu_3;


unsigned int delka_stisku_4;        
unsigned int odpocet_pohybu_4;

//==========================================================================================================
void setup(void)
  {
    Serial.begin(9600);
    pinMode(pin_tl_1 , INPUT_PULLUP);
    pinMode(pin_out_1, OUTPUT);
  
    pinMode(pin_tl_2 , INPUT_PULLUP);
    pinMode(pin_out_2, OUTPUT);
  
    pinMode(pin_tl_3 , INPUT_PULLUP);
    pinMode(pin_out_3, OUTPUT);
  
    pinMode(pin_tl_4 , INPUT_PULLUP);
    pinMode(pin_out_4, OUTPUT);

    Serial.println("Zacatek programu - zakladni stav se zastavenym motorem");
  }


//==========================================================================================================
void loop(void)
  {
    tlacitko_1();                                                  // vyhodnocovani stavu prvniho tlacitka
    motor_1();                                                     // ovladani prvniho motoru

//    pripadne rozsireni o dalsi tlacitka a motory
    tlacitko_2();                                                // vyhodnocovani stavu druheho tlacitka
    motor_2();                                                   // ovladani druheho motoru
  
    tlacitko_3();
  	motor_3();
  
    tlacitko_4();
    motor_4();
  



   delay(10);                                                      // zakladni casovani jedne smycky na setinu sekundy
  }
  
//==========================================================================================================



//=========================================================================
//1----------------- vyhodnocovani stisku tlacitka1 --------------------------
void tlacitko_1(void)
  {

 

    if (digitalRead(pin_tl_1) == LOW and stav_1 == 0)              // Tlacitko bylo stisknuto behem zastaveneho motoru
      {
        delka_stisku_1 = 0;                                        // delka stisku tlacitka se vynuluje
        stav_1 = 1;                                                // drzeni tlacitka pri zastavenem motoru
        delay(50);                                                 // odruseni zakmitu pri sepnuti (po dobu, kdy zakmitava se procesor zastavi)
        Serial.println("'dolu'tlacitko 1 stisknute tlacitko pri zastavenem motoru");
        stav_2 = 0;
      }


    if (digitalRead(pin_tl_1) == LOW  and stav_1 == 1)             // Tlacitko je drzeno pri zastavenem motoru
      {
                                                                   // tady se zakmity tlacitka neodrusuji, protoze stisk trva
        delka_stisku_1 ++;                                         // pocitani doby drzeni v setinach sekundy 
        if (delka_stisku_1 > 200)                                  // po dvou sekundach drzeni se okamzite spousti motor
          {
            stav_1 = 4;
            Serial.println("'dolu'tlacitko 1 dlouhy stisk - RUCNI OVLADANI MOTORU");
           stav_2 = 0;            
          }
      }


    if (digitalRead(pin_tl_1) == HIGH and stav_1 == 1)             // Tlacitko bylo uvolneno pri zastavenem motoru (musel to byt kratky stisk, jinak by neplatil stav_1 == 1)
      {
        delay(50);                                                 // odruseni zakmitu pri rozepinani tlacitka
        odpocet_pohybu_1 = automat_cas;                            // casovani pohybu se nastavi na 60 sekund
        stav_1 = 3;                                                // spustit motor v automatickem rezimu
        Serial.println("'dolu'kratky stisk tlacitka 1 - MINUTOVY POHYB");
        stav_2 = 0;
      }


    if (digitalRead(pin_tl_1) == HIGH and stav_1 == 4)             // Tlacitko bylo uvolneno pri rucne ovladanem motoru
      {
        delay(50);                                                 // odruseni zakmitu pri rozepnuti
        stav_1 = 0;
        odpocet_pohybu_1 = 0;
        Serial.println("'dolu'tlacitko 1 preruseni rucniho ovladani");
        Serial.println("'dolu'tlacitko 1 zakladni stav se zastavenym motorem");
        stav_2 = 0;        
      }

    
    if (digitalRead(pin_tl_1) == LOW and stav_1 == 3)              // Tlacitko bylo stisknuto pri automaticky bezicim motoru
      {
        delay(50);                                                 // odruseni zakmitu pri sepnuti
        stav_1 = 5;                                                // priprava na prechod do zakladniho stavu se zastavenym motorem
        odpocet_pohybu_1 = 0;                                      // predcasne preruseni casovani
        Serial.println("'dolu'tlacitko 1 stisk tlacitka pri behu motoru - STOP");
        stav_2 = 0;        
      }


    if (digitalRead(pin_tl_1) == HIGH and stav_1 == 5)             // Tlacitko bylo uvolneno po predcasnem ukonceni behu
      {
        delay(50);                                                 // odruseni zakmitu pri uvolneni
        stav_1 = 0;                                                // prechod do zakladniho stavu se zastavenym motorem
        Serial.println("'dolu'tlacitko 1 zakladni stav se zastavenym motorem");
        stav_2 = 0;        
      }


  }

//=========================================================================
//1----------------- vyhodnocovani stisku tlacitka1 --------------------------


//=========================================================================
//----------------- ovladani motoru1 podle promenne 'stav_1' ----------------
void motor_1(void)
  {
  
    if (stav_1 == 3)									// motor ma bezet s casovanim
      
    {
        if (odpocet_pohybu_1 > 0)
          {
            
            digitalWrite(pin_out_1, LOW);                         // motor bezi
            odpocet_pohybu_1 --;                                   // casovani behu se snizi o setinu sekundy        
          }
        else                                                       // odpocet behu vyprsel
          {
            digitalWrite(pin_out_1, HIGH);                          // motor se zastavi
            stav_1 = 0;                                            // prepne se do zakladniho stavu
            Serial.println("'dolu'motor 1 se prave zastavil");            
          }
      }


    if (stav_1 == 4)                                               // motor ma bezet s rucnim ovladanim
      {
        digitalWrite(pin_out_1, LOW);                             // motor bezi
      }


    if (stav_1 == 0 or stav_1 == 5)                                // motor v zakladnim stavu, nebo pri preruseni automatickeho behu
      {
    
        digitalWrite(pin_out_1, HIGH);                              // motor stoji
      }

  }

//=========================================================================
//----------------- ovladani motoru1 podle promenne 'stav_1' --------------

//=========================================================================
//2---------------------- vyhodnocovani stisku tlacitka2 ------------------

void tlacitko_2(void)
  {
    if (digitalRead(pin_tl_2) == LOW and stav_2 == 0)              // Tlacitko bylo stisknuto behem zastaveneho motoru
      {
        delka_stisku_2 = 0;                                        // delka stisku tlacitka se vynuluje
        stav_2 = 1;                                                // drzeni tlacitka pri zastavenem motoru
        delay(50);                                                 // odruseni zakmitu pri sepnuti (po dobu, kdy zakmitava se procesor zastavi)
        Serial.println("'nahoru'tlacitko 2 stisknute tlacitko pri zastavenem motoru");
        stav_1 = 0;
      }


    if (digitalRead(pin_tl_2) == LOW  and stav_2 == 1)             // Tlacitko je drzeno pri zastavenem motoru
      {
                                                                   // tady se zakmity tlacitka neodrusuji, protoze stisk trva
        delka_stisku_2 ++;                                         // pocitani doby drzeni v setinach sekundy 
        if (delka_stisku_2 > 200)                                  // po dvou sekundach drzeni se okamzite spousti motor
          {
            stav_2 = 4;
            Serial.println("'nahoru'dlouhy stisk tlacitko 2 - RUCNI OVLADANI MOTORU");
            stav_1 = 0;
          }
      }


    if (digitalRead(pin_tl_2) == HIGH and stav_2 == 1)             // Tlacitko bylo uvolneno pri zastavenem motoru (musel to byt kratky stisk, jinak by neplatil stav_1 == 1)
      {
        delay(50);                                                 // odruseni zakmitu pri rozepinani tlacitka
        odpocet_pohybu_2 = automat_cas;                            // casovani pohybu se nastavi na 60 sekund
        stav_2 = 3;                                                // spustit motor v automatickem rezimu
        Serial.println("'nahoru'kratky stisk tlacitko 2 - MINUTOVY POHYB");
        stav_1 = 0;
      }


    if (digitalRead(pin_tl_2) == HIGH and stav_2 == 4)             // Tlacitko bylo uvolneno pri rucne ovladanem motoru
      {
        delay(50);                                                 // odruseni zakmitu pri rozepnuti
        stav_2 = 0;
        odpocet_pohybu_2 = 0;
        Serial.println("tlacitko 2 preruseni rucniho ovladani");
        Serial.println("'nahoru'tlacitko 2 zakladni stav se zastavenym motorem");
        stav_1 = 0;
      }

    
    if (digitalRead(pin_tl_2) == LOW and stav_2 == 3)              // Tlacitko bylo stisknuto pri automaticky bezicim motoru
      {
        delay(50);                                                 // odruseni zakmitu pri sepnuti
        stav_2 = 5;                                                // priprava na prechod do zakladniho stavu se zastavenym motorem
        odpocet_pohybu_2 = 0;                                      // predcasne preruseni casovani
        Serial.println("'nahoru'stisk tlacitka 2 pri behu motoru - STOP");
        stav_1 = 0;
      }


    if (digitalRead(pin_tl_2) == HIGH and stav_2 == 5)             // Tlacitko bylo uvolneno po predcasnem ukonceni behu
      {
        delay(50);                                                 // odruseni zakmitu pri uvolneni
        stav_2 = 0;                                                // prechod do zakladniho stavu se zastavenym motorem
        Serial.println("'nahoru'tlacitko 2 zakladni stav se zastavenym motorem");
        stav_1 = 0;
      }

  }

  //=========================================================================
//2---------------------- vyhodnocovani stisku tlacitka2 ------------------

//===========================================================================
//----------------- ovladani motoru2 podle promenne 'stav_2' ----------------

void motor_2(void)
  {
    if (stav_2 == 3)                                               // motor ma bezet s casovanim
      {
        if (odpocet_pohybu_2 > 0)
          {
            digitalWrite(pin_out_2, LOW);                         // motor bezi
            odpocet_pohybu_2 --;                                   // casovani behu se snizi o setinu sekundy        
          }
        else                                                       // odpocet behu vyprsel
          {
            digitalWrite(pin_out_2, HIGH);                          // motor se zastavi
            stav_2 = 0;                                            // prepne se do zakladniho stavu
            Serial.println("'nahoru'motor 2 se prave zastavil");            
          }
      }


    if (stav_2 == 4)                                               // motor ma bezet s rucnim ovladanim
      {
        digitalWrite(pin_out_1,HIGH);
        digitalWrite(pin_out_2, LOW);                             // motor bezi
      }


    if (stav_2 == 0 or stav_2 == 5)                                // motor v zakladnim stavu, nebo pri preruseni automatickeho behu
      {
        
        digitalWrite(pin_out_2, HIGH);                              // motor stoji
      }

  }

//===========================================================================
//----------------- ovladani motoru2 podle promenne 'stav_2' ----------------

//===========================================================================
//3---------------------- vyhodnocovani stisku tlacitka3 --------------------

void tlacitko_3(void)
  {
    if (digitalRead(pin_tl_3) == LOW and stav_3 == 0)              // Tlacitko bylo stisknuto behem zastaveneho motoru
      {
        delka_stisku_3 = 0;                                        // delka stisku tlacitka se vynuluje
        stav_3 = 1;                                                // drzeni tlacitka pri zastavenem motoru
        delay(50);                                                 // odruseni zakmitu pri sepnuti (po dobu, kdy zakmitava se procesor zastavi)
        Serial.println("'dolu'stisknute tlacitko3 pri zastavenem motoru");
        stav_4 = 0;
      }


    if (digitalRead(pin_tl_3) == LOW  and stav_3 == 1)             // Tlacitko je drzeno pri zastavenem motoru
      {
                                                                   // tady se zakmity tlacitka neodrusuji, protoze stisk trva
        delka_stisku_3 ++;                                         // pocitani doby drzeni v setinach sekundy 
        if (delka_stisku_3 > 200)                                  // po dvou sekundach drzeni se okamzite spousti motor
          {
            stav_3 = 4;
            Serial.println("'dolu'dlouhy stisk tlacitko 3 - RUCNI OVLADANI MOTORU");
            stav_4 = 0;
          }
      }


    if (digitalRead(pin_tl_3) == HIGH and stav_3 == 1)             // Tlacitko bylo uvolneno pri zastavenem motoru (musel to byt kratky stisk, jinak by neplatil stav_1 == 1)
      {
        delay(50);                                                 // odruseni zakmitu pri rozepinani tlacitka
        odpocet_pohybu_3 = automat_cas;                            // casovani pohybu se nastavi na 60 sekund
        stav_3 = 3;                                                // spustit motor v automatickem rezimu
        Serial.println("'dolu'kratky stisk tlacitko 3 - MINUTOVY POHYB");
        stav_4 = 0;
      }


    if (digitalRead(pin_tl_3) == HIGH and stav_3 == 4)             // Tlacitko bylo uvolneno pri rucne ovladanem motoru
      {
        delay(50);                                                 // odruseni zakmitu pri rozepnuti
        stav_3 = 0;
        odpocet_pohybu_3 = 0;
        Serial.println("'dolu'tlacitko 3 preruseni rucniho ovladani");
        Serial.println("'dolu'tlacitko 3 zakladni stav se zastavenym motorem");
        stav_4 = 0;
      }

    
    if (digitalRead(pin_tl_3) == LOW and stav_3 == 3)              // Tlacitko bylo stisknuto pri automaticky bezicim motoru
      {
        delay(50);                                                 // odruseni zakmitu pri sepnuti
        stav_3 = 5;                                                // priprava na prechod do zakladniho stavu se zastavenym motorem
        odpocet_pohybu_3 = 0;                                      // predcasne preruseni casovani
        Serial.println("'dolu'stisk tlacitka 3 pri behu motoru - STOP");
        stav_4 = 0;
      }


    if (digitalRead(pin_tl_3) == HIGH and stav_3 == 5)             // Tlacitko bylo uvolneno po predcasnem ukonceni behu
      {
        delay(50);                                                 // odruseni zakmitu pri uvolneni
        stav_3 = 0;                                                // prechod do zakladniho stavu se zastavenym motorem
        Serial.println("'dolu'zakladni stav tlacitko 3 se zastavenym motorem");
        stav_4 = 0;
      }

  }

  //=========================================================================
//3---------------------- vyhodnocovani stisku tlacitka3 --------------------

//===========================================================================
//----------------- ovladani motoru3 podle promenne 'stav_3' ----------------

void motor_3(void)
  {
    if (stav_3 == 3)                                               // motor ma bezet s casovanim
      {
        if (odpocet_pohybu_3 > 0)
          {
            digitalWrite(pin_out_3, LOW);                         // motor bezi
            odpocet_pohybu_3 --;                                   // casovani behu se snizi o setinu sekundy        
          }
        else                                                       // odpocet behu vyprsel
          {
            digitalWrite(pin_out_3, HIGH);                          // motor se zastavi
            stav_3 = 0;                                            // prepne se do zakladniho stavu
            Serial.println("'dolu'motor 3 se prave zastavil");            
          }
      }


    if (stav_3 == 4)                                               // motor ma bezet s rucnim ovladanim
      {
        digitalWrite(pin_out_3, LOW);                             // motor bezi
      }


    if (stav_3 == 0 or stav_3 == 5)                                // motor v zakladnim stavu, nebo pri preruseni automatickeho behu
      {
        digitalWrite(pin_out_3, HIGH);                              // motor stoji
      }

  }

//===========================================================================
//----------------- ovladani motoru3 podle promenne 'stav_3' ----------------

//===========================================================================
//4---------------------- vyhodnocovani stisku tlacitka4 --------------------

void tlacitko_4(void)
  {
    if (digitalRead(pin_tl_4) == LOW and stav_4 == 0)              // Tlacitko bylo stisknuto behem zastaveneho motoru
      {
        delka_stisku_4 = 0;                                        // delka stisku tlacitka se vynuluje
        stav_4 = 1;                                                // drzeni tlacitka pri zastavenem motoru
        delay(50);                                                 // odruseni zakmitu pri sepnuti (po dobu, kdy zakmitava se procesor zastavi)
        Serial.println("'nahoru'prave stisknute tlacitko 4  pri zastavenem motoru");
        stav_3 = 0;
      }


    if (digitalRead(pin_tl_4) == LOW  and stav_4 == 1)             // Tlacitko je drzeno pri zastavenem motoru
      {
                                                                   // tady se zakmity tlacitka neodrusuji, protoze stisk trva
        delka_stisku_4 ++;                                         // pocitani doby drzeni v setinach sekundy 
        if (delka_stisku_4 > 200)                                  // po dvou sekundach drzeni se okamzite spousti motor
          {
            stav_4 = 4;
            Serial.println("'nahoru'dlouhy stisk tlacitko 4 - RUCNI OVLADANI MOTORU");
            stav_3 = 0;
          }
      }


    if (digitalRead(pin_tl_4) == HIGH and stav_4 == 1)             // Tlacitko bylo uvolneno pri zastavenem motoru (musel to byt kratky stisk, jinak by neplatil stav_1 == 1)
      {
        delay(50);                                                 // odruseni zakmitu pri rozepinani tlacitka
        odpocet_pohybu_4 = automat_cas;                            // casovani pohybu se nastavi na 60 sekund
        stav_4 = 3;                                                // spustit motor v automatickem rezimu
        Serial.println("'nahoru'kratky stisk tlacitko 4 - MINUTOVY POHYB");
        stav_3 = 0;
      }


    if (digitalRead(pin_tl_4) == HIGH and stav_4 == 4)             // Tlacitko bylo uvolneno pri rucne ovladanem motoru
      {
        delay(50);                                                 // odruseni zakmitu pri rozepnuti
        stav_4 = 0;
        odpocet_pohybu_4 = 0;
        Serial.println("'nahoru'tlacitko 4 preruseni rucniho ovladani");
        Serial.println("'nahoru'tlacitko 4 zakladni stav se zastavenym motorem");
        stav_3 = 0;
      }

    
    if (digitalRead(pin_tl_4) == LOW and stav_4 == 3)              // Tlacitko bylo stisknuto pri automaticky bezicim motoru
      {
        delay(50);                                                 // odruseni zakmitu pri sepnuti
        stav_4 = 5;                                                // priprava na prechod do zakladniho stavu se zastavenym motorem
        odpocet_pohybu_4 = 0;                                      // predcasne preruseni casovani
        Serial.println("'nahoru'stisk tlacitka 4 pri behu motoru - STOP");
        stav_3 = 0;
      }


    if (digitalRead(pin_tl_4) == HIGH and stav_4 == 5)             // Tlacitko bylo uvolneno po predcasnem ukonceni behu
      {
        delay(50);                                                 // odruseni zakmitu pri uvolneni
        stav_4 = 0;                                                // prechod do zakladniho stavu se zastavenym motorem
        Serial.println("'nahoru'tlacitko 4 zakladni stav se zastavenym motorem");
        stav_3 = 0;
      }

  }

//===========================================================================
//4---------------------- vyhodnocovani stisku tlacitka4 --------------------

//===========================================================================
//----------------- ovladani motoru4 podle promenne 'stav_4' ----------------

void motor_4(void)
  {
    if (stav_4 == 3)                                               // motor ma bezet s casovanim
      {
        if (odpocet_pohybu_4 > 0)
          {
            digitalWrite(pin_out_4, LOW);                         // motor bezi
            odpocet_pohybu_4 --;                                   // casovani behu se snizi o setinu sekundy        
          }
        else                                                       // odpocet behu vyprsel
          {
            digitalWrite(pin_out_4, HIGH);                          // motor se zastavi
            stav_4 = 0;                                            // prepne se do zakladniho stavu
            Serial.println("'nahoru'motor 4 se prave zastavil");            
          }
      }


    if (stav_4 == 4)                                               // motor ma bezet s rucnim ovladanim
      {
        digitalWrite(pin_out_4, LOW);                             // motor bezi
      }


    if (stav_4 == 0 or stav_4 == 5)                                // motor v zakladnim stavu, nebo pri preruseni automatickeho behu
      {
        digitalWrite(pin_out_4, HIGH);                              // motor stoji
      }

  }

//===========================================================================
//----------------- ovladani motoru2 podle promenne 'stav_4' ----------------
Přílohy
rolety.png

Uživatelský avatar
kiRRow
Příspěvky: 1152
Registrován: 07 kvě 2019, 07:03
Reputation: 0
Bydliště: Opava

Re: Ovládání venkovních rolet

Příspěvek od kiRRow » 09 pro 2021, 10:53

A jak to arduino a ten modul napájíš? Já si myslím, že buď to nestíhá vyrovnávat odběry těch relátek, nebo ty rolety nějak ruší zdroj. Jestli to dělá jen s roletama, tak to ruší ty rolety.

Uživatelský avatar
Caster
Příspěvky: 380
Registrován: 11 zář 2019, 09:02
Reputation: 0

Re: Ovládání venkovních rolet

Příspěvek od Caster » 09 pro 2021, 12:45

Pokud je Arduino někde blízko těch rolet, tak je nutné mít motorky rolet dobře odrušené a samozřejmě mít také dobrý zdroj (pro motorky, pokud nejsou napájeny 220 V), jak psal kiRRow. Nutností je mít také kvalitní zdroj pro Arduino a ideálně ho dát do kovové krabičky (Arduino).

Zkusil bych takém, zda přestane Arduino padat, pokud bude dočasně napájeno jen baterií a nějakým jednoduchým stabilizátorem např. L7805CV-DG napájeným např. dvěma Li-Ion bateriemi, případně pěti tužkovými alkalickými bateriemi. Možná by regulátor zvládl i 12 V akumulátor.

To by pomohlo odhalit, zda je problém ve zdroji Arduina.

Uživatelský avatar
kiRRow
Příspěvky: 1152
Registrován: 07 kvě 2019, 07:03
Reputation: 0
Bydliště: Opava

Re: Ovládání venkovních rolet

Příspěvek od kiRRow » 09 pro 2021, 14:38

Caster píše:
09 pro 2021, 12:45
... a ideálně ho dát do kovové krabičky (Arduino).
A tuto krabičku uzemnit ...

Uživatelský avatar
kiRRow
Příspěvky: 1152
Registrován: 07 kvě 2019, 07:03
Reputation: 0
Bydliště: Opava

Re: Ovládání venkovních rolet

Příspěvek od kiRRow » 09 pro 2021, 14:58

Rád bych věděl odkud berou motory pro rolety napájení a odkud bereš napájení pro arduino, jaké zdroje používáš. Je arduino poblíž silových kabelů ? Tohle už je problém v praxi, který nastává při "určité konstelaci" a chtělo by to být trochu konkrétnější.

Jednou se mi arduino občas restartovalo po výměně vzduchového ventilu. Problém byl v tom, že nový ventil neměl ošetřenou cívku diodou a při rozepnutí způsobil napěťovou špičku, na kterou zdroj zareagoval svým vypnutím. Stačilo zapojit k cívce v závěrném směru diodu.
Jednou arduino spínalo docela dost silný motor, a přitom kontrolovalo několik servomotorů. Bylo napájeno DC/DC měničem z spínaného zdroje. Při sepnutí silného motoru se všechny serva hnuly. Výměna měniče za linerární zdroj.

AstroMiK
Příspěvky: 592
Registrován: 08 pro 2017, 19:05
Reputation: 0

Re: Ovládání venkovních rolet

Příspěvek od AstroMiK » 09 pro 2021, 20:50

Také přikláním k tomu, že popsané problémy bude způsobovat nějaké rušení na napájení.
Tohle se na dálku dost těžko řeší.


Dej pozor ještě na ty zobrazované texty v programu.
Už se dostáváš nebezpečně blízko k horní hranici RAM.

Tam, kde opravdu potřebuješ vypisovat texty do sériové linky, použij místo:

Kód: Vybrat vše

Serial.println("'nahoru'dlouhy stisk tlacitko 2 - RUCNI OVLADANI MOTORU");
tohle:

Kód: Vybrat vše

Serial.println(F("'nahoru'dlouhy stisk tlacitko 2 - RUCNI OVLADANI MOTORU"));
Ale lepší by bylo ty printy na závěr úplně vyhodit. Já jsem to tam dal jen pro testování, aby bylo vidět, jak program běží.


EDIT:

A ještě v tom tvém kódu vidím docela často zapomenuté číslování proměnných.
Například:
chyby.gif

A nebo to máš schválně? Že zastavuješ vedlejší motory?

Odpovědět

Kdo je online

Uživatelé prohlížející si toto fórum: Žádní registrovaní uživatelé a 20 hostů