Mini CNC osa Z

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

Re: Mini CNC osa Z

Příspěvek od kiRRow » 05 úno 2020, 18:46

Kód: Vybrat vše

if(mode == 2) {  // ******* LED1,LED2 blikání rychlé  *******     
       if(mamBezet == true) {   // ZRUŠENÁ PODMÍNKA mamBezet    - zmena true za false
           
           casCekani = millis() - buttonTime; //musíš si definovat novou proměnnou - do ní bude uložen čas který už program načekal od stisku tlačítka start
           	
           if(casCekani  > 10000){  // zjistím si jestli je čas něco provést, uběhlo už 10s od poslední akce?            
               aktualniMillis = millis();  // podívám se na hodinky - aktuální čas                  
               if(aktualniMillis - predchoziMillis1 > 200) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 200ms od poslední akce?                  
                 if (led1svetlo) {                           
                   led1svetlo = false;  // zhasnu LED1
                   led2svetlo = false;  // zhasnu LED2                   
                  } else {                    
                    led1svetlo = true;  // rožnu LED1
                    led2svetlo = true;  // rožnu LED2                                
                   }                                   
                   predchoziMillis1 = aktualniMillis;   // v tento čas jsem provedl poslední akci  
               }                                                                         
              } else {                                    
                 led1svetlo = false;
                 led2svetlo = false;                               
                 vypisLCD = true;                                                                           
                } 
        }       
  }

Kód: Vybrat vše

    if(mode == 2){ // Dle mode vyberu který
	// tady si to musím pohlídat - tohle mode má totiž tři stavy, které chci vypsat - takže si musím zjistit v jakém stavu je
	// pokud program spuštěný není ... mamBezet == false ... chci si vypsat, že to je blikání s čekáním
	// pokud je spuštěný program mamBezet == true ... ale ještě nedošlo k uplynutí toho čekacího času, chci vypsat, že program se spustí za
	// nějakou dobu - takže vlastně i tu dobu si budu muset někde zapamatovat, nebo ji znovu zase vypočítat
	// pokud je spuštěný program mamBezet a už došlo k uplynutí zpoždění, tak chci vypsat, že LEDky blikají
	if(mamBezet == true){ // bezi a bud ceka nebo neceka
		if(casCekani  > 10000){
			bezi a ceka ... vypisuji informaci o cekani ... napr zbyva 10000 - casCekani
		} else {
			bezi a neceka ... vypisuji informaci o tom, že už to bliká
		}
	} else {
		nebeží ... vypisuji info - že toto mode dělá tohle a tohle
	}
    }
to jestli má program bežet musí být řízeno tlačítkem, nebo ještě samotným programem (např má bliknout jen 10x - pak ano, po desátém bliknutí mode zapíše že program mamBezet = false;) ... obsluha výpisu na displej přece nemůže zasahovat do takovéto proměnné ... program má přece pracovat takto

1) obsloužíme tlačítka
Na základě toho co jsme zjistili z tlačítek nastavíme příslušné parametry v programu ... např mamBezet, mode, vypisLCD atp
2) provedeme samotný program
Na základě nastavených parametrů v předchozím kroku program postupně projíždí jednotlivé větvě IF a vykonává svou práci - bliká, vrtí, čeká
3) obsluha LCD
Po provedení nejdůležitější práce, pokud je třeba, se výsledky shrnou a vypíší na displej - buď ho přepíší celý, nebo jen jeho část

1.VSTUP -> 2.AKCE -> 3.VÝSTUP

Hanz
Příspěvky: 262
Registrován: 25 dub 2019, 23:52
Reputation: 0

Re: Mini CNC osa Z

Příspěvek od Hanz » 10 úno 2020, 14:53

dobrý den, výpis mode2 na lcd mě trápil a trápí dál :evil: Nechal jsem v mode2 vypisy jen na seriový monitor.
Nedaří se mi u výpisu to, že jakmile se dokončí odpočet 10s, tak má přijít výpis ledky blikají :cry: Odpočet mi doběhne na nulu a ...nic . Ledky si veselé blikají a výpis žádný ? Myslel jsem si, že když je v podmínce casCekani > 10000, tak se výpis překlopí po odečtu času na výpis ledky blikají ? :?:

Kód: Vybrat vše

#define buttonSelectUp 2   // číslo pinu tlačítka SELECT pro výběr MODE nahoru
#define buttonStart 3   // číslo pinu tlačítka START/STOP - červené
#define buttonSelectDown 4   // číslo pinu tlačítka pro výběr MODE dolů
#define LED1  10    // číslo pinu LED1 zelená
#define LED2  11    // číslo pinu LED2 červená
#define LED3  5
#define LED4  6

#include <Wire.h>   // knihovny pro LCD přes I2C
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);   // nastavení adresy I2C (0x27), počtu znaků, řádků LCD 20x4

#include <Servo.h>  // knihovna pro ovládání serva
Servo myservo;  // instance třídy servo viz. Objektově Orientované Programování
int pos = 0;  // proměnná úhlu natočení serva

boolean buttonStateUp = false;  // nejnovější hodnota načtená ze vstupního pinu 
boolean lastButtonStateUp = false;  // předchozí hodnota načtení ze vstupního pinu
boolean lastTrueButtonStateUp = false;  // předchozí hodnota ošetřeného tlačítka

boolean buttonStateStart = false;
boolean lastButtonStart = false;
boolean lastTrueButtonStart = false;

boolean buttonStateDown = false;  
boolean lastButtonStateDown = false;  
boolean lastTrueButtonStateDown = false;  

int mode = 0;
boolean mamBezet = false;


unsigned long lastDebounceTime = 0;  // čas posledního změny výstupního pinu
unsigned long lastDebounceTime2 = 0;
unsigned long lastDebounceTime3 = 0;
unsigned long debounceDelay = 50;  // čas debounce prodlevy 

unsigned long aktualniMillis;   //aktualní čas 
unsigned long predchoziMillis1;   // předchozí čas pro rychle blikání
unsigned long predchoziMillis2;   // předchozí čas pro pomalé blikání
unsigned long predchoziMillis3;   // předchozí čas pro střídavé blikání
unsigned long cas = 0;
unsigned long casCekani;  // proměnná - do ní bude uložen čas, který už program načekal od stisku tlačítka start

long buttonTime;      //  čas začátku stisknutí tlačítka

boolean led1svetlo;   //  pomocná proměnná led1svetlo
boolean led2svetlo;   //  pomocná proměnná led2svetlo

boolean vypisLCD = true;  // proměnná kde si uchovávám jestli je potřeba provést update na lcd displeji

void setup() {
  
  pinMode(LED1, OUTPUT);  // pin pro LED1 nastaven jako výstup
  pinMode(LED2, OUTPUT);  // pin pro LED2 nastaven jako výstup
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  
  pinMode(buttonSelectUp, INPUT);  // pin pro tlačítko buttonSelect nastaveno jako vstup
  pinMode(buttonStart, INPUT);  // pin pro tlačítko buttonStart nastaveno jako vstup
  pinMode(buttonSelectDown, INPUT);  //pin pro tlačítko buttonSelectDown nastaveno jako vstup

  myservo.attach(9);  // pin pro servo

  lcd.begin();   // inicializace LCD
  lcd.backlight();   // zapnutí podsvícení
  Serial.begin(9600);   // konfigurace rychlosti seriového portu
  Serial.println("Seriovy port aktivni");  // První výpis na seriový port  
  
  lcd.setCursor( 2, 1);
  lcd.print("ready"); 
  delay(1500); 
  }  


void loop(){
  
 //-------------- debounce pro tlačítko Select Up ----------
  buttonStateUp = digitalRead(buttonSelectUp);  // přečtení stavu tlačítka    
  if (buttonStateUp != lastButtonStateUp) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime = millis();
  }                            
  if ((millis() - lastDebounceTime) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateUp != lastTrueButtonStateUp) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             
  
     if(buttonStateUp == true) { 
                               // přidáním podmínky - začátek počítání vždy např. od 10s
      if(mamBezet == false) {  // a taky přepnutí mode jen tehdy, když jsou mode ve Stop 
        if(mode < 6) {  // když je hodnota mode menší než 6
         mode++; // přičte k mode hodnotu 1
          vypisLCD = true;
        }          
       }   
     }
       lastTrueButtonStateUp = buttonStateUp;  // uložím si nový pravý ošetřený stav tlačítka           
    } 
  }     
  lastButtonStateUp = buttonStateUp; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
  //---------------konec ošetření tlačítka Select Up -----------

 //-------------- debounce pro tlačítko Select Down ----------
  buttonStateDown = digitalRead(buttonSelectDown);  // přečtení stavu tlačítka    
  if (buttonStateDown != lastButtonStateDown) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime3 = millis();
  }                            
  if ((millis() - lastDebounceTime3) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateDown != lastTrueButtonStateDown) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             
  
     if(buttonStateDown == true) { 
                               // přidáním podmínky docílím vždy celého odpočtu času 10s !
      if(mamBezet == false) {  // a taky přepnutí mode jen tehdy, když jsou mode ve Stop 
        if(mode > 0) {  // když je mode větší než 0
         mode--; // odečte od mode hodnotu 1          
         vypisLCD = true;  
         }             
       }  
     }
       lastTrueButtonStateDown = buttonStateDown;  // uložím si nový pravý ošetřený stav tlačítka           
    } 
  }     
  lastButtonStateDown = buttonStateDown; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
 //-------------- konec ořetření tlačítka Select Down ---------- 
  
  //-------------- debounce pro tlačítko START/STOP ----------  
    buttonStateStart = digitalRead(buttonStart);  // přečtení stavu tlačítka    
  if (buttonStateStart != lastButtonStart) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime2 = millis();
  }                            
  if ((millis() - lastDebounceTime2) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateStart != lastTrueButtonStart) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             

     if (buttonStateStart == true) {
         mamBezet = !mamBezet;          
         buttonTime = millis(); 
          vypisLCD = true;  // příkaz vypisuje funkci tlačítka, tedy start / stop
          Serial.println("stisk START/STOP");  // výpis na seriový monitor stisknutí tlačítka START/STOP                
      }
        // TADY CHYBÍ CO SE MÁ PROVÉST PŘI STISKU TLAČÍTKA START ... U MODE SE PŘIČÍTÁ MODE ...
        // ...U STARTU BY SE MĚLA PŘEKLÁPĚT PROMĚNNÁ mamBezet - hoď si tu nějaký výpis do seriové linky a uvidíš že to funguje
      }             
      lastTrueButtonStart = buttonStateStart;  // uložím si nový pravý ošetřený stav tlačítka        
    }  
   
  lastButtonStart = buttonStateStart; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
  //-------------- konec ořetření tlačítka Start/Stop ----------
   
                       
  if(mode == 0) {  // ******* LED1,LED2 vypnuto ******** 
     if(mamBezet == false){      
        led1svetlo = false;  // zhasni LED1              
        led2svetlo = false;  // zhasni LED2 
     }                        
   }
  
  if(mode == 1) {  // ******* LED1,LED2 zapnuto  ********    
       if(mamBezet == true){                                          
         led1svetlo = true;        
         led2svetlo = true;
       } else {       
          led1svetlo = false;         
          led2svetlo = false; 
         }
  }
                      
  if(mode == 2) {  // ******* LED1,LED2 blikání rychlé  *******     
       if(mamBezet == true) {   // ZRUŠENÁ PODMÍNKA mamBezet    - zmena true za false
           
           casCekani = millis() - buttonTime; //musíš si definovat novou proměnnou - do ní bude uložen čas který už program načekal od stisku tlačítka start
             
           if(casCekani  > 10000){  // zjistím si jestli je čas něco provést, uběhlo už 10s od poslední akce?            
               aktualniMillis = millis();  // podívám se na hodinky - aktuální čas 
               if(aktualniMillis - predchoziMillis1 > 200) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 200ms od poslední akce?                  
                 if (led1svetlo) {                           
                   led1svetlo = false;  // zhasnu LED1
                   led2svetlo = false;  // zhasnu LED2                   
                  } else {                    
                    led1svetlo = true;  // rožnu LED1
                    led2svetlo = true;  // rožnu LED2                                
                   }                                   
                   predchoziMillis1 = aktualniMillis;   // v tento čas jsem provedl poslední akci  
               }                                                                         
              } else {                                    
                 led1svetlo = false;
                 led2svetlo = false;                               
                 vypisLCD = true;                                                                           
                } 
        }       
  }
  
  if(mode == 3) {  // ******* LED1,LED2 blikání pomalé  *******  
     if(mamBezet == true){
        aktualniMillis = millis();  //podívám se na hodinky - aktuální čas  
       if(aktualniMillis - predchoziMillis2 > 500) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 500ms od poslední akce?  
         if (led2svetlo) {          
            led1svetlo = false;  // zhasnu LED1
            led2svetlo = false;  // zhasnu LED2
          } else {
            led1svetlo = true;  // rožnu LED1
            led2svetlo = true;  // rožnu LED2
             }
             predchoziMillis2 = aktualniMillis;   // v tento čas jsem provedl poslední akci 
        } 
      } else {
        led1svetlo = false;
        led2svetlo = false;   
      }        
     } 
                
     if(mode == 4) {  // ******* LED1,LED2 blikání střídavé  *******     
        if(mamBezet == true){ 
           aktualniMillis = millis();  //podívám se na hodinky - aktuální čas     
         if(aktualniMillis - predchoziMillis3 > 300) { // nejprve si zjistím jestli je čas něco provést, uběhlo už 300ms ?
           led1svetlo = !led1svetlo; // do proměnné led1svetlo zapíšu její negovanou hodnotu, tj. svítila-li LED1 tak zhasne, byla-li zhaslá rožne se
           led2svetlo = !led1svetlo; // do proměnné led2svetlo zapíšu negovanou hodnotu led1svetlo, tj. pokud LED1 svítí chci LED2 zhaslou a naopak
           predchoziMillis3 = aktualniMillis;   // v tento čas jsem provedl poslední akci 
          }   
         } else {              
           led1svetlo = false;
           led2svetlo = false;         
          }                       
     }

     if(mode == 5){  // ********** SERVO **********      
             if(mamBezet == true) {  // program spuštěn
                     if(lastTrueButtonStateUp == true){  // stisknuto tlačítko selectUp
                             //pokud můžu a nebourám servem do krajní pozice, měním pozici serva
                             if(pos <= 175){
                              pos +=1;
                              myservo.write(pos);                                                          
                             }
                     }
                     if(lastTrueButtonStateDown == true){  // stisknuto tlačítko selectDown
                             //pokud můžu a nebourám servem do druhé krajní pozice, měním pozici serva druhým směrem 
                             if(pos >= 5){
                              pos -=1;
                              myservo.write(pos);                                                           
                             }
                     }                     
                     digitalWrite(LED4, pos < 175);  // svítí, když je servo v pozici Up - 175° stupňů
                     digitalWrite(LED3, pos > 5);  // svítí, když je servo v pozici Down - 5° stupňů  
                     }
             }                
             if(mamBezet == false){  // když je mode5 ve stavu Stop, tak ledky jsou zhasnuté            
               digitalWrite(LED4,false);
               digitalWrite(LED3,false);                     
     }     
    
    digitalWrite(LED1,led1svetlo);  // aktualizace stavu LED1, zápis proměnné led1svetlo na výstupní pin 10
    digitalWrite(LED2,led2svetlo);  // aktualizace stavu LED2, zápis proměnné led2svetlo na výstupní pin 11 

    /*OBSLUHA 20x4 LCD DISPLAY*/
  if(vypisLCD){
    lcd.setCursor( 0, 1);  // tady se zadává pozice výpisu 3 znak, 2 řádek  BYLO 2,1
    lcd.print("  Mode ");
    lcd.print(mode);
    lcd.print("  -  ");       
    if(mamBezet){      
      lcd.print("START");
    } else {      
      lcd.print("STOP ");
     }
     
 //***********************  MODE = 2 VYPISY ZATIM JEN NA SERIOVY MONITOR  *****************   
    
        // tady si to musím pohlídat - tohle mode má totiž tři stavy, které chci vypsat - takže si musím zjistit v jakém stavu je
        // pokud program spuštěný není ... mamBezet == false ... chci si vypsat, že to je blikání s čekáním
        // pokud je spuštěný program mamBezet == true ... ale ještě nedošlo k uplynutí toho čekacího času, chci vypsat, že program se spustí za
        // nějakou dobu - takže vlastně i tu dobu si budu muset někde zapamatovat, nebo ji znovu zase vypočítat
        // pokud je spuštěný program mamBezet a už došlo k uplynutí zpoždění, tak chci vypsat, že LEDky blikají
        
        if(mode == 2){ // Dle mode vyberu který                    
           if(mamBezet == true){  // bezi a bud ceka nebo neceka            
              if(casCekani  < 10000){  // bezi a ceka ... vypisuji informaci o cekani ... napr zbyva 10000 - casCekani                                                                           
                 Serial.println(10000 - casCekani);  // výpis odočtu času 10s -> 0s  /*** pokud je vypis jen casCekani, tak odpocet 0s -> 10s ***/                                                             
              }else{  // beží a nečeká ... vypisuje informaci ... ledky blikají                          
                Serial.println("ledky blikají");                
              }              
              }else{  // nebezí ... vypisuje informaci ... co se děje v mode
                Serial.println("Mode Stop -> stiskni Start"); 
             }             
        }        
//*****************************************************************************************
        
    if(mode == 4){
      lcd.setCursor( 2, 2);
      lcd.print("               ");  // vymazání výpisu servo       
    } 
    
    if(mode == 5){                      
      lcd.setCursor( 2, 2);
      lcd.print("servo  "); 
    }   

  vypisLCD = false;    
  }     
  /*KONEC OBSLUHY 20x4 LCD DISPLAY*/
 }  
 
pak by mě taky zajímalo, jestli je nějaké pravidlo / nebo jak poznám /, že je třeba vytvořit novou proměnnou ? :roll:

Kód: Vybrat vše

        // pokud je spuštěný program mamBezet == true ... ale ještě nedošlo k uplynutí toho čekacího času, chci vypsat, že program se spustí za
        // nějakou dobu - takže vlastně i tu dobu si budu muset někde zapamatovat, nebo ji znovu zase vypočítat
tohle mi taky vrtá hlavou
děkuju

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

Re: Mini CNC osa Z

Příspěvek od kiRRow » 10 úno 2020, 16:37

Ono tě to asi naštve ... ale problém je v tom, že když ti skončí to odpočítavání a začne se plnit první část podmínky, je třeba říct vypisLCD = true;

Nová proměnná se vytváří vždy, když potřebuji procesorem zpracovat hodnotu a chci, aby si ji po určitou, nebo i po celou dobu pamatoval. Podle toho se taky proměnné rozdělují na globální a lokální.

Globální proměnná je taková, která je definována mimo jakékoliv {} ... tedy i mimo loop. K takové proměnné je přístup z jakékoliv části a funkce programu, ale za trest zabírá operační paměť celou dobu.
Lokální proměnná je taková, která je definována v {} (nadává se tomu scoop) ... K takové proměnné je přístup pouze a jedině z části programu, která je ve stejném scoopu a když program tento scoop opustí, proměnná přestává existovat a na její místo může být později uloženo něco jiného.

Hanz
Příspěvky: 262
Registrován: 25 dub 2019, 23:52
Reputation: 0

Re: Mini CNC osa Z

Příspěvek od Hanz » 12 úno 2020, 17:22

dobrý den, bohužel ani po doplnění o příkaz - vypisLCD = true; - se mi nedaří rozchodit výpisy v mode2 :twisted:
když dojdu k mode2 na lcd je výpis" Mode 2 - STOP" a na dalším řádku mám vypsáno "stiskni Start", po stisknutí tlačítka Start se vypíše "ledky blikaji", ale zároveň taky probíhá odpočet 10000ms , což není pravda. Po dokončení odpočtu se ledky fyzicky rozblikají a stále svítí výpis "ledky blikaji" což tady už pravda je :cry:
tady je kod

Kód: Vybrat vše

#define buttonSelectUp 2   // číslo pinu tlačítka SELECT pro výběr MODE nahoru
#define buttonStart 3   // číslo pinu tlačítka START/STOP - červené
#define buttonSelectDown 4   // číslo pinu tlačítka pro výběr MODE dolů
#define LED1  10    // číslo pinu LED1 zelená
#define LED2  11    // číslo pinu LED2 červená
#define LED3  5
#define LED4  6

#include <Wire.h>   // knihovny pro LCD přes I2C
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);   // nastavení adresy I2C (0x27), počtu znaků, řádků LCD 20x4

#include <Servo.h>  // knihovna pro ovládání serva
Servo myservo;  // instance třídy servo viz. Objektově Orientované Programování
int pos = 0;  // proměnná úhlu natočení serva

boolean buttonStateUp = false;  // nejnovější hodnota načtená ze vstupního pinu 
boolean lastButtonStateUp = false;  // předchozí hodnota načtení ze vstupního pinu
boolean lastTrueButtonStateUp = false;  // předchozí hodnota ošetřeného tlačítka

boolean buttonStateStart = false;
boolean lastButtonStart = false;
boolean lastTrueButtonStart = false;

boolean buttonStateDown = false;  
boolean lastButtonStateDown = false;  
boolean lastTrueButtonStateDown = false;  

int mode = 0;
boolean mamBezet = false;


unsigned long lastDebounceTime = 0;  // čas posledního změny výstupního pinu
unsigned long lastDebounceTime2 = 0;
unsigned long lastDebounceTime3 = 0;
unsigned long debounceDelay = 50;  // čas debounce prodlevy 

unsigned long aktualniMillis;   //aktualní čas 
unsigned long predchoziMillis1;   // předchozí čas pro rychle blikání
unsigned long predchoziMillis2;   // předchozí čas pro pomalé blikání
unsigned long predchoziMillis3;   // předchozí čas pro střídavé blikání
unsigned long cas = 0;
unsigned long casCekani;  // proměnná - do ní bude uložen čas, který už program načekal od stisku tlačítka start

long buttonTime;      //  čas začátku stisknutí tlačítka

boolean led1svetlo;   //  pomocná proměnná led1svetlo
boolean led2svetlo;   //  pomocná proměnná led2svetlo

boolean vypisLCD = true;  // proměnná kde si uchovávám jestli je potřeba provést update na lcd displeji


void setup() {
  
  pinMode(LED1, OUTPUT);  // pin pro LED1 nastaven jako výstup
  pinMode(LED2, OUTPUT);  // pin pro LED2 nastaven jako výstup
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  
  pinMode(buttonSelectUp, INPUT);  // pin pro tlačítko buttonSelect nastaveno jako vstup
  pinMode(buttonStart, INPUT);  // pin pro tlačítko buttonStart nastaveno jako vstup
  pinMode(buttonSelectDown, INPUT);  //pin pro tlačítko buttonSelectDown nastaveno jako vstup

  myservo.attach(9);  // pin pro servo

  lcd.begin();   // inicializace LCD
  lcd.backlight();   // zapnutí podsvícení
  Serial.begin(9600);   // konfigurace rychlosti seriového portu
  Serial.println("Seriovy port aktivni");  // První výpis na seriový port  
  
  lcd.setCursor( 2, 1);
  lcd.print("ready"); 
  delay(1500); 
  }  


void loop(){
  
 //-------------- debounce pro tlačítko Select Up ----------
  buttonStateUp = digitalRead(buttonSelectUp);  // přečtení stavu tlačítka    
  if (buttonStateUp != lastButtonStateUp) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime = millis();
  }                            
  if ((millis() - lastDebounceTime) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateUp != lastTrueButtonStateUp) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             
  
     if(buttonStateUp == true) { 
                               // přidáním podmínky - začátek počítání vždy např. od 10s
      if(mamBezet == false) {  // a taky přepnutí mode jen tehdy, když jsou mode ve Stop 
        if(mode < 5) {  // když je hodnota mode menší než 5
         mode++; // přičte k mode hodnotu 1
          vypisLCD = true;
          
        }          
       }   
     }
       lastTrueButtonStateUp = buttonStateUp;  // uložím si nový pravý ošetřený stav tlačítka           
    } 
  }     
  lastButtonStateUp = buttonStateUp; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
  //---------------konec ošetření tlačítka Select Up -----------

 //-------------- debounce pro tlačítko Select Down ----------
  buttonStateDown = digitalRead(buttonSelectDown);  // přečtení stavu tlačítka    
  if (buttonStateDown != lastButtonStateDown) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime3 = millis();
  }                            
  if ((millis() - lastDebounceTime3) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateDown != lastTrueButtonStateDown) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             
  
     if(buttonStateDown == true) { 
                               // přidáním podmínky docílím vždy celého odpočtu času 10s !
      if(mamBezet == false) {  // a taky přepnutí mode jen tehdy, když jsou mode ve Stop 
        if(mode > 0) {  // když je mode větší než 0
         mode--; // odečte od mode hodnotu 1          
         vypisLCD = true; 
          
         }             
       }  
     }
       lastTrueButtonStateDown = buttonStateDown;  // uložím si nový pravý ošetřený stav tlačítka           
    } 
  }     
  lastButtonStateDown = buttonStateDown; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
 //-------------- konec ořetření tlačítka Select Down ---------- 
  
  //-------------- debounce pro tlačítko START/STOP ----------  
    buttonStateStart = digitalRead(buttonStart);  // přečtení stavu tlačítka    
  if (buttonStateStart != lastButtonStart) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime2 = millis();
  }                            
  if ((millis() - lastDebounceTime2) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateStart != lastTrueButtonStart) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             

     if (buttonStateStart == true) {
         mamBezet = !mamBezet;          
         buttonTime = millis(); 
          vypisLCD = true;  // příkaz vypisuje funkci tlačítka, tedy start / stop
          
          Serial.println("stisk START/STOP");  // výpis na seriový monitor stisknutí tlačítka START/STOP                
      }
        // TADY CHYBÍ CO SE MÁ PROVÉST PŘI STISKU TLAČÍTKA START ... U MODE SE PŘIČÍTÁ MODE ...
        // ...U STARTU BY SE MĚLA PŘEKLÁPĚT PROMĚNNÁ mamBezet - hoď si tu nějaký výpis do seriové linky a uvidíš že to funguje
      }             
      lastTrueButtonStart = buttonStateStart;  // uložím si nový pravý ošetřený stav tlačítka        
    }  
   
  lastButtonStart = buttonStateStart; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
  //-------------- konec ořetření tlačítka Start/Stop ----------
   
                       
  if(mode == 0) {  // ******* LED1,LED2 vypnuto ******** 
     if(mamBezet == false){      
        led1svetlo = false;  // zhasni LED1              
        led2svetlo = false;  // zhasni LED2 
     }                        
   }
  
  if(mode == 1) {  // ******* LED1,LED2 zapnuto  ********    
       if(mamBezet == true){                                          
         led1svetlo = true;        
         led2svetlo = true;
       } else {       
          led1svetlo = false;         
          led2svetlo = false; 
         }
  }
                      
  if(mode == 2) {  // ******* LED1,LED2 blikání rychlé  *******     
       if(mamBezet == true) {   // ZRUŠENÁ PODMÍNKA mamBezet    - zmena true za false
           
           casCekani = millis() - buttonTime; //musíš si definovat novou proměnnou - do ní bude uložen čas který už program načekal od stisku tlačítka start
             
           if(casCekani  > 10000){  // zjistím si jestli je čas něco provést, uběhlo už 10s od poslední akce?            
               aktualniMillis = millis();  // podívám se na hodinky - aktuální čas 
               if(aktualniMillis - predchoziMillis1 > 200) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 200ms od poslední akce?                  
                 if (led1svetlo) {                           
                   led1svetlo = false;  // zhasnu LED1
                   led2svetlo = false;  // zhasnu LED2                   
                  } else {                    
                    led1svetlo = true;  // rožnu LED1
                    led2svetlo = true;  // rožnu LED2                                
                   }                                   
                   predchoziMillis1 = aktualniMillis;   // v tento čas jsem provedl poslední akci  
               }                                                                         
              } else {                                    
                 led1svetlo = false;
                 led2svetlo = false;                               
                 vypisLCD = true;                                                                                           
                } 
        }       
  }
  
  if(mode == 3) {  // ******* LED1,LED2 blikání pomalé  *******  
     if(mamBezet == true){
        aktualniMillis = millis();  //podívám se na hodinky - aktuální čas  
       if(aktualniMillis - predchoziMillis2 > 500) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 500ms od poslední akce?  
         if (led2svetlo) {          
            led1svetlo = false;  // zhasnu LED1
            led2svetlo = false;  // zhasnu LED2
          } else {
            led1svetlo = true;  // rožnu LED1
            led2svetlo = true;  // rožnu LED2
             }
             predchoziMillis2 = aktualniMillis;   // v tento čas jsem provedl poslední akci 
        } 
      } else {
        led1svetlo = false;
        led2svetlo = false;   
      }        
     } 
                
     if(mode == 4) {  // ******* LED1,LED2 blikání střídavé  *******     
        if(mamBezet == true){ 
           aktualniMillis = millis();  //podívám se na hodinky - aktuální čas     
         if(aktualniMillis - predchoziMillis3 > 300) { // nejprve si zjistím jestli je čas něco provést, uběhlo už 300ms ?
           led1svetlo = !led1svetlo; // do proměnné led1svetlo zapíšu její negovanou hodnotu, tj. svítila-li LED1 tak zhasne, byla-li zhaslá rožne se
           led2svetlo = !led1svetlo; // do proměnné led2svetlo zapíšu negovanou hodnotu led1svetlo, tj. pokud LED1 svítí chci LED2 zhaslou a naopak
           predchoziMillis3 = aktualniMillis;   // v tento čas jsem provedl poslední akci 
          }   
         } else {              
           led1svetlo = false;
           led2svetlo = false;         
          }                       
     }

     if(mode == 5){  // ********** SERVO **********      
             if(mamBezet == true) {  // program spuštěn
                     if(lastTrueButtonStateUp == true){  // stisknuto tlačítko selectUp
                             //pokud můžu a nebourám servem do krajní pozice, měním pozici serva
                             if(pos <= 175){
                              pos +=1;
                              myservo.write(pos);                                                          
                             }
                     }
                     if(lastTrueButtonStateDown == true){  // stisknuto tlačítko selectDown
                             //pokud můžu a nebourám servem do druhé krajní pozice, měním pozici serva druhým směrem 
                             if(pos >= 5){
                              pos -=1;
                              myservo.write(pos);                                                           
                             }
                     }                     
                     digitalWrite(LED4, pos < 175);  // svítí, když je servo v pozici Up - 175° stupňů
                     digitalWrite(LED3, pos > 5);  // svítí, když je servo v pozici Down - 5° stupňů  
                     }
             }                
             if(mamBezet == false){  // když je mode5 ve stavu Stop, tak ledky jsou zhasnuté            
               digitalWrite(LED4,false);
               digitalWrite(LED3,false);                     
     }     
    
    digitalWrite(LED1,led1svetlo);  // aktualizace stavu LED1, zápis proměnné led1svetlo na výstupní pin 10
    digitalWrite(LED2,led2svetlo);  // aktualizace stavu LED2, zápis proměnné led2svetlo na výstupní pin 11 

    /*OBSLUHA 20x4 LCD DISPLAY*/
  if(vypisLCD){
    lcd.setCursor( 0, 1);  // tady se zadává pozice výpisu 3 znak, 2 řádek  
    lcd.print("  Mode ");
    lcd.print(mode);
    lcd.print("  -  ");       
    if(mamBezet){      
      lcd.print("START");
    } else {      
      lcd.print("STOP ");
     }
     
    if(mode == 1){
      lcd.setCursor( 2, 2);
      lcd.print("               ");  // vymazání výpisu ...koment mode       
    }      
 //***********************  MODE = 2 VYPISY *****************  
        // tady si to musím pohlídat - tohle mode má totiž tři stavy, které chci vypsat - takže si musím zjistit v jakém stavu je
        // pokud program spuštěný není ... mamBezet == false ... chci si vypsat, že to je blikání s čekáním
        // pokud je spuštěný program mamBezet == true ... ale ještě nedošlo k uplynutí toho čekacího času, chci vypsat, že program se spustí za
        // nějakou dobu - takže vlastně i tu dobu si budu muset někde zapamatovat, nebo ji znovu zase vypočítat
        // pokud je spuštěný program mamBezet a už došlo k uplynutí zpoždění, tak chci vypsat, že LEDky blikají
        
        if(mode == 2){ // Dle mode vyberu který                    
           if(mamBezet == true){  // bezi a bud ceka nebo neceka           
              if(casCekani > 10000){  // bezi a ceka ... vypisuji informaci o cekani ... napr zbyva 10000 - casCekani                                                                    
                 lcd.setCursor( 2, 2);
                 lcd.print(10000 - casCekani);
                 lcd.setCursor( 6, 2);
                 lcd.print("         ");  // vymazání předešlého výpisu                  
       //         vypisLCD = true;  // update na lcd displeji                                                                                                                                       
              }else{  // beží a nečeká ... vypisuje informaci ... ledky blikají                                                                    
                lcd.setCursor( 2, 2);
                lcd.print("ledky blikaji"); 
                vypisLCD = true;                                    
              }                     
              }else{  // nebezí ... vypisuje informaci ... co se děje v mode                
                lcd.setCursor( 2, 2);
                lcd.print("stiskni Start");                
             }             
        }        
//*****************************************************************************************
        
    if(mode == 3){
      lcd.setCursor( 2, 2);
      lcd.print("               ");  // vymazání výpisu ... koment mode       
    } 

    if(mode == 4){
      lcd.setCursor( 2, 2);
      lcd.print("               ");  // vymazání výpisu ... koment mode       
    } 
        
    if(mode == 5){                      
      lcd.setCursor( 2, 2);
      lcd.print("servo  ");  // výpis, že mode obsluhuje servo
    }   

  vypisLCD = false;    
  }     
  /*KONEC OBSLUHY 20x4 LCD DISPLAY*/
 }  
 
mělo by to vypadat tak, že se dostanu do mode2 a jsem ve stavu Stop, vypis stiskni Start, stisknu Start, vypisuje se odpočet 10000ms a po odpočtu se rozblikají led s výpisem "ledky blikají", stisknu Stop, výpis "stiskni Start", nebo můžu do jiného mode tlačítkama Up/Down
pokud jsem změnit znaménko v mode2 u if(casCekani > 10000){ // bezi a ceka ...že casCekani < ... tak se mi vypisoval na lcd odpocet 10000ms, který se nezměnil po odpočtu na výpis "ledky blikaji" i když už ledky blikaly ? děkuju

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

Re: Mini CNC osa Z

Příspěvek od kiRRow » 12 úno 2020, 18:43

Kód: Vybrat vše

if(mode == 2) {  // ******* LED1,LED2 blikání rychlé  *******     
       if(mamBezet == true) {   // ZRUŠENÁ PODMÍNKA mamBezet    - zmena true za false
           
           casCekani = millis() - buttonTime; //musíš si definovat novou proměnnou - do ní bude uložen čas který už program načekal od stisku tlačítka start
             
           if(casCekani  > 10000){  // zjistím si jestli je čas něco provést, uběhlo už 10s od poslední akce?
           
           	vypisLCD = true; // cekani uběhlo, potřebuji vypsat displej (akorát ho to bude vypisovat pokaždé, když to teď poběží kolem)
           	
           	// dá se to vyřešit tak, že si vytvořím další proměnnou blokujLCD ... a po prvním výpisu si ji nastavím na true - a vypis obalím do podmínky
           	// if(blokujLCD == false) { vypisLCD = true; blokujLCD = true; }
           
               aktualniMillis = millis();  // podívám se na hodinky - aktuální čas 
               if(aktualniMillis - predchoziMillis1 > 200) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 200ms od poslední akce?                  
                 if (led1svetlo) {                           
                   led1svetlo = false;  // zhasnu LED1
                   led2svetlo = false;  // zhasnu LED2                   
                  } else {                    
                    led1svetlo = true;  // rožnu LED1
                    led2svetlo = true;  // rožnu LED2                                
                   }                                   
                   predchoziMillis1 = aktualniMillis;   // v tento čas jsem provedl poslední akci  
               }                                                                         
              } else {                                    
                 led1svetlo = false;
                 led2svetlo = false;                               
                 vypisLCD = true;
                 // program skoncil, takže si uvolním blokaci displeje blokujLCD = false;                                                  
                } 
        }       
  }
Do ošetření LCD nedávej vypisLCD = true; ... nemá to vůbec smysl, protože na konci programu se to stejně nastaví na false ... a ten text budeš muset smazat nebo přepsat ...

Hanz
Příspěvky: 262
Registrován: 25 dub 2019, 23:52
Reputation: 0

Re: Mini CNC osa Z

Příspěvek od Hanz » 17 úno 2020, 10:04

dobrý den, stále bojuji s výpisem na lcd a i když jsem provedl úpravy podle kiRRow, tak výpisy nechodily , jak měly :cry:
vytvořena nová proměnná

Kód: Vybrat vše

unsigned long blokujLCD;
Nezdála se mi podmínka u ošetření lcd v mode2, kdy tam bylo, že ... čas čekání je větší než 10000 ...

Kód: Vybrat vše

   if(casCekani > 10000){  // bezi a ceka ... 
otočil jsem znaménko na ... je menší než 10000... no a výpisy začly chodit správně ?

Kód: Vybrat vše

   if(casCekani < 10000){  // bezi a ceka ... 
možná to byl problém i u předchozích výpisů ?
Nyní však nechodí vizuální odpočet času od 10000ms do 0ms, jen výpis na lcd "čekam 10s" ?
Výpisy na LCD byly malinko upraveny, ale to jen pro info. Kod je zde :

Kód: Vybrat vše

#define buttonSelectUp 2   // číslo pinu tlačítka SELECT pro výběr MODE nahoru
#define buttonStart 3   // číslo pinu tlačítka START/STOP - červené
#define buttonSelectDown 4   // číslo pinu tlačítka pro výběr MODE dolů
#define LED1  10    // číslo pinu LED1 zelená
#define LED2  11    // číslo pinu LED2 červená
#define LED3  5
#define LED4  6

#include <Wire.h>   // knihovny pro LCD přes I2C
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);   // nastavení adresy I2C (0x27), počtu znaků, řádků LCD 20x4

#include <Servo.h>  // knihovna pro ovládání serva
Servo myservo;  // instance třídy servo viz. Objektově Orientované Programování
int pos = 0;  // proměnná úhlu natočení serva

boolean buttonStateUp = false;  // nejnovější hodnota načtená ze vstupního pinu 
boolean lastButtonStateUp = false;  // předchozí hodnota načtení ze vstupního pinu
boolean lastTrueButtonStateUp = false;  // předchozí hodnota ošetřeného tlačítka

boolean buttonStateStart = false;
boolean lastButtonStart = false;
boolean lastTrueButtonStart = false;

boolean buttonStateDown = false;  
boolean lastButtonStateDown = false;  
boolean lastTrueButtonStateDown = false;  

int mode = 0;
boolean mamBezet = false;


unsigned long lastDebounceTime = 0;  // čas posledního změny výstupního pinu
unsigned long lastDebounceTime2 = 0;
unsigned long lastDebounceTime3 = 0;
unsigned long debounceDelay = 50;  // čas debounce prodlevy 

unsigned long aktualniMillis;   //aktualní čas 
unsigned long predchoziMillis1;   // předchozí čas pro rychle blikání
unsigned long predchoziMillis2;   // předchozí čas pro pomalé blikání
unsigned long predchoziMillis3;   // předchozí čas pro střídavé blikání
unsigned long cas = 0;
unsigned long casCekani;  // proměnná - do ní bude uložen čas, který už program načekal od stisku tlačítka start
unsigned long blokujLCD;

long buttonTime;      //  čas začátku stisknutí tlačítka

boolean led1svetlo;   //  pomocná proměnná led1svetlo
boolean led2svetlo;   //  pomocná proměnná led2svetlo

boolean vypisLCD = true;  // proměnná kde si uchovávám jestli je potřeba provést update na lcd displeji


void setup() {
  
  pinMode(LED1, OUTPUT);  // pin pro LED1 nastaven jako výstup
  pinMode(LED2, OUTPUT);  // pin pro LED2 nastaven jako výstup
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  
  pinMode(buttonSelectUp, INPUT);  // pin pro tlačítko buttonSelect nastaveno jako vstup
  pinMode(buttonStart, INPUT);  // pin pro tlačítko buttonStart nastaveno jako vstup
  pinMode(buttonSelectDown, INPUT);  //pin pro tlačítko buttonSelectDown nastaveno jako vstup

  myservo.attach(9);  // pin pro servo

  lcd.begin();   // inicializace LCD
  lcd.backlight();   // zapnutí podsvícení
  Serial.begin(9600);   // konfigurace rychlosti seriového portu
  Serial.println("Seriovy port aktivni");  // První výpis na seriový port  
  
  lcd.setCursor( 2, 1);
  lcd.print("ready"); 
  delay(1500); 
  }  


void loop(){
  
 //-------------- debounce pro tlačítko Select Up ----------
  buttonStateUp = digitalRead(buttonSelectUp);  // přečtení stavu tlačítka    
  if (buttonStateUp != lastButtonStateUp) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime = millis();
  }                            
  if ((millis() - lastDebounceTime) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateUp != lastTrueButtonStateUp) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             
  
     if(buttonStateUp == true) { 
                               // přidáním podmínky - začátek počítání vždy např. od 10s
      if(mamBezet == false) {  // a taky přepnutí mode jen tehdy, když jsou mode ve Stop 
        if(mode < 5) {  // když je hodnota mode menší než 5
         mode++; // přičte k mode hodnotu 1
          vypisLCD = true;
          
        }          
       }   
     }
       lastTrueButtonStateUp = buttonStateUp;  // uložím si nový pravý ošetřený stav tlačítka           
    } 
  }     
  lastButtonStateUp = buttonStateUp; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
  //---------------konec ošetření tlačítka Select Up -----------

 //-------------- debounce pro tlačítko Select Down ----------
  buttonStateDown = digitalRead(buttonSelectDown);  // přečtení stavu tlačítka    
  if (buttonStateDown != lastButtonStateDown) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime3 = millis();
  }                            
  if ((millis() - lastDebounceTime3) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateDown != lastTrueButtonStateDown) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             
  
     if(buttonStateDown == true) { 
                               // přidáním podmínky docílím vždy celého odpočtu času 10s !
      if(mamBezet == false) {  // a taky přepnutí mode jen tehdy, když jsou mode ve Stop 
        if(mode > 0) {  // když je mode větší než 0
         mode--; // odečte od mode hodnotu 1          
         vypisLCD = true; 
          
         }             
       }  
     }
       lastTrueButtonStateDown = buttonStateDown;  // uložím si nový pravý ošetřený stav tlačítka           
    } 
  }     
  lastButtonStateDown = buttonStateDown; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
 //-------------- konec ořetření tlačítka Select Down ---------- 
  
  //-------------- debounce pro tlačítko START/STOP ----------  
    buttonStateStart = digitalRead(buttonStart);  // přečtení stavu tlačítka    
  if (buttonStateStart != lastButtonStart) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime2 = millis();
  }                            
  if ((millis() - lastDebounceTime2) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateStart != lastTrueButtonStart) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             

     if (buttonStateStart == true) {
         mamBezet = !mamBezet;          
         buttonTime = millis(); 
          vypisLCD = true;  // příkaz vypisuje funkci tlačítka, tedy start / stop
          
          Serial.println("stisk START/STOP");  // výpis na seriový monitor stisknutí tlačítka START/STOP                
      }
        // TADY CHYBÍ CO SE MÁ PROVÉST PŘI STISKU TLAČÍTKA START ... U MODE SE PŘIČÍTÁ MODE ...
        // ...U STARTU BY SE MĚLA PŘEKLÁPĚT PROMĚNNÁ mamBezet - hoď si tu nějaký výpis do seriové linky a uvidíš že to funguje
      }             
      lastTrueButtonStart = buttonStateStart;  // uložím si nový pravý ošetřený stav tlačítka        
    }  
   
  lastButtonStart = buttonStateStart; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
  //-------------- konec ořetření tlačítka Start/Stop ----------
   
                       
  if(mode == 0) {  // ******* LED1,LED2 vypnuto ******** 
     if(mamBezet == false){      
        led1svetlo = false;  // zhasni LED1              
        led2svetlo = false;  // zhasni LED2 
     }                        
   }
  
  if(mode == 1) {  // ******* LED1,LED2 zapnuto  ********    
       if(mamBezet == true){                                          
         led1svetlo = true;        
         led2svetlo = true;
       } else {       
          led1svetlo = false;         
          led2svetlo = false; 
         }
  }
                    
if(mode == 2) {  // ******* LED1,LED2 blikání rychlé  *******     
       if(mamBezet == true) {   // ZRUŠENÁ PODMÍNKA mamBezet    - zmena true za false
           
           casCekani = millis() - buttonTime; //musíš si definovat novou proměnnou - do ní bude uložen čas který už program načekal od stisku tlačítka start
             
           if(casCekani  > 10000){  // zjistím si jestli je čas něco provést, uběhlo už 10s od poslední akce?
           
             vypisLCD = true; // cekani uběhlo, potřebuji vypsat displej (akorát ho to bude vypisovat pokaždé, když to teď poběží kolem)
            
            // dá se to vyřešit tak, že si vytvořím další proměnnou blokujLCD ... a po prvním výpisu si ji nastavím na true - a vypis obalím do podmínky
            // if(blokujLCD == false) { vypisLCD = true; blokujLCD = true; } -> do výpisu LCD
           
               aktualniMillis = millis();  // podívám se na hodinky - aktuální čas 
               if(aktualniMillis - predchoziMillis1 > 200) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 200ms od poslední akce?                  
                 if (led1svetlo) {                           
                   led1svetlo = false;  // zhasnu LED1
                   led2svetlo = false;  // zhasnu LED2                   
                  } else {                    
                    led1svetlo = true;  // rožnu LED1
                    led2svetlo = true;  // rožnu LED2                                
                   }                                   
                   predchoziMillis1 = aktualniMillis;   // v tento čas jsem provedl poslední akci  
               }                                                                         
              } else {                                    
                 led1svetlo = false;
                 led2svetlo = false;                               
             //    vypisLCD = true;
                 blokujLCD = false;  // program skoncil, takže si uvolním blokaci displeje blokujLCD = false;                                                  
                } 
        }       
  }

 
  if(mode == 3) {  // ******* LED1,LED2 blikání pomalé  *******  
     if(mamBezet == true){
        aktualniMillis = millis();  //podívám se na hodinky - aktuální čas  
       if(aktualniMillis - predchoziMillis2 > 500) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 500ms od poslední akce?  
         if (led2svetlo) {          
            led1svetlo = false;  // zhasnu LED1
            led2svetlo = false;  // zhasnu LED2
          } else {
            led1svetlo = true;  // rožnu LED1
            led2svetlo = true;  // rožnu LED2
             }
             predchoziMillis2 = aktualniMillis;   // v tento čas jsem provedl poslední akci 
        } 
      } else {
        led1svetlo = false;
        led2svetlo = false;   
      }        
     } 
                
     if(mode == 4) {  // ******* LED1,LED2 blikání střídavé  *******     
        if(mamBezet == true){ 
           aktualniMillis = millis();  //podívám se na hodinky - aktuální čas     
         if(aktualniMillis - predchoziMillis3 > 300) { // nejprve si zjistím jestli je čas něco provést, uběhlo už 300ms ?
           led1svetlo = !led1svetlo; // do proměnné led1svetlo zapíšu její negovanou hodnotu, tj. svítila-li LED1 tak zhasne, byla-li zhaslá rožne se
           led2svetlo = !led1svetlo; // do proměnné led2svetlo zapíšu negovanou hodnotu led1svetlo, tj. pokud LED1 svítí chci LED2 zhaslou a naopak
           predchoziMillis3 = aktualniMillis;   // v tento čas jsem provedl poslední akci 
          }   
         } else {              
           led1svetlo = false;
           led2svetlo = false;         
          }                       
     }

     if(mode == 5){  // ********** SERVO **********      
             if(mamBezet == true) {  // program spuštěn
                     if(lastTrueButtonStateUp == true){  // stisknuto tlačítko selectUp
                             //pokud můžu a nebourám servem do krajní pozice, měním pozici serva
                             if(pos <= 175){
                              pos +=1;
                              myservo.write(pos);                                                          
                             }
                     }
                     if(lastTrueButtonStateDown == true){  // stisknuto tlačítko selectDown
                             //pokud můžu a nebourám servem do druhé krajní pozice, měním pozici serva druhým směrem 
                             if(pos >= 5){
                              pos -=1;
                              myservo.write(pos);                                                           
                             }
                     }                     
                     digitalWrite(LED4, pos < 175);  // svítí, když je servo v pozici Up - 175° stupňů
                     digitalWrite(LED3, pos > 5);  // svítí, když je servo v pozici Down - 5° stupňů  
                     }
             }                
             if(mamBezet == false){  // když je mode5 ve stavu Stop, tak ledky jsou zhasnuté            
               digitalWrite(LED4,false);
               digitalWrite(LED3,false);                     
     }     
    
    digitalWrite(LED1,led1svetlo);  // aktualizace stavu LED1, zápis proměnné led1svetlo na výstupní pin 10
    digitalWrite(LED2,led2svetlo);  // aktualizace stavu LED2, zápis proměnné led2svetlo na výstupní pin 11 

    /*OBSLUHA 20x4 LCD DISPLAY*/
  if(vypisLCD){
    lcd.setCursor( 0, 1);  // tady se zadává pozice výpisu 3 znak, 2 řádek  
    lcd.print("  Mode ");
    lcd.print(mode);
    lcd.print("  -  ");       
    if(mamBezet){      
      lcd.print("START");
    } else {      
      lcd.print("STOP ");
     }
     
    if(mode == 1){
      lcd.setCursor( 2, 2);
      lcd.print("               ");  // vymazání výpisu ...koment mode       
    }      
 //***********************  MODE = 2 VYPISY *****************  
        // tady si to musím pohlídat - tohle mode má totiž tři stavy, které chci vypsat - takže si musím zjistit v jakém stavu je
        // pokud program spuštěný není ... mamBezet == false ... chci si vypsat, že to je blikání s čekáním
        // pokud je spuštěný program mamBezet == true ... ale ještě nedošlo k uplynutí toho čekacího času, chci vypsat, že program se spustí za
        // nějakou dobu - takže vlastně i tu dobu si budu muset někde zapamatovat, nebo ji znovu zase vypočítat
        // pokud je spuštěný program mamBezet a už došlo k uplynutí zpoždění, tak chci vypsat, že LEDky blikají
        
        if(mode == 2){ // Dle mode vyberu který                    
           if(mamBezet == true){  // bezi a bud ceka nebo neceka           
              if(casCekani < 10000){  // bezi a ceka ... vypisuji informaci o cekani ... napr zbyva 10000 - casCekani 
                lcd.setCursor( 2, 2);
                lcd.print("cekam 10s");                  
                 if(blokujLCD == false) {
                  vypisLCD = true; blokujLCD = true;  // viz.koment mode2
                  }                                                                                                                     
              }else{  // beží a nečeká ... vypisuje informaci ... ledky blikají                                                                    
                lcd.setCursor( 2, 2);
                lcd.print("ledky blikaji ");                                    
              }                     
              }else{  // nebezí ... vypisuje informaci ... co se děje v mode                
                lcd.setCursor( 2, 2);
                lcd.print("s cekanim    ");                
             }             
        }     
           
//*****************************************************************************************
        
    if(mode == 3){
      lcd.setCursor( 2, 2);
      lcd.print("               ");  // vymazání výpisu ... může být koment mode       
    } 

    if(mode == 4){
      lcd.setCursor( 2, 2);
      lcd.print("               ");  // vymazání výpisu ... může být koment mode       
    } 
        
    if(mode == 5){                      
      lcd.setCursor( 2, 2);
      lcd.print("servo  ");  // výpis, že mode obsluhuje servo
    }   

  vypisLCD = false;    
  }     
  /*KONEC OBSLUHY 20x4 LCD DISPLAY*/
 }  
 
záměrně vše nechávám i s komenty v kodu,
snad se nemýlím děkuju

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

Re: Mini CNC osa Z

Příspěvek od kiRRow » 20 úno 2020, 18:05

jestli čekáš, tak já taky čekám ... čekám, jestli jsi se něco naučil.

a ano ... stím znaménkem jsem udělal chybu já ... přišel jsi na ni náhodou, nebo to byl úmysl ? :)

Hanz
Příspěvky: 262
Registrován: 25 dub 2019, 23:52
Reputation: 0

Re: Mini CNC osa Z

Příspěvek od Hanz » 23 úno 2020, 00:13

dobrý den,není důvod k radosti, protože zkouším přijít na to, aby mi mode2 vypisovalo číselný odpočet čekání 10s :roll: než začnou blikat LED. Pokud je to napsáno slovně tj. "cekam 10s", tak lcd vypisuje ok.
Jakmile napíšu do výpisu lcd.print(10000 - casCekání); tak to píše nesmysly.
A ano, asi jsem se toho moc nenaučil :cry: Protože, opět potřebuju poradit a nepomohly mi ani nápovědy :oops:
Kod je vlastně skoro stejný - funkční výpis v mode2, pokud nechci vidět číselný odpočet

Kód: Vybrat vše

#define buttonSelectUp 2   // číslo pinu tlačítka SELECT pro výběr MODE nahoru
#define buttonStart 3   // číslo pinu tlačítka START/STOP - červené
#define buttonSelectDown 4   // číslo pinu tlačítka pro výběr MODE dolů
#define LED1  10    // číslo pinu LED1 zelená
#define LED2  11    // číslo pinu LED2 červená
#define LED3  5
#define LED4  6

#include <Wire.h>   // knihovny pro LCD přes I2C
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);   // nastavení adresy I2C (0x27), počtu znaků, řádků LCD 20x4

#include <Servo.h>  // knihovna pro ovládání serva
Servo myservo;  // instance třídy servo viz. Objektově Orientované Programování
int pos = 0;  // proměnná úhlu natočení serva
int poc;  //  nastaveni pocitadla

boolean buttonStateUp = false;  // nejnovější hodnota načtená ze vstupního pinu 
boolean lastButtonStateUp = false;  // předchozí hodnota načtení ze vstupního pinu
boolean lastTrueButtonStateUp = false;  // předchozí hodnota ošetřeného tlačítka

boolean buttonStateStart = false;
boolean lastButtonStart = false;
boolean lastTrueButtonStart = false;

boolean buttonStateDown = false;  
boolean lastButtonStateDown = false;  
boolean lastTrueButtonStateDown = false;  

int mode = 0;
boolean mamBezet = false;


unsigned long lastDebounceTime = 0;  // čas posledního změny výstupního pinu
unsigned long lastDebounceTime2 = 0;
unsigned long lastDebounceTime3 = 0;
unsigned long debounceDelay = 50;  // čas debounce prodlevy 

unsigned long aktualniMillis;   //aktualní čas 
unsigned long predchoziMillis1;   // předchozí čas pro rychle blikání
unsigned long predchoziMillis2;   // předchozí čas pro pomalé blikání
unsigned long predchoziMillis3;   // předchozí čas pro střídavé blikání
unsigned long cas = 0;
unsigned long casCekani;  // proměnná - do ní bude uložen čas, který už program načekal od stisku tlačítka start
unsigned long blokujLCD;

long buttonTime;      //  čas začátku stisknutí tlačítka

boolean led1svetlo;   //  pomocná proměnná led1svetlo
boolean led2svetlo;   //  pomocná proměnná led2svetlo

boolean vypisLCD = true;  // proměnná kde si uchovávám jestli je potřeba provést update na lcd displeji
boolean vypisLinku = true; 

void setup() {
  
  pinMode(LED1, OUTPUT);  // pin pro LED1 nastaven jako výstup
  pinMode(LED2, OUTPUT);  // pin pro LED2 nastaven jako výstup
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  
  pinMode(buttonSelectUp, INPUT);  // pin pro tlačítko buttonSelect nastaveno jako vstup
  pinMode(buttonStart, INPUT);  // pin pro tlačítko buttonStart nastaveno jako vstup
  pinMode(buttonSelectDown, INPUT);  //pin pro tlačítko buttonSelectDown nastaveno jako vstup

  myservo.attach(9);  // pin pro servo

  lcd.begin();   // inicializace LCD
  lcd.backlight();   // zapnutí podsvícení
  Serial.begin(9600);   // konfigurace rychlosti seriového portu
  Serial.println("Seriovy port aktivni");  // První výpis na seriový port  
  
  lcd.setCursor( 2, 1);
  lcd.print("ready"); 
  delay(1500); 
  }  


void loop(){
  
 //-------------- debounce pro tlačítko Select Up ----------
  buttonStateUp = digitalRead(buttonSelectUp);  // přečtení stavu tlačítka    
  if (buttonStateUp != lastButtonStateUp) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime = millis();
  }                            
  if ((millis() - lastDebounceTime) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateUp != lastTrueButtonStateUp) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             
  
     if(buttonStateUp == true) { 
                               // přidáním podmínky - začátek počítání vždy např. od 10s
      if(mamBezet == false) {  // a taky přepnutí mode jen tehdy, když jsou mode ve Stop 
        if(mode < 6) {  // když je hodnota mode menší než 7
         mode++; // přičte k mode hodnotu 1
          vypisLCD = true;
          
        }          
       }   
     }
       lastTrueButtonStateUp = buttonStateUp;  // uložím si nový pravý ošetřený stav tlačítka           
    } 
  }     
  lastButtonStateUp = buttonStateUp; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
  //---------------konec ošetření tlačítka Select Up -----------

 //-------------- debounce pro tlačítko Select Down ----------
  buttonStateDown = digitalRead(buttonSelectDown);  // přečtení stavu tlačítka    
  if (buttonStateDown != lastButtonStateDown) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime3 = millis();
  }                            
  if ((millis() - lastDebounceTime3) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateDown != lastTrueButtonStateDown) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             
  
     if(buttonStateDown == true) { 
                               // přidáním podmínky docílím vždy celého odpočtu času 10s !
      if(mamBezet == false) {  // a taky přepnutí mode jen tehdy, když jsou mode ve Stop 
        if(mode > 0) {  // když je mode větší než 0
         mode--; // odečte od mode hodnotu 1          
         vypisLCD = true; 
          
         }             
       }  
     }
       lastTrueButtonStateDown = buttonStateDown;  // uložím si nový pravý ošetřený stav tlačítka           
    } 
  }     
  lastButtonStateDown = buttonStateDown; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
 //-------------- konec ořetření tlačítka Select Down ---------- 
  
  //-------------- debounce pro tlačítko START/STOP ----------  
    buttonStateStart = digitalRead(buttonStart);  // přečtení stavu tlačítka    
  if (buttonStateStart != lastButtonStart) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime2 = millis();
  }                            
  if ((millis() - lastDebounceTime2) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateStart != lastTrueButtonStart) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             

     if (buttonStateStart == true) {
         mamBezet = !mamBezet;          
         buttonTime = millis(); 
          vypisLCD = true;  // příkaz vypisuje funkci tlačítka, tedy start / stop
          
          Serial.println("stisk START/STOP");  // výpis na seriový monitor stisknutí tlačítka START/STOP                
      }
        // TADY CHYBÍ CO SE MÁ PROVÉST PŘI STISKU TLAČÍTKA START ... U MODE SE PŘIČÍTÁ MODE ...
        // ...U STARTU BY SE MĚLA PŘEKLÁPĚT PROMĚNNÁ mamBezet - hoď si tu nějaký výpis do seriové linky a uvidíš že to funguje
      }             
      lastTrueButtonStart = buttonStateStart;  // uložím si nový pravý ošetřený stav tlačítka        
    }  
   
  lastButtonStart = buttonStateStart; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
  //-------------- konec ořetření tlačítka Start/Stop ----------
   
                       
  if(mode == 0) {  // ******* LED1,LED2 vypnuto ******** 
     if(mamBezet == false){      
        led1svetlo = false;  // zhasni LED1              
        led2svetlo = false;  // zhasni LED2 
     }                        
   }
  
  if(mode == 1) {  // ******* LED1,LED2 zapnuto  ********    
       if(mamBezet == true){                                          
         led1svetlo = true;        
         led2svetlo = true;
       } else {       
          led1svetlo = false;         
          led2svetlo = false; 
         }
  }
                    
if(mode == 2) {  // ******* LED1,LED2 blikání rychlé  *******     
       if(mamBezet == true) {   // ZRUŠENÁ PODMÍNKA mamBezet    - zmena true za false
           
           casCekani = millis() - buttonTime; //musíš si definovat novou proměnnou - do ní bude uložen čas který už program načekal od stisku tlačítka start
             
           if(casCekani  > 10000){  // zjistím si jestli je čas něco provést, uběhlo už 10s od poslední akce?
          
             vypisLCD = true; // cekani uběhlo, potřebuji vypsat displej (akorát ho to bude vypisovat pokaždé, když to teď poběží kolem)
            
            // dá se to vyřešit tak, že si vytvořím další proměnnou blokujLCD ... a po prvním výpisu si ji nastavím na true - a vypis obalím do podmínky
            // if(blokujLCD == false) { vypisLCD = true; blokujLCD = true; } 
           
               aktualniMillis = millis();  // podívám se na hodinky - aktuální čas 
               if(aktualniMillis - predchoziMillis1 > 200) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 200ms od poslední akce?                  
                 if (led1svetlo) {                           
                   led1svetlo = false;  // zhasnu LED1
                   led2svetlo = false;  // zhasnu LED2                   
                  } else {                    
                    led1svetlo = true;  // rožnu LED1
                    led2svetlo = true;  // rožnu LED2                                
                   }                                   
                   predchoziMillis1 = aktualniMillis;   // v tento čas jsem provedl poslední akci  
               }                                                                         
              } else {                                    
                 led1svetlo = false;
                 led2svetlo = false;                           
                 blokujLCD = false;                                                    
                } 
        }       
  }

 
  if(mode == 3) {  // ******* LED1,LED2 blikání pomalé  *******  
     if(mamBezet == true){
        aktualniMillis = millis();  //podívám se na hodinky - aktuální čas  
       if(aktualniMillis - predchoziMillis2 > 500) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 500ms od poslední akce?  
         if (led2svetlo) {          
            led1svetlo = false;  // zhasnu LED1
            led2svetlo = false;  // zhasnu LED2
          } else {
            led1svetlo = true;  // rožnu LED1
            led2svetlo = true;  // rožnu LED2
             }
             predchoziMillis2 = aktualniMillis;   // v tento čas jsem provedl poslední akci 
        } 
      } else {
        led1svetlo = false;
        led2svetlo = false;   
      }        
     } 
                
     if(mode == 4) {  // ******* LED1,LED2 blikání střídavé  *******     
        if(mamBezet == true){ 
           aktualniMillis = millis();  //podívám se na hodinky - aktuální čas     
         if(aktualniMillis - predchoziMillis3 > 300) { // nejprve si zjistím jestli je čas něco provést, uběhlo už 300ms ?
           led1svetlo = !led1svetlo; // do proměnné led1svetlo zapíšu její negovanou hodnotu, tj. svítila-li LED1 tak zhasne, byla-li zhaslá rožne se
           led2svetlo = !led1svetlo; // do proměnné led2svetlo zapíšu negovanou hodnotu led1svetlo, tj. pokud LED1 svítí chci LED2 zhaslou a naopak
           predchoziMillis3 = aktualniMillis;   // v tento čas jsem provedl poslední akci 
          }   
         } else {              
           led1svetlo = false;
           led2svetlo = false;         
          }                       
     }

     if(mode == 5){  // ********** SERVO **********            
        if(mamBezet == true) {  // program spuštěn
              if(lastTrueButtonStateUp == true){  // stisknuto tlačítko selectUp
                      //pokud můžu a nebourám servem do krajní pozice, měním pozici serva
                   if(pos <= 175){
                     pos +=1;
                     myservo.write(pos);                                                          
                   }
              }
              if(lastTrueButtonStateDown == true){  // stisknuto tlačítko selectDown
                      //pokud můžu a nebourám servem do druhé krajní pozice, měním pozici serva druhým směrem 
                   if(pos >= 5){
                     pos -=1;
                     myservo.write(pos);                                                           
                   }
              }                     
              digitalWrite(LED4, pos < 175);  // LED4 svítí, když je servo v pozici Up - 175° stupňů
              digitalWrite(LED3, pos > 5);  // LED3 svítí, když je servo v pozici Down - 5° stupňů  
        }
      }                
             if(mamBezet == false){  // když je mode5 ve stavu Stop, tak ledky jsou zhasnuté            
               digitalWrite(LED4,false);
               digitalWrite(LED3,false);                     
     }

     if(mode == 6){  //******** v mode cyklus WHILE *********
        if(mamBezet == true) {  // program spuštěn                 
           while (lastTrueButtonStateUp == true && pos < 175) { // Zatím co je stisknuto tlačítko Up a zároveň pozice motoru je menší než 175            
              pos++; // zvyš pozici serva
              myservo.write(pos); // a následně zapiš na servo
           }  // konec while            
           while (lastTrueButtonStateDown == true && pos > 5) { // Zatím co je stisknuto tlačítko Down a zároveň pozice motoru je větší než 5
              pos--; // sniž pozici serva
              myservo.write(pos); // a následně zapiš na servo
           }  // konec while 
              digitalWrite(LED4, pos < 175);  // LED4 svítí, když je servo v pozici Up - 175° stupňů
              digitalWrite(LED3, pos > 5);  // LED3 svítí, když je servo v pozici Down - 5° stupňů                       
        }
     }

    digitalWrite(LED1,led1svetlo);  // aktualizace stavu LED1, zápis proměnné led1svetlo na výstupní pin 10
    digitalWrite(LED2,led2svetlo);  // aktualizace stavu LED2, zápis proměnné led2svetlo na výstupní pin 11 
    

    /*OBSLUHA 20x4 LCD DISPLAY*/
  if(vypisLCD){
    lcd.setCursor( 0, 1);  // tady se zadává pozice výpisu 3 znak, 2 řádek  
    lcd.print("  Mode ");
    lcd.print(mode);
    lcd.print("  -  ");       
    if(mamBezet){      
      lcd.print("START");
    } else {      
      lcd.print("STOP ");
     }
     
    if(mode == 1){
      lcd.setCursor( 2, 2);
      lcd.print("               ");  // vymazání výpisu ...koment mode       
    }      
 //***********************  MODE = 2 VYPISY *****************  
        
        if(mode == 2){ // Dle mode vyberu který                    
           if(mamBezet == true){  // bezi a bud ceka nebo neceka                                                   
                 if(casCekani < 10000){  // bezi a ceka ... vypisuji informaci o cekani ... napr zbyva 10000 - casCekani 
                    if(blokujLCD == false) {                   
                       lcd.setCursor( 2, 2);
                       lcd.print("cekam 10s");                                                                                          
                       vypisLCD = true;
                       blokujLCD = true;                                         
                    }
              }else{  // beží a nečeká ... vypisuje informaci ... ledky blikají  
                  lcd.setCursor( 2, 2);
                  lcd.print("ledky blikaji"); 
                                                   
              }                     
              }else{  // nebezí ... vypisuje informaci ... co se děje v mode                                 
                   lcd.setCursor( 2, 2);
                   lcd.print("s cekanim    ");
                                                                                                      
             }  
                         
        }     
             
//*****************************************************************************************
        
    if(mode == 3){
      lcd.setCursor( 2, 2);
      lcd.print("               ");  // vymazání výpisu ... může být koment pro mode       
    } 

    if(mode == 4){
      lcd.setCursor( 2, 2);
      lcd.print("               ");  // vymazání výpisu ... může být koment pro mode       
    } 
        
    if(mode == 5){                      
      lcd.setCursor( 2, 2);
      lcd.print("servo for  ");  // výpis, že mode obsluhuje servo v cyklu for
    } 
    
    if(mode == 6){                      
      lcd.setCursor( 2, 2);
      lcd.print("servo while");  // výpis, že mode obsluhuje servo v cyklu while
    } 

  vypisLCD = false;      
  }     
  /*KONEC OBSLUHY 20x4 LCD DISPLAY*/
 }  
 
v mode2 je podmínka změny u výpisu, tu jsem napsal špatně a ponahrátí vůbec nemají vliv, jako by tam nebyla. děkuju

Hanz
Příspěvky: 262
Registrován: 25 dub 2019, 23:52
Reputation: 0

Re: Mini CNC osa Z

Příspěvek od Hanz » 23 úno 2020, 18:38

dobrý den, myslím si , že jsem se konečně dopracoval výsledku :roll: Měl jsem to všechno před očima i ty nápovědy od kiRRow byly před očima , ale někdy je to opravdu, opravdu složité... .
Tady je kod, kde je mode2 "s cekanim", po stisknutí tlačítka start, probíhá odpočet od 10000ms do 0ms, a pak se vypíše "ledky blikaji" + led blikají .

Kód: Vybrat vše

#define buttonSelectUp 2   // číslo pinu tlačítka SELECT pro výběr MODE nahoru
#define buttonStart 3   // číslo pinu tlačítka START/STOP - červené
#define buttonSelectDown 4   // číslo pinu tlačítka pro výběr MODE dolů
#define LED1  10    // číslo pinu LED1 zelená
#define LED2  11    // číslo pinu LED2 červená
#define LED3  5
#define LED4  6

#include <Wire.h>   // knihovny pro LCD přes I2C
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);   // nastavení adresy I2C (0x27), počtu znaků, řádků LCD 20x4

#include <Servo.h>  // knihovna pro ovládání serva
Servo myservo;  // instance třídy servo viz. Objektově Orientované Programování
int pos = 0;  // proměnná úhlu natočení serva
int poc;  //  nastaveni pocitadla

boolean buttonStateUp = false;  // nejnovější hodnota načtená ze vstupního pinu 
boolean lastButtonStateUp = false;  // předchozí hodnota načtení ze vstupního pinu
boolean lastTrueButtonStateUp = false;  // předchozí hodnota ošetřeného tlačítka

boolean buttonStateStart = false;
boolean lastButtonStart = false;
boolean lastTrueButtonStart = false;

boolean buttonStateDown = false;  
boolean lastButtonStateDown = false;  
boolean lastTrueButtonStateDown = false;  

int mode = 0;
boolean mamBezet = false;


unsigned long lastDebounceTime = 0;  // čas posledního změny výstupního pinu
unsigned long lastDebounceTime2 = 0;
unsigned long lastDebounceTime3 = 0;
unsigned long debounceDelay = 50;  // čas debounce prodlevy 

unsigned long aktualniMillis;   //aktualní čas 
unsigned long predchoziMillis1;   // předchozí čas pro rychle blikání
unsigned long predchoziMillis2;   // předchozí čas pro pomalé blikání
unsigned long predchoziMillis3;   // předchozí čas pro střídavé blikání
unsigned long cas = 0;
unsigned long casCekani;  // proměnná - do ní bude uložen čas, který už program načekal od stisku tlačítka start
unsigned long blokujLCD;

long buttonTime;      //  čas začátku stisknutí tlačítka

boolean led1svetlo;   //  pomocná proměnná led1svetlo
boolean led2svetlo;   //  pomocná proměnná led2svetlo

boolean vypisLCD = true;  // proměnná kde si uchovávám jestli je potřeba provést update na lcd displeji
boolean vypisLinku = true; 

void setup() {
  
  pinMode(LED1, OUTPUT);  // pin pro LED1 nastaven jako výstup
  pinMode(LED2, OUTPUT);  // pin pro LED2 nastaven jako výstup
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  
  pinMode(buttonSelectUp, INPUT);  // pin pro tlačítko buttonSelect nastaveno jako vstup
  pinMode(buttonStart, INPUT);  // pin pro tlačítko buttonStart nastaveno jako vstup
  pinMode(buttonSelectDown, INPUT);  //pin pro tlačítko buttonSelectDown nastaveno jako vstup

  myservo.attach(9);  // pin pro servo

  lcd.begin();   // inicializace LCD
  lcd.backlight();   // zapnutí podsvícení
  Serial.begin(9600);   // konfigurace rychlosti seriového portu
  Serial.println("Seriovy port aktivni");  // První výpis na seriový port  
  
  lcd.setCursor( 2, 1);
  lcd.print("ready"); 
  delay(1500); 
  }  


void loop(){
  
 //-------------- debounce pro tlačítko Select Up ----------
  buttonStateUp = digitalRead(buttonSelectUp);  // přečtení stavu tlačítka    
  if (buttonStateUp != lastButtonStateUp) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime = millis();
  }                            
  if ((millis() - lastDebounceTime) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateUp != lastTrueButtonStateUp) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             
  
     if(buttonStateUp == true) { 
                               // přidáním podmínky - začátek počítání vždy např. od 10s
      if(mamBezet == false) {  // a taky přepnutí mode jen tehdy, když jsou mode ve Stop 
        if(mode < 6) {  // když je hodnota mode menší než 7
         mode++; // přičte k mode hodnotu 1
          vypisLCD = true;
          
        }          
       }   
     }
       lastTrueButtonStateUp = buttonStateUp;  // uložím si nový pravý ošetřený stav tlačítka           
    } 
  }     
  lastButtonStateUp = buttonStateUp; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
  //---------------konec ošetření tlačítka Select Up -----------

 //-------------- debounce pro tlačítko Select Down ----------
  buttonStateDown = digitalRead(buttonSelectDown);  // přečtení stavu tlačítka    
  if (buttonStateDown != lastButtonStateDown) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime3 = millis();
  }                            
  if ((millis() - lastDebounceTime3) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateDown != lastTrueButtonStateDown) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             
  
     if(buttonStateDown == true) { 
                               // přidáním podmínky docílím vždy celého odpočtu času 10s !
      if(mamBezet == false) {  // a taky přepnutí mode jen tehdy, když jsou mode ve Stop 
        if(mode > 0) {  // když je mode větší než 0
         mode--; // odečte od mode hodnotu 1          
         vypisLCD = true; 
          
         }             
       }  
     }
       lastTrueButtonStateDown = buttonStateDown;  // uložím si nový pravý ošetřený stav tlačítka           
    } 
  }     
  lastButtonStateDown = buttonStateDown; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
 //-------------- konec ořetření tlačítka Select Down ---------- 
  
  //-------------- debounce pro tlačítko START/STOP ----------  
    buttonStateStart = digitalRead(buttonStart);  // přečtení stavu tlačítka    
  if (buttonStateStart != lastButtonStart) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime2 = millis();
  }                            
  if ((millis() - lastDebounceTime2) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateStart != lastTrueButtonStart) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             

     if (buttonStateStart == true) {
         mamBezet = !mamBezet;          
         buttonTime = millis(); 
          vypisLCD = true;  // příkaz vypisuje funkci tlačítka, tedy start / stop
          
          Serial.println("stisk START/STOP");  // výpis na seriový monitor stisknutí tlačítka START/STOP                
      }
        // TADY CHYBÍ CO SE MÁ PROVÉST PŘI STISKU TLAČÍTKA START ... U MODE SE PŘIČÍTÁ MODE ...
        // ...U STARTU BY SE MĚLA PŘEKLÁPĚT PROMĚNNÁ mamBezet - hoď si tu nějaký výpis do seriové linky a uvidíš že to funguje
      }             
      lastTrueButtonStart = buttonStateStart;  // uložím si nový pravý ošetřený stav tlačítka        
    }  
   
  lastButtonStart = buttonStateStart; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
  //-------------- konec ořetření tlačítka Start/Stop ----------
   
                       
  if(mode == 0) {  // ******* LED1,LED2 vypnuto ******** 
     if(mamBezet == false){      
        led1svetlo = false;  // zhasni LED1              
        led2svetlo = false;  // zhasni LED2 
     }                        
   }
  
  if(mode == 1) {  // ******* LED1,LED2 zapnuto  ********    
       if(mamBezet == true){                                          
         led1svetlo = true;        
         led2svetlo = true;
       } else {       
          led1svetlo = false;         
          led2svetlo = false; 
         }
  }
                    
if(mode == 2) {  // ******* LED1,LED2 blikání rychlé  *******     
       if(mamBezet == true) {   // ZRUŠENÁ PODMÍNKA mamBezet    - zmena true za false
           
           casCekani = millis() - buttonTime; //musíš si definovat novou proměnnou - do ní bude uložen čas který už program načekal od stisku tlačítka start
             
           if(casCekani  > 10000){  // zjistím si jestli je čas něco provést, uběhlo už 10s od poslední akce?
          
             vypisLCD = true; // cekani uběhlo, potřebuji vypsat displej (akorát ho to bude vypisovat pokaždé, když to teď poběží kolem)
            
            // dá se to vyřešit tak, že si vytvořím další proměnnou blokujLCD ... a po prvním výpisu si ji nastavím na true - a vypis obalím do podmínky
             if(blokujLCD == false) { vypisLCD = true; blokujLCD = true; } 
           
               aktualniMillis = millis();  // podívám se na hodinky - aktuální čas 
               if(aktualniMillis - predchoziMillis1 > 200) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 200ms od poslední akce?                  
                 if (led1svetlo) {                           
                   led1svetlo = false;  // zhasnu LED1
                   led2svetlo = false;  // zhasnu LED2                   
                  } else {                    
                    led1svetlo = true;  // rožnu LED1
                    led2svetlo = true;  // rožnu LED2                                
                   }                                   
                   predchoziMillis1 = aktualniMillis;   // v tento čas jsem provedl poslední akci  
               }                                                                         
              } else {                                    
                 led1svetlo = false;
                 led2svetlo = false;                           
                 vypisLCD = true;
                 blokujLCD = true;  // program skoncil, takže si uvolním blokaci displeje blokujLCD = false                                                    
                } 
        }       
  }

 
  if(mode == 3) {  // ******* LED1,LED2 blikání pomalé  *******  
     if(mamBezet == true){
        aktualniMillis = millis();  //podívám se na hodinky - aktuální čas  
       if(aktualniMillis - predchoziMillis2 > 500) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 500ms od poslední akce?  
         if (led2svetlo) {          
            led1svetlo = false;  // zhasnu LED1
            led2svetlo = false;  // zhasnu LED2
          } else {
            led1svetlo = true;  // rožnu LED1
            led2svetlo = true;  // rožnu LED2
             }
             predchoziMillis2 = aktualniMillis;   // v tento čas jsem provedl poslední akci 
        } 
      } else {
        led1svetlo = false;
        led2svetlo = false;   
      }        
     } 
                
     if(mode == 4) {  // ******* LED1,LED2 blikání střídavé  *******     
        if(mamBezet == true){ 
           aktualniMillis = millis();  //podívám se na hodinky - aktuální čas     
         if(aktualniMillis - predchoziMillis3 > 300) { // nejprve si zjistím jestli je čas něco provést, uběhlo už 300ms ?
           led1svetlo = !led1svetlo; // do proměnné led1svetlo zapíšu její negovanou hodnotu, tj. svítila-li LED1 tak zhasne, byla-li zhaslá rožne se
           led2svetlo = !led1svetlo; // do proměnné led2svetlo zapíšu negovanou hodnotu led1svetlo, tj. pokud LED1 svítí chci LED2 zhaslou a naopak
           predchoziMillis3 = aktualniMillis;   // v tento čas jsem provedl poslední akci 
          }   
         } else {              
           led1svetlo = false;
           led2svetlo = false;         
          }                       
     }

     if(mode == 5){  // ********** SERVO **********            
        if(mamBezet == true) {  // program spuštěn
              if(lastTrueButtonStateUp == true){  // stisknuto tlačítko selectUp
                      //pokud můžu a nebourám servem do krajní pozice, měním pozici serva
                   if(pos <= 175){
                     pos +=1;
                     myservo.write(pos);                                                          
                   }
              }
              if(lastTrueButtonStateDown == true){  // stisknuto tlačítko selectDown
                      //pokud můžu a nebourám servem do druhé krajní pozice, měním pozici serva druhým směrem 
                   if(pos >= 5){
                     pos -=1;
                     myservo.write(pos);                                                           
                   }
              }                     
              digitalWrite(LED4, pos < 175);  // LED4 svítí, když je servo v pozici Up - 175° stupňů
              digitalWrite(LED3, pos > 5);  // LED3 svítí, když je servo v pozici Down - 5° stupňů  
        }
      }                
             if(mamBezet == false){  // když je mode5 ve stavu Stop, tak ledky jsou zhasnuté            
               digitalWrite(LED4,false);
               digitalWrite(LED3,false);                     
     }

     if(mode == 6){  //******** v mode cyklus WHILE *********
        if(mamBezet == true) {  // program spuštěn                 
           while (lastTrueButtonStateUp == true && pos < 175) { // Zatím co je stisknuto tlačítko Up a zároveň pozice motoru je menší než 175            
              pos++; // zvyš pozici serva
              myservo.write(pos); // a následně zapiš na servo
           }  // konec while            
           while (lastTrueButtonStateDown == true && pos > 5) { // Zatím co je stisknuto tlačítko Down a zároveň pozice motoru je větší než 5
              pos--; // sniž pozici serva
              myservo.write(pos); // a následně zapiš na servo
           }  // konec while 
              digitalWrite(LED4, pos < 175);  // LED4 svítí, když je servo v pozici Up - 175° stupňů
              digitalWrite(LED3, pos > 5);  // LED3 svítí, když je servo v pozici Down - 5° stupňů                       
        }
     }

    digitalWrite(LED1,led1svetlo);  // aktualizace stavu LED1, zápis proměnné led1svetlo na výstupní pin 10
    digitalWrite(LED2,led2svetlo);  // aktualizace stavu LED2, zápis proměnné led2svetlo na výstupní pin 11 
    

    /*OBSLUHA 20x4 LCD DISPLAY*/
  if(vypisLCD){
    lcd.setCursor( 0, 1);  // tady se zadává pozice výpisu 3 znak, 2 řádek  
    lcd.print("  Mode ");
    lcd.print(mode);
    lcd.print("  -  ");       
    if(mamBezet){      
      lcd.print("START");
    } else {      
      lcd.print("STOP ");
     }
     
    if(mode == 1){
      lcd.setCursor( 2, 2);
      lcd.print("               ");  // vymazání výpisu ...koment mode       
    }      
 //***********************  MODE = 2 VYPISY *****************  
        
        if(mode == 2){ // Dle mode vyberu který                    
           if(mamBezet == true){  // bezi a bud ceka nebo neceka                                                                     
              if(casCekani < 10000){  // bezi a ceka ... vypisuji informaci o cekani ... napr zbyva 10000 - casCekani                                       
                  lcd.setCursor( 2, 2);
                  lcd.print(10000 - casCekani);
                  lcd.setCursor( 6, 2);
                  lcd.print("       ");
              }else{  // beží a nečeká ... vypisuje informaci ... ledky blikají  
                  lcd.setCursor( 2, 2);
                  lcd.print("ledky blikaji"); 
                  vypisLCD = true;                                 
              }                     
              }else{  // nebezí ... vypisuje informaci ... co se děje v mode                                 
                   lcd.setCursor( 2, 2);
                   lcd.print("s cekanim    ");                                                                                                      
             }                           
        }     
             
//*****************************************************************************************
        
    if(mode == 3){
      lcd.setCursor( 2, 2);
      lcd.print("500 ms         ");  // vymazání výpisu ... může být koment pro mode       
    } 

    if(mode == 4){
      lcd.setCursor( 2, 2);
      lcd.print("300 ms         ");  // vymazání výpisu ... může být koment pro mode       
    } 
        
    if(mode == 5){                      
      lcd.setCursor( 2, 2);
      lcd.print("servo for  ");  // výpis, že mode obsluhuje servo v cyklu for
    } 
    
    if(mode == 6){                      
      lcd.setCursor( 2, 2);
      lcd.print("servo while");  // výpis, že mode obsluhuje servo v cyklu while
    } 

  vypisLCD = false;      
  }     
  /*KONEC OBSLUHY 20x4 LCD DISPLAY*/
 }  
 

přidal jsem pár výpisů, ale to jen pro přejítí k jiným myšlenkám, taky mode6 s while.
Zmátlo mě, že jsem pořád chtěl řešit výpisy u obsluhy LCD :oops:
Velmi, velmi děkuju

Hanz
Příspěvky: 262
Registrován: 25 dub 2019, 23:52
Reputation: 0

Re: Mini CNC osa Z

Příspěvek od Hanz » 03 bře 2020, 11:06

dobrý den, proběhlo pár úprav v kodu, něco jsem vynechal a zrušil, něco přidal. Hlavně v mode6 je největší úprava, kdy jsem nechal servo vrtět po stisknutí tlačítka start 15s. Všechno se dařilo , než jsem přidal výpis doby vrtění na lcd .
Nemůžu se hnout z místa a prosím o radu/ rady, jak upravit kod.

Kód: Vybrat vše

#define buttonSelectUp 2   // číslo pinu tlačítka SELECT pro výběr MODE nahoru
#define buttonStart 3   // číslo pinu tlačítka START/STOP - červené
#define buttonSelectDown 4   // číslo pinu tlačítka pro výběr MODE dolů
#define LED1  10    // číslo pinu LED1 zelená
#define LED2  11    // číslo pinu LED2 červená
#define LED3  5
#define LED4  6

#include <Wire.h>   // knihovny pro LCD přes I2C
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);   // nastavení adresy I2C (0x27), počtu znaků, řádků LCD 20x4

#include <Servo.h>  // knihovna pro ovládání serva
Servo myservo;  // instance třídy servo viz. Objektově Orientované Programování
int pos = 0;  // proměnná úhlu natočení serva
int step = 0;                // ukládá se do ní hodnotu jednoho kroku serva
int poc = 0;  

boolean buttonStateUp = false;  // nejnovější hodnota načtená ze vstupního pinu 
boolean lastButtonStateUp = false;  // předchozí hodnota načtení ze vstupního pinu
boolean lastTrueButtonStateUp = false;  // předchozí hodnota ošetřeného tlačítka

boolean buttonStateStart = false;
boolean lastButtonStart = false;
boolean lastTrueButtonStart = false;

boolean buttonStateDown = false;  
boolean lastButtonStateDown = false;  
boolean lastTrueButtonStateDown = false;  

int mode = 0;
boolean mamBezet = false;


unsigned long lastDebounceTime = 0;  // čas posledního změny výstupního pinu
unsigned long lastDebounceTime2 = 0;
unsigned long lastDebounceTime3 = 0;
unsigned long debounceDelay = 50;  // čas debounce prodlevy 

unsigned long aktualniMillis;   //aktualní čas 
unsigned long predchoziMillis1;   // předchozí čas pro rychle blikání
unsigned long predchoziMillis2;   // předchozí čas pro pomalé blikání
unsigned long predchoziMillis3;   // předchozí čas pro střídavé blikání

unsigned long casCekani;  // proměnná - do ní bude uložen čas, který už program načekal od stisku tlačítka start
unsigned long casVrteni;  // proměnná - do ní bude uložen čas, který program vrtěl servem od stisknutí tlačítka start
unsigned long blokujLCD;


long buttonTime;      //  čas začátku stisknutí tlačítka

boolean led1svetlo;   //  pomocná proměnná led1svetlo
boolean led2svetlo;   //  pomocná proměnná led2svetlo

boolean vypisLCD = true;  // proměnná kde si uchovávám jestli je potřeba provést update na lcd displeji
boolean vypisLinku = true; 

void setup() {
  
  pinMode(LED1, OUTPUT);  // pin pro LED1 nastaven jako výstup
  pinMode(LED2, OUTPUT);  // pin pro LED2 nastaven jako výstup
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  
  pinMode(buttonSelectUp, INPUT);  // pin pro tlačítko buttonSelect nastaveno jako vstup
  pinMode(buttonStart, INPUT);  // pin pro tlačítko buttonStart nastaveno jako vstup
  pinMode(buttonSelectDown, INPUT);  //pin pro tlačítko buttonSelectDown nastaveno jako vstup

  myservo.attach(9);  // pin pro servo

  lcd.begin();   // inicializace LCD
  lcd.backlight();   // zapnutí podsvícení
  Serial.begin(9600);   // konfigurace rychlosti seriového portu
  Serial.println("Seriovy port aktivni");  // První výpis na seriový port  
  
  lcd.setCursor( 2, 1);
  lcd.print("ready"); 
  delay(1500); 
  }  


void loop(){
  
 //-------------- debounce pro tlačítko Select Up ----------
  buttonStateUp = digitalRead(buttonSelectUp);  // přečtení stavu tlačítka    
  if (buttonStateUp != lastButtonStateUp) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime = millis();
  }                            
  if ((millis() - lastDebounceTime) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateUp != lastTrueButtonStateUp) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             
  
     if(buttonStateUp == true) { 
                               // přidáním podmínky - začátek počítání vždy např. od 10s
      if(mamBezet == false) {  // a taky přepnutí mode jen tehdy, když jsou mode ve Stop 
        if(mode < 6) {  // když je hodnota mode menší než 6
         mode++; // přičte k mode hodnotu 1
          vypisLCD = true;
          
        }          
       }   
     }
       lastTrueButtonStateUp = buttonStateUp;  // uložím si nový pravý ošetřený stav tlačítka           
    } 
  }     
  lastButtonStateUp = buttonStateUp; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
  //---------------konec ošetření tlačítka Select Up -----------

 //-------------- debounce pro tlačítko Select Down ----------
  buttonStateDown = digitalRead(buttonSelectDown);  // přečtení stavu tlačítka    
  if (buttonStateDown != lastButtonStateDown) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime3 = millis();
  }                            
  if ((millis() - lastDebounceTime3) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateDown != lastTrueButtonStateDown) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             
  
     if(buttonStateDown == true) { 
                               // přidáním podmínky docílím vždy celého odpočtu času 10s !
      if(mamBezet == false) {  // a taky přepnutí mode jen tehdy, když jsou mode ve Stop 
        if(mode > 0) {  // když je mode větší než 0
         mode--; // odečte od mode hodnotu 1          
         vypisLCD = true; 
          
         }             
       }  
     }
       lastTrueButtonStateDown = buttonStateDown;  // uložím si nový pravý ošetřený stav tlačítka           
    } 
  }     
  lastButtonStateDown = buttonStateDown; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
 //-------------- konec ořetření tlačítka Select Down ---------- 
  
  //-------------- debounce pro tlačítko START/STOP ----------  
    buttonStateStart = digitalRead(buttonStart);  // přečtení stavu tlačítka    
  if (buttonStateStart != lastButtonStart) { // kmita to, od minule se to zmenilo, zacnu debounce cas pocitat znovu (tedy od posledni zmeny, ktera je ted)
    lastDebounceTime2 = millis();
  }                            
  if ((millis() - lastDebounceTime2) > debounceDelay) { // jo, uz se to dlouho nezmenilo, tak je to stabilni a spravna hodnota
    if (buttonStateStart != lastTrueButtonStart) {  // Pokud se stav tlačítka změnil tj. porovná se buttonState (stav tlačítka) s předchozím stavem             

     if (buttonStateStart == true) {
         mamBezet = !mamBezet;          
         buttonTime = millis(); 
          vypisLCD = true;  // příkaz vypisuje funkci tlačítka, tedy start / stop
          
          Serial.println("stisk START/STOP");  // výpis na seriový monitor stisknutí tlačítka START/STOP                
      }
        // TADY CHYBÍ CO SE MÁ PROVÉST PŘI STISKU TLAČÍTKA START ... U MODE SE PŘIČÍTÁ MODE ...
        // ...U STARTU BY SE MĚLA PŘEKLÁPĚT PROMĚNNÁ mamBezet - hoď si tu nějaký výpis do seriové linky a uvidíš že to funguje
      }             
      lastTrueButtonStart = buttonStateStart;  // uložím si nový pravý ošetřený stav tlačítka        
    }  
   
  lastButtonStart = buttonStateStart; // tady si to ulozim, v dalsim pruchodu loop() to zase porovnam s novym stavem, zda se to mezi tim nezmenilo
  //-------------- konec ořetření tlačítka Start/Stop ----------
   
                       
  if(mode == 0) {  // ******* LED1,LED2 vypnuto ******** 
     if(mamBezet == false){      
        led1svetlo = false;  // zhasni LED1              
        led2svetlo = false;  // zhasni LED2 
     }                        
   }
  
  if(mode == 1) {  // ******* LED1,LED2 zapnuto  ********    
       if(mamBezet == true){
         led1svetlo = true;        
         led2svetlo = true;
       } else {       
          led1svetlo = false;         
          led2svetlo = false; 
         }
  }
                    
if(mode == 2) {  // ******* LED1,LED2 blikání rychlé  *******     
       if(mamBezet == true) {  // program spuštěn 
           
           casCekani = millis() - buttonTime; //musíš si definovat novou proměnnou - do ní bude uložen čas který už program načekal od stisku tlačítka start
             
           if(casCekani  > 10000){  // zjistím si jestli je čas něco provést, uběhlo už 10s od poslední akce?
          
             vypisLCD = true; // cekani uběhlo, potřebuji vypsat displej (akorát ho to bude vypisovat pokaždé, když to teď poběží kolem)
            
            // dá se to vyřešit tak, že si vytvořím další proměnnou blokujLCD ... a po prvním výpisu si ji nastavím na true - a vypis obalím do podmínky
             if(blokujLCD == false) { vypisLCD = true; blokujLCD = true; } 
           
               aktualniMillis = millis();  // podívám se na hodinky - aktuální čas 
               if(aktualniMillis - predchoziMillis1 > 200) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 200ms od poslední akce?                  
                 if (led1svetlo) {                           
                   led1svetlo = false;  // zhasnu LED1
                   led2svetlo = false;  // zhasnu LED2                   
                  } else {                    
                    led1svetlo = true;  // rožnu LED1
                    led2svetlo = true;  // rožnu LED2                                
                   }                                   
                   predchoziMillis1 = aktualniMillis;   // v tento čas jsem provedl poslední akci  
               }                                                                         
              } else {                                    
                 led1svetlo = false;
                 led2svetlo = false;                           
                 vypisLCD = true;
                 blokujLCD = true;  // program skoncil, takže si uvolním blokaci displeje blokujLCD = false                                                    
                } 
        }       
  }

 
  if(mode == 3) {  // ******* LED1,LED2 blikání pomalé  *******  
     if(mamBezet == true){
        aktualniMillis = millis();  //podívám se na hodinky - aktuální čas  
       if(aktualniMillis - predchoziMillis2 > 500) {  // nejprve si zjistím jestli je čas něco provést, uběhlo už 500ms od poslední akce?  
         if (led2svetlo) {          
            led1svetlo = false;  // zhasnu LED1
            led2svetlo = false;  // zhasnu LED2
          } else {
            led1svetlo = true;  // rožnu LED1
            led2svetlo = true;  // rožnu LED2
             }
             predchoziMillis2 = aktualniMillis;   // v tento čas jsem provedl poslední akci 
        } 
      } else {
        led1svetlo = false;
        led2svetlo = false;   
      }        
     } 
                
     if(mode == 4) {  // ******* LED1,LED2 blikání střídavé  *******     
        if(mamBezet == true){ 
           aktualniMillis = millis();  //podívám se na hodinky - aktuální čas     
         if(aktualniMillis - predchoziMillis3 > 300) { // nejprve si zjistím jestli je čas něco provést, uběhlo už 300ms ?
           led1svetlo = !led1svetlo; // do proměnné led1svetlo zapíšu její negovanou hodnotu, tj. svítila-li LED1 tak zhasne, byla-li zhaslá rožne se
           led2svetlo = !led1svetlo; // do proměnné led2svetlo zapíšu negovanou hodnotu led1svetlo, tj. pokud LED1 svítí chci LED2 zhaslou a naopak
           predchoziMillis3 = aktualniMillis;   // v tento čas jsem provedl poslední akci 
          }   
         } else {              
           led1svetlo = false;
           led2svetlo = false;         
          }                       
     }

     if(mode == 5){  // ********** SERVO I. **********            
        if(mamBezet == true) {  // program spuštěn
              if(lastTrueButtonStateUp == true){  // stisknuto tlačítko selectUp
                      //pokud můžu a nebourám servem do krajní pozice, měním pozici serva
                   if(pos <= 175){
                     pos +=1;
                     myservo.write(pos);                                                          
                   }
              }
              if(lastTrueButtonStateDown == true){  // stisknuto tlačítko selectDown
                      //pokud můžu a nebourám servem do druhé krajní pozice, měním pozici serva druhým směrem 
                   if(pos >= 5){
                     pos -=1;
                     myservo.write(pos);                                                           
                   }
              }                     
              digitalWrite(LED4, pos < 175);  // LED4 svítí, když je servo v pozici Up - 175° stupňů
              digitalWrite(LED3, pos > 5);  // LED3 svítí, když je servo v pozici Down - 5° stupňů  
        }
      }                
             if(mamBezet == false){  // když je mode5 ve stavu Stop, tak ledky jsou zhasnuté            
               digitalWrite(LED4,false);
               digitalWrite(LED3,false);                     
     }


     if(mode == 6) {  // ******* SERVO II. VRTÍ se 15s ********                                     
        if(mamBezet == true){  // program spuštěn
          casVrteni = millis() - buttonTime; 
                   
        vypisLCD = true;   // POKUD JE vypisLCD ODKOMENTOVANÝ vypisLCD VRTÍ SE SERVO VELMI POMALU - PROČ ???
                           
          if(casVrteni <= 15000)  {   // podmínka pro čas vrtění serva              
             if (pos <= 0) {     // zkontroluji si jestli je pozice 0 nebo méně
                 step = 1;        // nastavím step na 1 (TOHLE JE ZMĚNA SMĚRU
             }
             if (pos >= 180) {    // zkontroluji si jestli je pozice 180 nebo více
                 step = -1;        // nastavím step na -1 (TOHLE JE ZMĚNA SMĚRU)            
             }      
             pos += step;       // k pozici motoru přičtu step (TA JE BUĎ 1 A POS SE ZVYŠUJE, NEBO -1 A POS SE SNIŽUJE)
               digitalWrite(LED4,pos>=175);
               digitalWrite(LED3,pos<=5);
             myservo.write(pos);     // nastavení serva na pozici
             delay(7);     // nějaký ten delay, aby se to stihlo natočit      
          }              
        }
     }     
                        
    digitalWrite(LED1,led1svetlo);  // aktualizace stavu LED1, zápis proměnné led1svetlo na výstupní pin 10
    digitalWrite(LED2,led2svetlo);  // aktualizace stavu LED2, zápis proměnné led2svetlo na výstupní pin 11     

    /*OBSLUHA 20x4 LCD DISPLAY*/
    
  if(vypisLCD){
    lcd.setCursor( 0, 1);  // tady se zadává pozice výpisu 3 znak, 2 řádek  
    lcd.print("  Mode ");
    lcd.print(mode);
    lcd.print("  -  ");       
    if(mamBezet){      
      lcd.print("START");
    } else {      
      lcd.print("STOP ");
     }
     
    if(mode == 1){
      lcd.setCursor( 2, 2);
      lcd.print("               ");  // vymazání výpisu ...koment mode       
    }     
        
    if(mode == 2){ // Dle mode vyberu který                    
       if(mamBezet == true){  // bezi a bud ceka nebo neceka                                                                     
          if(casCekani < 10000){  // bezi a ceka ... vypisuji informaci o cekani ... napr zbyva 10000 - casCekani                                       
              lcd.setCursor( 2, 2);
              lcd.print(10000 - casCekani);
           //   lcd.setCursor( 6, 2);
              lcd.print(" ms       ");
          }else{  // beží a nečeká ... vypisuje informaci ... ledky blikají  
              lcd.setCursor( 2, 2);
              lcd.print("ledky blikaji"); 
              vypisLCD = true;                                 
          }                     
          }else{  // nebezí ... vypisuje informaci ... co se děje v mode                                 
               lcd.setCursor( 2, 2);
               lcd.print("s cekanim    ");                                                                                                      
         }                           
    }                  
        
    if(mode == 3){
      lcd.setCursor( 2, 2);
      lcd.print("500 ms    ");  //  výpis v mode blikání led 500 ms    
    } 

    if(mode == 4){
      lcd.setCursor( 2, 2);
      lcd.print("300 ms    ");  // výpis v mode blikání led 300 ms       
    } 
        
    if(mode == 5){                      
      lcd.setCursor( 2, 2);
      lcd.print("servo I.   ");  // výpis, že mode obsluhuje servo
    }     
    
//**************************** MODE 6 VÝPISY ***** UPRAVIT !!! *****************


    if(mode == 6){           
       if(mamBezet == true){  // program spuštěn                                              
          if(casVrteni < 15000){
              lcd.setCursor( 2, 2);   
              lcd.print(15000 - casVrteni); // odečet času vrtění serva
              lcd.print(" ms        ");                  
          }else{ 
                       
            lcd.setCursor( 2, 2);  // pozice kursoru
            lcd.print("servo pauza"); // výpis na lcd 
     
          }
          } else{
            lcd.setCursor( 2, 2);
            lcd.print("servo II.  ");                    
         
         } 
    }             
//****************************************************************************** 
                
    vypisLCD = false;      
  }     
  /*KONEC OBSLUHY 20x4 LCD DISPLAY*/
 }  
 
děkuju

Odpovědět

Kdo je online

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