Skocz do zawartości

Proste podświetlanie schodów na Arduino. Prośba o pomoc w stworzeniu programu


Pomocna odpowiedź

Dodaj do kodu jakieś logowanie w różnych miejscach programu żebyś wiedział gdzie się zatrzymuje.

Serial.println("1"); //itd...

 

Link to post
Share on other sites

@jas123 @jas123 

Kod narazie wygląda tak. Po naciśnięciu przycisku ma po kolei załączać diody. Potem jest regulowany potencjometrem czas w którym wszystkie diody świecą, a na koniec diody po kolei gasną.
Kod zapewne mógłby zostać jakoś skrócony, poprawiony itp. Mam nadzieję, że z czasem pewne rzeczy będę potrafił zrobić w jakiś prostszy, ładniejszy sposób.

Nie wiem jak go zmodyfikować, żeby w zależności od długości wciśnięcia przycisku uruchamiał funkcję ledsOn lub wlaczNaStale

 

#define led1 4
#define led2 5
#define led3 6
#define led4 7
#define led5 8
#define led6 9
#define led7 10
#define przycisk1 2
#define przycisk2 3

unsigned long oldTime= 0; //zmienna starego czasu między rozświetlaniem diod
unsigned long newTime = 0;

  
unsigned long oldTimePodtrzymania = 0; //zmienna starego czasu podtrzymania świecenia
unsigned long newTimePodtrzymania = 0;

byte zmiennaP1 = 0; //zmienna dla przycisku 1 - ilość case-ów 
byte zmiennaP2 = 0; //zmienna dla przycisku 2- ilość case-ów

byte stanPrzycisku1 = 0; //0-puszczony, 1-wciśnięty
byte stanPrzycisku2 = 0;

int odczytanaWartosc = 0;
byte zmienna2 = 0; //zmienna ilosci seknud które mineły w podtrzymaniu
int czasPodtrzymania = 1; // NIE zero żeby warunek w loop if(stanPrzycisku1==0 and zmienna2 >= czasPodtrzymania Nie był od razu spełniony na starcie
int dodatkowePodtrzymanie=0; //zmienna zwiększająca odczytaną wart. czasPodtrzymania. Jeśli jesteśmy w ledsOn i naciśnięto przycisk to przedłuża czas podtrzym.

volatile int ileRazy = 0; //ilość naciśnięć przycisku 

void wlaczNaStale();  //włączenie wszystkich diod na stałe
void wylaczStale();
boolean wszystkieWlaczone=false;   //zmienna informująca czy wszystkie diody są włączone- do f. wlaczNaStale
void czasCzekania();


void resetZmienna2(); //Ta deklaracja może być zbędna, może wystarczy ta z attachInterrupt

void setup()
{ 
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  pinMode(led5, OUTPUT);
  pinMode(led6, OUTPUT);
  pinMode(led7, OUTPUT);

  pinMode(przycisk1, INPUT_PULLUP); //przycisk 1
  pinMode(przycisk2, INPUT_PULLUP); // przycisk 2

attachInterrupt(digitalPinToInterrupt(przycisk1), resetZmienna2, FALLING); // Przerwanie reagujące na zbocze malejące
  
  
  Serial.begin(9600);
}

void loop()
{  
  
  
  if (digitalRead(przycisk1) == 0)
  {
    stanPrzycisku1 = 1;
  }
  if (digitalRead(przycisk2) == 0)
  {
    stanPrzycisku2 = 1;
  }


    if (stanPrzycisku1 == 1)
    {
      ledsOn();    
    }
  
    if (stanPrzycisku2 == 1)
    {
      ledsOn();
    }
  if(stanPrzycisku1==0 and zmienna2 >= czasPodtrzymania){  // wejście do f gaszenia
    ledsOff();
  }
  
   if((stanPrzycisku1==1)&& (zmiennaP1>8)){  // Jeśli kolejne naciśnięcie przycisku, a jesteśmy w gaszeniu to rozświetl od początku
    zmiennaP1=0;
    zmienna2=0;
     ledsOn();
  }
 
  }


void ledsOn(){
  ileRazy=0;
   if(zmiennaP1>3 && zmiennaP1<=7 && digitalRead(przycisk1)==LOW){ // Jeśli jesteśmy w rozświetlaniu i zapaliły się więcej niż 2 diody to kolejne naciśnięcie przycisku zwiększa podtrzymanie o 3jedn
    dodatkowePodtrzymanie=3;
  }
  
 newTime = millis();
  if (newTime - oldTime >= 800)
  {
    oldTime = newTime;
    zmiennaP1++;
    Serial.print("zmiennaP1 z ledsOn ");
    Serial.println(zmiennaP1);
  }
  switch (zmiennaP1) //dzięki temu że minęla 1sek możemy wybrać co się stanie
  { 
  case 1: //jeśli minęły 1sek włącz led1
    digitalWrite(led1, HIGH);
    break;
  case 2: //odliczasz kolejną 1sek i włącz led2
    digitalWrite(led2, HIGH);
    break;
  case 3:
    digitalWrite(led3, HIGH); //itd
    break;
  case 4:
    digitalWrite(led4, HIGH);
    break;
  case 5:
    digitalWrite(led5, HIGH);
    break;
  case 6:
    digitalWrite(led6, HIGH);
    break;
  case 7:
    digitalWrite(led7, HIGH);
    
    break;
  case 8:
    czasCzekania(); 
    stanPrzycisku1 = 0;
   
    break;
  }
}

void ledsOff(){
newTime = millis();
  Serial.print("newTime z ledsOff ");
    Serial.println(newTime);
  if (newTime - oldTime >= 800)
  {
    oldTime = newTime;
    zmiennaP1++;
    Serial.print("wart zmiennaP1 z ledsOff ");
    Serial.println(zmiennaP1);
  }
  
  switch (zmiennaP1) //kontynuacja switchów z wcześniejszej części
  {
  case 9:
    digitalWrite(led1, LOW); //wyłączasz led1
    break;
  case 10: //wyłączasz led2
    digitalWrite(led2, LOW);
    break;
  case 11: //wyłaczasz led3
    digitalWrite(led3, LOW);
    break;
  case 12:
    digitalWrite(led4, LOW);
    break;
  case 13:
    digitalWrite(led5, LOW);
    break;
  case 14:
    digitalWrite(led6, LOW);
    break;
  case 15:
    digitalWrite(led7, LOW);
    stanPrzycisku1 = 0;
    zmiennaP1 = 0;
    zmienna2=0;
    dodatkowePodtrzymanie=0;  //reset dodatkowego potrzymania 
    Serial.print("dodatkowe potrzym ");
    Serial.println(dodatkowePodtrzymanie);
    break;
  }
}

void czasCzekania()
{    //jako że program nie jest wymagający to tutaj również można użyć delay'a bo i tak program jest wstrzymany
  do //cała ta pętla wstrzyma Ci cały program póki nie zostanie spełniony warunek za wyrażeniem while
  {
         
    odczytanaWartosc = analogRead(A0);                        //odczytujesz wartość z portu A0
    czasPodtrzymania = map(odczytanaWartosc, 0, 1023, 0, 10); //zamienia zmienną z przedziału od 0 do 1023 na zmienną od 0 do 10 (sekund)
  Serial.print("t podtrzym z potenc. ");
  Serial.println(czasPodtrzymania); 
    czasPodtrzymania=czasPodtrzymania+dodatkowePodtrzymanie;
   
    
    Serial.print("t podtrzym+ dodatk ");
    Serial.println(czasPodtrzymania);     
    
    newTimePodtrzymania = millis();
    if (newTimePodtrzymania - oldTimePodtrzymania >= 800) // odliczaj po 1s
    {
      oldTimePodtrzymania = newTimePodtrzymania;
      zmienna2++; //co 1sek zwiększasz wartość zmiennej2
 
      if(ileRazy>=1){  //Jeśli naciśnięto  kolejny raz przycisk to reset podtrzymania i zmiennej1. Następnie przechodzi do ledsOff ze zmiennąP1=0
        // NIE = 9 więc tam przechodzi czas równy podświetlaniu potem przy zmiennejP1=9 zaczyna gasnąć. Trochę na odwrót, ale działa
    
      zmiennaP1=0;
      zmienna2=0;
      ileRazy=0;
     
    }
    
      
    Serial.print("ZMIENNA 2 akt. wart. ");
    Serial.println(zmienna2);
      
    }
  } while (zmienna2 <= czasPodtrzymania); //a pętla trwa póki zmienna2 nie osiągnie wartości zmapowanej zmiennej czasPodtrzymania
   
 
}

void resetZmienna2()
{
  ileRazy++;
  Serial.print("ile razy ");
  Serial.println(ileRazy);
}  
 

void wlaczNaStale()
{
  digitalWrite(led1,HIGH);
  digitalWrite(led2,HIGH);
  digitalWrite(led3,HIGH);
  digitalWrite(led4,HIGH);
  digitalWrite(led5,HIGH);
  digitalWrite(led6,HIGH);
  digitalWrite(led7,HIGH);
  
  ileRazy=0;
  wszystkieWlaczone=true;
}
           
void wylaczStale(){
  digitalWrite(led1,LOW);
  digitalWrite(led2,LOW);
  digitalWrite(led3,LOW);
  digitalWrite(led4,LOW);
  digitalWrite(led5,LOW);
  digitalWrite(led6,LOW);
  digitalWrite(led7,LOW);
  
  ileRazy=0;
  wszystkieWlaczone=false;
}

 

Link to post
Share on other sites

Dopisz kawałek kodu który niestety zatrzyma Ci cały program na kilka chwil. Niestety na obecną chwilę nic innego nie przychodzi mi do głowy.
Oczywiście kod jest przykładowy. Wszelkie konieczne zmienne i sposób odliczania czasu dopisz sobie sam.

 

if (digitalRead(przycisk) == 0)
{
  do
  {
    /* tu sobie wpisz obliczanie trzymania przycisku*/
  } while (digitalRead(przycisk) == 0);
}
if (czasTrzymania <= 2)
{//tu kod jak czas wynosi poniżej 2 czy innego czasu
}
if (czasTrzymania >= 4)
{//tu kod jak czas wynosi powyżej 4 czy innego czasu
}

 

Link to post
Share on other sites

W takim przypadku ja bym użył millis()

//////przed pętlą setup//////
unsigned long zapamietanyCzas = 0;
unsigned long roznicaCzasu = 0;

////////pętla loop///////////
if (digitalRead(przycisk) == 0){
  
unsigned long aktualnyCzas = millis();

if (digitalRead(przycisk) == 1) {
  
  roznicaCzasu = aktualnyCzas - zapamietanyCzas;
  
    if  (roznicaCzasu >= 5000 ){
      ledsOn();
    }else{
      wlaczNaStale();       
    }
   zapamietanyCzas = aktualnyCzas; 
}   
}

 

Link to post
Share on other sites
Zarejestruj się lub zaloguj, aby ukryć tę reklamę.
Zarejestruj się lub zaloguj, aby ukryć tę reklamę.

jlcpcb.jpg

jlcpcb.jpg

Produkcja i montaż PCB - wybierz sprawdzone PCBWay!
   • Darmowe płytki dla studentów i projektów non-profit
   • Tylko 5$ za 10 prototypów PCB w 24 godziny
   • Usługa projektowania PCB na zlecenie
   • Montaż PCB od 30$ + bezpłatna dostawa i szablony
   • Darmowe narzędzie do podglądu plików Gerber
Zobacz również » Film z fabryki PCBWay

Z pomocą z innego forum stworzyłem taki kod. Niestety nie wiem  jak wyłączyć diody gdy będą w funkcji wlaczNaStale (czyli uruchomić funkcję wylaczStale) tak, żeby nie uruchomić przy tym zwykłego podświetlania??

Myślałem, żeby zupełnie poniżej dać kolejny if taki:
if(digitalRead(przycisk1)==LOW and wszystkieWlaczone==true){
wylaczStale();
}
Żeby, gdy wszystkie ledy świecą i naciśniemy przycisk na dowolny czas, to uruchomi się funkcja wylaczStale, która zgasi wszystkie ledy. Niestety nie działa w ten sposób.

void loop()

{ 

  
  // Rozróżnianie czy przycisk wciśnięty na krótko czy na długo
  if (digitalRead(przycisk1) == LOW)
  {
    if (buttonActive == false)
    {
      buttonActive = true;
      tKrotkiegoNacisniecia = millis();
    }
    if ((millis() - tKrotkiegoNacisniecia > tDlugiegoNacisniecia) && (longPressActive == false))
    {
      longPressActive = true;
      // procedura dla długiego naciśnięcia

     wlaczNaStale();
     stanPrzycisku1=0;  // zerujemy stan przycisku, żeby prog nie wszedł do f. ledsOn (gdy stanPrzycisku1==1 to rusza ledsOn)

      }
    
  }
  else
  {
    if (buttonActive == true and wszystkieWlaczone==false)
    {
      if (longPressActive == true)
      {
        longPressActive = false;
      }
      else
      {

        // procedura dla krotkiego stanu przycisku
       stanPrzycisku1=1;
        
      }
      buttonActive = false;
    }
  }

if(stanPrzycisku1==1){
  ledsOn(); // Bez przypisania po naciśnięciu stanu przycisku na 1, jeśli byłoby tylko wywołanie ledsOn, 
  //to po wejściu do ledsOn zapali się tylko 1 dioda bo warunek że przycisk jest wciśnięty, już NIE będzie prawdziwy.

if(digitalRead(przycisk1)==LOW and wszystkieWlaczone==true){
  wylaczStale();
}  

  
}
  
  if(stanPrzycisku1==0 and zmienna2 >= czasPodtrzymania){  // wejście do f gaszenia
    ledsOff();
  }
  
   if((stanPrzycisku1==1)&& (zmiennaP1>8)){  // Jeśli kolejne naciśnięcie przycisku, a jesteśmy w gaszeniu to rozświetl od początku
    zmiennaP1=0;
    zmienna2=0;
     ledsOn();
  }
 
  }

Jutro będę próbował zrobić z millis wg pomysłu @jas123  

Link to post
Share on other sites

Projekt podświetlenie schodów jest świetną okazją do zapoznania się z możliwościami różnych  programów służących do pisania programów.Moje pierwsze rozwiązanie zostało napisane a raczej narysowane w  programie Realizer firmy   Actum Solutios i trwało jakieś trzy godziny.Powodem tak krótkiego czasu jest bogactwo bibliotek.Zachęcam do ściągnięcia programu Realizer Bronze.W załączniku jest odpowiedni plik z rozszerzeniem .sch. Realizer Bronze pozwoli otworzyć ten plik ale nie pozwoli na nic więcej.Pisanie programu w Arduino jest  zupełnie inne i nie ma wprost, dla wielu elementów ,równoważnych  procedur w związku z tym należy je wypracować.To świetne ćwiczenie umiejętności i nabieranie doświadczenia. Następna wersja programu będzie pisana w STM32CubeIDE.

//SCHODY
//Poniżej napisany program został skompilowany dla kontrolera STM32F103.
//W celu przystosowania do Arduino wykorzystującego procesor ATmega 328 lub inny należy odpowiednio przypisać porty
//Ten program został wstępnie przetestowany i na moim STM3232F103 działa poprawnie.
//Jeśli będziesz chciał zastosować ten program usuń wszystkie linie dotyczące transmisji szeregowej bo są zbędne.
//Te linie służą do testowania programu.
//Ten program potrzebuje zainstalowania biblioteki Timers w wersji,którą dołączyłem do wcześniejszego postu.

#include <Timers.h>
Timers <4> schody;
bool u1=0,u2=0,u3=0,u4=0,u5=1;
bool z1=0,z2=0,z3=0,z4=0 ;
bool Q1=0,Q2=0,Q3=0,Q4=0 ;
bool k1=0, k2=0,k3=0,k4=0;
# define C1   PB12 //Czujnik nr1 TSOP.Stan'1' jest wtedy gdy do czujnika
// nie dociera sygnsł z nadajnika.Stan '0' jest wtedy gdy sygnał z nadajnika dociera.
# define C2   PB13 //Czujnik nr2 TSOP
# define C3   PB14 //Czujnik nr3 TSOP
# define C4   PB15 //Czujnik nr4 TSOP
#define led1  PB3
#define led2  PB4
#define led3  PB5
#define led4  PB6
#define led5  PB7
#define led6  PB8
#define led7  PC13
#define p1    PB9//przycisk włączenia oświetlenia na stałe.
#define wdn  PB1//wyłączenie diod nadawczych(wdn) w dzień
//Pierwsze naciśnięcie przycisku włącza oświetlenie a drugie naciśnięcie przycisku wyłącza. 
int analog0 = PA0;
int noc=0; 
int d=0 ,f=0,h1=0,h2=0,b=0 ;
//===================================================
void dogory()
{
  h1=1;
 d=d+1;
 if(d>12){
  d=0;
 }
 switch (d)
 {
  case 1:
  digitalWrite(led1,LOW);
  break;
  case 2:
  digitalWrite(led2,LOW);
  break;
  case 3:
  digitalWrite(led3,LOW);
  break;
  case 4:
  digitalWrite(led4,LOW);
  break;
  case 5:
  digitalWrite(led5,LOW);
  break;
  case 6:
  digitalWrite(led6,LOW);
  break;
  case 7:
  digitalWrite(led7,LOW);
  break;
  case 12:
  h1=0;
  if ((h1==0) && (h2==0))
  {
  digitalWrite(led1,HIGH);
  digitalWrite(led2,HIGH);
  digitalWrite(led3,HIGH);
  digitalWrite(led4,HIGH);
  digitalWrite(led5,HIGH);
  digitalWrite(led6,HIGH);
  digitalWrite(led7,HIGH);
  }
  Q2=0;
  k2=0;
  break;
 }
}
//===========================================
void dodolu()
{
  h2=1;
f=f+1;
 if(f>12)
 {
  f=0;
 }
 switch (f)
 {
  case 1:
  digitalWrite(led7,LOW);
  break;
  case 2:
  digitalWrite(led6,LOW);
  break;
  case 3:
  digitalWrite(led5,LOW);
  break;
  case 4:
  digitalWrite(led4,LOW);
  break;
  case 5:
  digitalWrite(led3,LOW);
  break;
  case 6:
  digitalWrite(led2,LOW);
  break;
  case 7:
  digitalWrite(led1,LOW);
  break;
  case 12:
  h2=0;
  if ((h1==0) && (h2==0))
  {
  digitalWrite(led1,HIGH);
  digitalWrite(led2,HIGH);
  digitalWrite(led3,HIGH);
  digitalWrite(led4,HIGH);
  digitalWrite(led5,HIGH);
  digitalWrite(led6,HIGH);
  digitalWrite(led7,HIGH);
  }
  Q4=0;
  k4=0;
  break;
   }
 }
//============================================
 void czas1()
 {
  Q1=0;
  k1=0;
   }
//=============================================   
 void czas2() 
  {
  Q3=0;
  k3=0;
   }
//=============================================
void setup() {
 Serial.print(9600);
 pinMode(C1,INPUT_PULLUP);
 pinMode(C2,INPUT_PULLUP);
 pinMode(C3,INPUT_PULLUP);
 pinMode(C4,INPUT_PULLUP);
 pinMode(p1,INPUT_PULLUP);
 pinMode(led1,OUTPUT);digitalWrite(led1,HIGH);
 pinMode(led2,OUTPUT);digitalWrite(led2,HIGH);
 pinMode(led3,OUTPUT);digitalWrite(led3,HIGH);
 pinMode(led4,OUTPUT);digitalWrite(led4,HIGH);
 pinMode(led5,OUTPUT);digitalWrite(led5,HIGH);
 pinMode(led6,OUTPUT);digitalWrite(led6,HIGH);
 pinMode(led7,OUTPUT);digitalWrite(led7,HIGH);
 pinMode(wdn,OUTPUT);digitalWrite(wdn,HIGH);
schody.attach (0, 1000, dogory);
schody.attach (1, 1000, dodolu);
schody.attach (2, 2000, czas1);
schody.attach (3, 2000, czas2);
}
//================================================
void loop()
{
u1= digitalRead(C1);
u2= digitalRead(C2);
u3= digitalRead(C3);
u4= digitalRead(C4);
u5= digitalRead(p1);
noc=analogRead(analog0);
 Serial.print("noc=");
 Serial.println(noc);
if (noc<800)
{
 digitalWrite(wdn,HIGH);//wyjście podłączone do wejścia bramki 'and'.
 //Drugie wejście bramki 'and' ma być podłączone do wyjścia generatora np.33khz.
 }
else 
{
  digitalWrite(wdn,LOW);
}
if (u5==0)
 {
  b=b+1;
  switch(b)
  {
    case 1 :
  digitalWrite(led1,LOW);
  digitalWrite(led2,LOW);
  digitalWrite(led3,LOW);
  digitalWrite(led4,LOW);
  digitalWrite(led5,LOW);
  digitalWrite(led6,LOW);
  digitalWrite(led7,LOW);
  break;
  case 2:
  digitalWrite(led1,HIGH);
  digitalWrite(led2,HIGH);
  digitalWrite(led3,HIGH);
  digitalWrite(led4,HIGH);
  digitalWrite(led5,HIGH);
  digitalWrite(led6,HIGH);
  digitalWrite(led7,HIGH);
  b=0;
  break;
      }
    }
z2=Q1 && u2 ;
z4=Q3 && u4 ;
z1=(u1==1) && (u2==0) && (noc<800) && (b==0);
z3=(u3==1) && (u4==0) && (noc<800) && (b==0);
Q1= z1|| k1 ;//k1 jest stanem Q1 (n-1)
Q3= z3|| k3 ;//k3 jest stanem Q3 (n-1)

Q2= z2 || k2;
Q4= z4 || k4;
k2=Q2;
k1=Q1;
Serial.print("k1=");
 Serial.println(k1);
k4=Q4;
k3=Q3;
schody.process();
if (k2==0)
 {
  schody.updateInterval(0,0);
}
else
{
  schody.updateInterval(0,1000);
  }
   if (k4==0)
 {
  schody.updateInterval(1,0);
}
else
{
  schody.updateInterval(1,1000);
   }
    if (k1==1)
 {
  schody.updateInterval(2,2000);
}
else
{
  schody.updateInterval(2,0);
}
if (k3==1)
 {
  schody.updateInterval(3,2000);
}
else
{
  schody.updateInterval(3,0);
}
  }

 

potrzeb pliki.rar

Edytowano przez szymonw
Link to post
Share on other sites

Udało mi się z rozróżnianiem czasu naciśnięcia dla obu przycisków. Program ma już większość z założonych przeze mnie funkcji (chociaż do miana napisanego w optymalny sposób, mu daleko, ale na tym etapie cieszę się że w ogóle coś działa).
 

 

Jest jeszcze taki problem- gdy nacisnę jeden przycisk a tuż po nim drugi (dwie osoby idą z przeciwnych kierunków, prawie w tym samym czasie) to dwa poniższe warunki sprawiają, że uruchamia się gaszenie dla każdej ze stron i w efekcie diody gasną od dołu i od góry jednocześnie, po kolei. Ostatnia gaśnie środkowa. A powinno być tak, że diody gasną w sposób wyznaczony przez przycisk naciśnięty później.

Czyli jeśli ktoś idzie z dołu, zapaliły się już np. 3 stopnie i w tym momencie wchodzi ktoś z góry czyli zapala dopiero 1 stopień od góry, to gaszenie powinno się odbyć od góry (ledsOffZgory), bo ta osoba później zejdzie ze schodów.

Próbowałem, tak jak poniżej, ale niestety nie działa. Może źle zapisałem kod warunku który opisałem w komentarzu ??

if((stanPrzycisku1==2 && zmienna2 >= czasPodtrzymania)&& (zmiennaP1<zmiennaP2 || zmiennaP2==0)){  // wejście do f gaszenia dla przycisku 1 Jeśli minie czas podtrzym i  przycisk P1 został naciśnięty póżniej niż P2 (czyli zmiennaP1<zmiennaP2) Lub przycisk P2 wogóle nie naciśnięty (zmiennaP2==0), to wygaszaj z dołu
    ledsOffZdolu();
  }
if((stanPrzycisku2==2 && zmienna2 >= czasPodtrzymania) && (zmiennaP2<zmiennaP1 || zmiennaP1==0)){  // wejście do f gaszenia dla przycisku 2 Analogicznie
    ledsOffZgory();
  }

 

Link to post
Share on other sites

Nie wiem czy przeanalizowałeś mój program ale jest w nim rozwiązanie do którego dążysz.Są tam dwie zmienne h1 i h2,które służą do tego celu.Zmienne są umieszczone w void dogory i void dodolu. .Spójrz  na case 12 : gdzie jest warunek jeśli h1=0 i h2=0 to wyłącz.

Link to post
Share on other sites
42 minuty temu, szymonw napisał:

Nie wiem czy przeanalizowałeś mój program ale jest w nim rozwiązanie do którego dążysz.Są tam dwie zmienne h1 i h2,które służą do tego celu.Zmienne są umieszczone w void dogory i void dodolu. .Spójrz  na case 12 : gdzie jest warunek jeśli h1=0 i h2=0 to wyłącz.

A czy Kolega mógłby podpowiedzieć jak taki warunek mógłby wyglądać w moim przypadku?

 

Link to post
Share on other sites

Warunek będzie wyglądał najprawdopodobniej identycznie. Opublikuj ten swój kod to się nim zajmę po powrocie za kilka godzin..Mój kod bazuje na genialnej bibliotece Timers  i jak widzisz bardzo się wszystko upraszcza.Cały program bazuje na trochę zmodyfikowanej wersji przerzutnika SR(set reset) . Reszta to zależności czasowe.Warto poczytać o tej bibliotece -jest gdzieś na forum.

Link to post
Share on other sites

Nie wrzucam całego kodu, bo niestety jest bardzo długi (jest jeszcze jedna funkcja dla trzeciego przycisku, włączająca inną kombinację podświetlania, ale w powyżej opisanym problemie nie ma żadnego udziału). Pewnie dałoby się zrobić to krócej ale narazie dobrze że działa.

Problem jest myślę w dwóch warunkach zapisanych w liniach od 202.  W komentarzu przy kodzie opisałem jak wg mnie powinien wyglądać warunek, aby wygaszanie następowało od odpowiedniej strony. Może błędnie zapisałem te warunki ?

#define led1 4
#define led2 5
#define led3 6
#define led4 7
#define led5 8
#define led6 9
#define led7 10
#define przycisk1 2
#define przycisk2 3

#define przycisk3 11 //przycisk do efektu Pas startowy

unsigned long tKrotkiegoNacisniecia1 = 20;        // czas krotkiego wcisniecia przycisku
unsigned long tDlugiegoNacisniecia1  = 1000;       // czas dlugiego wcisniecia przycisku
boolean buttonActive1 = false;                  
boolean longPressActive1 = false;     

unsigned long tKrotkiegoNacisniecia2 = 20;        // czas krotkiego wcisniecia przycisku
unsigned long tDlugiegoNacisniecia2  = 1000;       // czas dlugiego wcisniecia przycisku
boolean buttonActive2 = false;                  
boolean longPressActive2 = false;   


unsigned long oldTime= 0; //zmienna starego czasu między rozświetlaniem diod
unsigned long newTime = 0;

unsigned long oldTimePodtrzymania = 0; //zmienna starego czasu podtrzymania świecenia
unsigned long newTimePodtrzymania = 0;

byte zmiennaP1 = 0; //zmienna dla przycisku 1 - ilość case-ów 
byte zmiennaP2 = 0; //zmienna dla przycisku 2- ilość case-ów

byte stanPrzycisku1 = 0; //0-puszczony, 1-wciśnięty 2-do wejścia do f gaszenia (po skończeniu rozświetlania)
byte stanPrzycisku2 = 0;
byte stanPrzycisku3 = 0;

int odczytanaWartosc = 0;
byte zmienna2 = 0; //zmienna ilosci seknud które mineły w podtrzymaniu
int czasPodtrzymania = 1; // NIE zero żeby warunek w loop if(stanPrzycisku1==0 and zmienna2 >= czasPodtrzymania Nie był od razu spełniony na starcie
int dodatkowePodtrzymanie=0; //zmienna zwiększająca odczytaną wart. czasPodtrzymania. Jeśli jesteśmy w ledsOn i naciśnięto przycisk to przedłuża czas podtrzym.

volatile int ileRazyP1 = 0; //ilość naciśnięć przycisku 1
volatile int ileRazyP2 = 0; //ilość naciśnięć przycisku 2

void wlaczNaStale();  //włączenie wszystkich diod na stałe
void wylaczStale();
boolean wszystkieWlaczone=false;   //zmienna informująca czy wszystkie diody są włączone- do f. wlaczNaStale
void czasCzekania();
void ledsOnZdolu(); //rozświetlanie i gaszenie z dołu do góry
void ledsOffZdolu();
void ledsOnZgory();//rozświetlanie i gaszenie z góry w dół
void ledsOffZgory();

void resetZmienna2P1(); //Ta deklaracja może być zbędna, może wystarczy ta z attachInterrupt
void resetZmienna2P2(); //Ta deklaracja może być zbędna, może wystarczy ta z attachInterrupt

void pasStartowy(); //efekt pasa startowego

void setup()
{ 
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  pinMode(led5, OUTPUT);
  pinMode(led6, OUTPUT);
  pinMode(led7, OUTPUT);

  pinMode(przycisk1, INPUT_PULLUP); //przycisk 1
  pinMode(przycisk2, INPUT_PULLUP); // przycisk 2
  pinMode(przycisk3,INPUT_PULLUP);  //przycisk 3 do efektu pas startowy

attachInterrupt(digitalPinToInterrupt(przycisk1), resetZmienna2P1, FALLING); // Przerwanie reagujące na zbocze malejące Przycisk 1
attachInterrupt(digitalPinToInterrupt(przycisk2), resetZmienna2P2, FALLING); // Przerwanie reagujące na zbocze malejące Przycisk 2
  Serial.begin(9600);
}

void loop()

{     
  // Rozróżnianie czy przycisk wciśnięty na krótko czy na długo Dla przycisku 1
  if (digitalRead(przycisk1) == LOW)
  {
    if (buttonActive1 == false)
    {
      buttonActive1 = true;
      tKrotkiegoNacisniecia1 = millis();
    }
    if ((millis() - tKrotkiegoNacisniecia1 > tDlugiegoNacisniecia1) && (longPressActive1 == false))
    {
      longPressActive1 = true;
      // procedura dla długiego naciśnięcia

     Serial.println("dlugie nacisniecie P1 ");
     wlaczNaStale();
     wszystkieWlaczone=true; //zmieniamy stan zmiennej, żeby można było wszystkie wyłączyć (jest to też w f. wlaczNaStale)
     
     stanPrzycisku1=0;  // zerujemy stan przycisku, żeby prog nie wszedł do f. ledsOn (gdy stanPrzycisku1==1 to rusza ledsOn)

      }
    
  }
  else
  {
    if (buttonActive1 == true)
    {
      if (longPressActive1 == true)
      {
        longPressActive1 = false;
      }
      else
      {   // procedura dla krotkiego stanu przycisku
     
      
      if(wszystkieWlaczone==true){  //jeśli wszystkie włączone na stałe to wyłącz 
        Serial.println("krotkie nac. Wylacz stale z P1");
        wylaczStale();    
        wszystkieWlaczone=false;  //po wyłączeniu zmieniamy stan zmiennej (jest to też w f. wylaczStale)       
        zmiennaP1=0;
      
      }
      else{
        stanPrzycisku1=1;
        
        Serial.println("krotkie nac. do f ledsOn Z D");
         
      }
        
      }
      buttonActive1 = false;
    }
  }


 // Rozróżnianie czasu wciśnięcia dla przycisku 2  
  if (digitalRead(przycisk2) == LOW)
  {
    if (buttonActive2 == false)
    {
      buttonActive2 = true;
      tKrotkiegoNacisniecia2 = millis();
    }
    if ((millis() - tKrotkiegoNacisniecia2 > tDlugiegoNacisniecia2) && (longPressActive2 == false))
    {
      longPressActive2 = true;
      // procedura dla długiego naciśnięcia

     Serial.println("dlugie nacisniecie P2");
     wlaczNaStale();
     wszystkieWlaczone=true; //zmieniamy stan zmiennej, żeby można było wszystkie wyłączyć (jest to też w f. wlaczNaStale)
     
     stanPrzycisku2=0;  // zerujemy stan przycisku, żeby prog nie wszedł do f. ledsOn (gdy stanPrzycisku1==1 to rusza ledsOn)

      }
    
  }
  else
  {
    if (buttonActive2 == true)
    {
      if (longPressActive2 == true)
      {
        longPressActive2 = false;
      }
      else
      {   // procedura dla krotkiego stanu przycisku
     
      
      if(wszystkieWlaczone==true){  //jeśli wszystkie włączone na stałe to wyłącz 
        Serial.println("krotkie nac. Wylacz stale z P2");
        wylaczStale();    
        wszystkieWlaczone=false;  //po wyłączeniu zmieniamy stan zmiennej (jest to też w f. wylaczStale)       
        zmiennaP2=0;
      
      }
      else{
        stanPrzycisku2=1;
        
        Serial.println("krotkie nac. do f ledsOn Z G ");
         
      }
        
      }
      buttonActive2 = false;
    }
  }


    
if(stanPrzycisku1==1){   // Bez przypisania po naciśnięciu stanu przycisku na 1, jeśli byłoby tylko wywołanie ledsOn, to po wejściu do ledsOn zapali się tylko 1 dioda bo warunek że przycisk jest wciśnięty, już NIE będzie prawdziwy.
 ledsOnZdolu();   
} 
 
// Procedury dla przycisku 2
if(stanPrzycisku2==1){ // Bez przypisania po naciśnięciu stanu przycisku na 1, jeśli byłoby tylko wywołanie ledsOn,
                      //to po wejściu do ledsOn zapali się tylko 1 dioda bo warunek że przycisk jest wciśnięty, już NIE będzie prawdziwy. 
  ledsOnZgory(); 
}  
  
if((stanPrzycisku1==2 && zmienna2 >= czasPodtrzymania)&& (zmiennaP1<zmiennaP2 || zmiennaP2==0)){  // wejście do f gaszenia dla przycisku 1 Jeśli minie czas podtrzymania i  przycisk P1 został naciśnięty póżniej niż P2 (czyli zmiennaP1<zmiennaP2) Lub przycisk P2 wogóle nie naciśnięty (zmiennaP2==0), to wygaszaj z dołu
    ledsOffZdolu();
  }

if((stanPrzycisku2==2 && zmienna2 >= czasPodtrzymania) && (zmiennaP2<zmiennaP1 || zmiennaP1==0)){  // wejście do f gaszenia dla przycisku 2 analogicznie
    ledsOffZgory();
  }
}

void ledsOnZdolu(){
  ileRazyP1=0;
   if(zmiennaP1>3 && zmiennaP1<=7 && digitalRead(przycisk1)==LOW){ // Jeśli jesteśmy w rozświetlaniu i zapaliły się więcej niż 3 diody to kolejne naciśnięcie przycisku zwiększa podtrzymanie o 3 jedn
    dodatkowePodtrzymanie=3;
  }
  
 newTime = millis();
  if (newTime - oldTime >= 600)
  {
    oldTime = newTime;
    zmiennaP1++;
    Serial.print("zmiennaP1 z ledsOnZdolu ");
    Serial.println(zmiennaP1);
  }
  switch (zmiennaP1) //dzięki temu że minęla 1sek możemy wybrać co się stanie
  { 
  case 1: //jeśli minęły 1sek włącz led1
    digitalWrite(led1, HIGH);
    break;
  case 2: //odliczasz kolejną 1sek i włącz led2
    digitalWrite(led2, HIGH);
    break;
  case 3:
    digitalWrite(led3, HIGH); //itd
    break;
  case 4:
    digitalWrite(led4, HIGH);
    break;
  case 5:
    digitalWrite(led5, HIGH);
    break;
  case 6:
    digitalWrite(led6, HIGH);
    break;
  case 7:
    digitalWrite(led7, HIGH);
    
    break;
  case 8:
    ileRazyP1=0;  // zerujemy dla f czas czekania
    stanPrzycisku1 = 2; //Zmieniamy stan przycisku na 2 bo gdyby był na 0 to po dojściu zmiennej2 powyżej czasPodtrzymania,
              //zaczęło by się ledsOff również dla drugiego przycisku-drugiej strony, mimo ze tam nie był pzycisk wciśnięty
    czasCzekania(); 
    break;
  }
}

void ledsOnZgory(){
  
  ileRazyP2=0;
   if(zmiennaP2>3 && zmiennaP2<=7 && digitalRead(przycisk2)==LOW){ // Jeśli jesteśmy w rozświetlaniu i zapaliły się więcej niż 3 diody to kolejne naciśnięcie przycisku zwiększa podtrzymanie o 3 jedn
    dodatkowePodtrzymanie=3;
  }
  
 newTime = millis();
  if (newTime - oldTime >= 600)
  {
    oldTime = newTime;
    zmiennaP2++;
    Serial.print("zmiennaP2 z ledsOnZgory ");
    Serial.println(zmiennaP2);
  }
  switch (zmiennaP2) //dzięki temu że minęla 1sek możemy wybrać co się stanie
  { 
  case 1: //jeśli minęły 1sek włącz led1
    digitalWrite(led7, HIGH);
    break;
  case 2: //odliczasz kolejną 1sek i włącz led2
    digitalWrite(led6, HIGH);
    break;
  case 3:
    digitalWrite(led5, HIGH); //itd
    break;
  case 4:
    digitalWrite(led4, HIGH);
    break;
  case 5:
    digitalWrite(led3, HIGH);
    break;
  case 6:
    digitalWrite(led2, HIGH);
    break;
  case 7:
    digitalWrite(led1, HIGH);
    
    break;
  case 8:    
    ileRazyP2=0;  //zerujemy dla f. czas czekania
    stanPrzycisku2 = 2;  //Zmieniamy stan przycisku na 2 bo gdyby był na 0 to po dojściu zmiennej2 powyżej czasPodtrzymania,
              //zaczęło by się ledsOff również dla drugiego przycisku-drugiej strony, mimo ze tam nie był pzycisk wciśnięty
    
   czasCzekania(); 
    break;
  }
}



void ledsOffZdolu(){  

  
if((ileRazyP1>=1)&&(zmiennaP1>8)){ //Jeśli ktoś nacisnie w czasie gaszenia, to rozświetl od początku i wyzeruj podtrzymanie
  // Oraz wyzeruj zmiennaP1. Więc ledsOff startuje ze zmiennaP1=0 NIE = 9 więc przechodzi czas równy podświetlaniu (1-8) potem przy zmiennejP1=9 zaczyna gasnąć. Trochę na odwrót, ale działa
  zmiennaP1=0;
  zmienna2=0;
  ledsOnZdolu();
}
  
newTime = millis();
  Serial.print("newTime z ledsOff z D ");
    Serial.println(newTime);
  if (newTime - oldTime >= 600)
  {
    oldTime = newTime;
    zmiennaP1++;
    Serial.print("wart zmiennaP1 z ledsOff Z dolu ");
    Serial.println(zmiennaP1);
  }
  
  switch (zmiennaP1) //kontynuacja switchów z wcześniejszej części
  {
  case 9:
    digitalWrite(led1, LOW); //wyłączasz led1
    break;
  case 10: //wyłączasz led2
    digitalWrite(led2, LOW);
    break;
  case 11: //wyłaczasz led3
    digitalWrite(led3, LOW);
    break;
  case 12:
    digitalWrite(led4, LOW);
    break;
  case 13:
    digitalWrite(led5, LOW);
    break;
  case 14:
    digitalWrite(led6, LOW);
    break;
  case 15:
    digitalWrite(led7, LOW);
    stanPrzycisku1 = 0;
    stanPrzycisku2=0; //resetowanie wartości obu przycisków
    zmiennaP1 = 0;
    zmiennaP2=0;
    zmienna2=0;
    ileRazyP1=0;
    dodatkowePodtrzymanie=0;  //reset dodatkowego potrzymania 
    Serial.print("dodatkowe potrzym ");
    Serial.println(dodatkowePodtrzymanie);
    break;
  }
}

void ledsOffZgory(){   

  
if((ileRazyP2>=1)&&(zmiennaP2>8)){ //Jeśli ktoś nacisnie w czasie gaszenia, to rozświetl od początku i wyzeruj podtrzymanie
  // Oraz wyzeruj zmiennaP1. Więc ledsOff startuje ze zmiennaP1=0 NIE = 9 więc przechodzi czas równy podświetlaniu (1-8) potem przy zmiennejP1=9 zaczyna gasnąć. Trochę na odwrót, ale działa
  zmiennaP2=0;
  zmienna2=0;
  ledsOnZgory();
}
  
newTime = millis();
  Serial.print("newTime z ledsOff z G ");
    Serial.println(newTime);
  if (newTime - oldTime >= 600)
  {
    oldTime = newTime;
    zmiennaP2++;
    Serial.print("wart zmiennaP2 z ledsOff z gory ");
    Serial.println(zmiennaP2);
  }
  
  switch (zmiennaP2) //kontynuacja switchów z wcześniejszej części
  {
  case 9:
    digitalWrite(led7, LOW); //wyłączasz led1
    break;
  case 10: //wyłączasz led2
    digitalWrite(led6, LOW);
    break;
  case 11: //wyłaczasz led3
    digitalWrite(led5, LOW);
    break;
  case 12:
    digitalWrite(led4, LOW);
    break;
  case 13:
    digitalWrite(led3, LOW);
    break;
  case 14:
    digitalWrite(led2, LOW);
    break;
  case 15:
    digitalWrite(led1, LOW);
    stanPrzycisku2 = 0;
    stanPrzycisku1=0;  //resetowanie wartości obu przycisków
    zmiennaP2 = 0;
    zmiennaP1=0;
    zmienna2=0;
    ileRazyP2=0;
    dodatkowePodtrzymanie=0;  //reset dodatkowego potrzymania    
    Serial.print("dodatkowe potrzym ");
    Serial.println(dodatkowePodtrzymanie);
    break;
  }
}

void czasCzekania()
{    //jako że program nie jest wymagający to tutaj również można użyć delay'a bo i tak program jest wstrzymany
  do //cała ta pętla wstrzyma Ci cały program póki nie zostanie spełniony warunek za wyrażeniem while
  {
   
    odczytanaWartosc = analogRead(A0);                        //odczytujesz wartość z portu A0
    czasPodtrzymania = map(odczytanaWartosc, 0, 1023, 0, 10); //zamienia zmienną z przedziału od 0 do 1023 na zmienną od 0 do 10 (sekund)
  if(czasPodtrzymania==0){  //Przy czasie podtrzymania=0 działa błędnie. Więc po skręceniu na 0 itak poprawi na 1
    czasPodtrzymania=1;
  }
 
  Serial.print("t podtrzym z potenc. ");
  Serial.println(czasPodtrzymania); 
    czasPodtrzymania=czasPodtrzymania+dodatkowePodtrzymanie;
   
    
    Serial.print("t podtrzym+ dodatk ");
    Serial.println(czasPodtrzymania);     
    
    newTimePodtrzymania = millis();
    if (newTimePodtrzymania - oldTimePodtrzymania >= 800) // odliczaj po 1s
    {
      oldTimePodtrzymania = newTimePodtrzymania;
      zmienna2++; //co 1sek zwiększasz wartość zmiennej2
 
      if(ileRazyP1>=1){  //Jeśli naciśnięto  kolejny raz przycisk to reset podtrzymania i zmiennejP1. Następnie przechodzi do ledsOff ze zmiennąP1=0
        // NIE = 9 więc tam przechodzi czas równy podświetlaniu potem przy zmiennejP1=9 zaczyna gasnąć. Trochę na odwrót, ale działa
    
      zmiennaP1=0;
      zmienna2=0;
      ileRazyP1=0;
    }

    if(ileRazyP2>=1){  //Jeśli naciśnięto  kolejny raz przycisk to reset podtrzymania i zmiennejP1. Następnie przechodzi do ledsOff ze zmiennąP1=0
        // NIE = 9 więc tam przechodzi czas równy podświetlaniu potem przy zmiennejP1=9 zaczyna gasnąć. Trochę na odwrót, ale działa
    
      zmiennaP2=0;
      zmienna2=0;
      ileRazyP2=0;
    }
    ileRazyP1=0; // Reset zmiennych ileRazy, żeby w f. ledsOff było można wydłużyć świecenie gdy kolejne naciśnięcie
    ileRazyP2=0;     
    
      
    Serial.print("ZMIENNA 2 akt. wart. ");
    Serial.println(zmienna2);
      
    }
  } while (zmienna2 <= czasPodtrzymania); //a pętla trwa póki zmienna2 nie osiągnie wartości zmapowanej zmiennej czasPodtrzymania
  

}

void resetZmienna2P1()
{
  ileRazyP1++;
  delay(100);
  if(zmiennaP1>15){
    zmiennaP1=0;
  }
 
  Serial.print("ile razy P 1 ");
  Serial.println(ileRazyP1);
}  

void resetZmienna2P2()
{
  ileRazyP2++;
  delay(100);
  if(zmiennaP2>15){
    zmiennaP2=0;
  }
  Serial.print("ile razy P 2 ");
  Serial.println(ileRazyP2);
}  
 

 

A propos biblioteki Timers, to do rozróżnienia czasu naciśnięcia przycisku próbowałem użyć biblioteki EasyButton poleconej mi przez inną osobę. Okazało się, że  bibliotek wykonuje tylko jeden kod, zależny od długości czasu naciśnięcia. Więc ktoś podrzucił mi kod rozpoznający czas naciśnięcia bez użycia dodatkowych bibliotek. Długi, ale działa. 

Link to post
Share on other sites

Analizowałem wczoraj pracę programu i doszedłem do wniosku, że być może warunki na uruchomienie funkcji ledsOff są poprawne, ale program działa tak, że nie zostaną spełnione. Otóż, gdy nacisnę dwa przyciski w niewielkim odstępie czasu, to pierwszy przycisk uruchomi np. ledsOnWgore i po dojściu zmiennejP1 do wartości 8, uruchomi się f. czasCzekania. Gdy ta funkcja się skończy, to program zamiast porównać czy zmiennaP2 jest mniejsza od zmiennejP1,  zaczyna kontynuować naliczanie wartości zmiennej od przycisku który został naciśnięty później (w tym przypadku zmiennejP2). 
Dopiero gdy zmiennaP2 też urośnie do 8, to program porównuje  wartości zmiennejP1 i zmiennejP2 i wtedy niestety obie mają wartość 8. Więc nie jest spełniony żaden z tych warunków do wejścia do f. ledsOff

Powinno być więc może tak, że gdy od jednego z przycisków zapalą się już wszystkie diody (przyjmijmy że pierwszy naciskam Przycisk1)  czyli zmiennaP1 osiągnie wartość 7, to  sprawdzamy czy zmiennaP2 jest  większa od 0 (czyli naciśnięto przycisk 2) i czy zmiennaP2 jest mniejsza od zmiennejP1 (czyli przycisk 2 naciśnięto później niż 1) Lub zmiennaP2 ma wartość 0, czyli nie wciśnięto przycisku 2 i jeśli któryś z tych warunków jest spełniony to zmienną stanPrzycisku1 zmieniam na 0, co spowoduje, że nie będzie się dalej naliczała zmiennaP1 od niego, czyli program nie wejdzie do f.  czasCzekania tylko pozowoli zmiennejP2 urosnąć do 8 i dopiero od niej uruchomi f. czasCzekania a po niej f. ledsOff od drugiego przycisku. 
Co o tym sądzicie, myślicie że dobrze rozumuję? 

Link to post
Share on other sites

Ja może wtrącę swoje trzy grosze zanim ten kod rozrośnie się tak, że przestanie się mieścić w pamięci 🙂

Istnieje coś takiego, jak zasada maksymalnej izolacji modułów. W Waszym przypadku możemy rozbić program na dwa różne moduły:

Moduł pierwszy - pobieranie polecenia. Ten moduł ma np. dostęp do wszelkich klawiszy, i na podstawie różnych kombinacji wciśnięć generuje polecenie. Przykładowo (upraszczając sprawę): wciśnięcie klawisza na dole oznacza "idę do góry", wciśnięcie klawisza na górze to "idę w dół", dłuższe wciśnięcie klawisza to "zapal wszystkie światła". Moduł nic nie wie o tym, jak to jest realizowanie, w ogóle nie ma żadnej informacji o jakichś ledach, światełkach, schodach i tym podobnych niepotrzebnych rzeczach; dla niego istnieją wyłącznie klawisze (ew. czujniki czy co tam sobie wymyślicie).

Fragment kodu mógłby wyglądać jakoś tak:

#define POLECENIE_WCHODZE (1 << 0)
#define POLECENIE_SCHODZE (1 << 1)
#define POLECENIE_ZAPAL   (1 << 2)
  
...
  
int polecenie = odbierzPolecenie();

Drugi moduł to realizacja polecenia. Moduł nie wie nic o jakichś klawiszach, guzikach, czujnikach i podobnych ustrojstwach. On ma tylko dostać na wejściu polecenie i je wykonać. W jaki sposób to polecenie będzie wydane - to już go nie obchodzi. Jakiś tam fragment pseudokodu mógłby wyglądać tak:

if wiatło_zgaszone && (polecenie & POLECENIE_WCHODZE)) {
  rozpocznij_sekwencje_wejścia();
}

Zaręczam, że kod będzie krótszy i łatwiejszy do opanowania 🙂

 

Link to post
Share on other sites

Skopiowałem ten Twój kod nacisnąłem przycisk kompiluj i niespodzianka -wyskoczył Error

\Documents\Arduino\sketch_nov24a/sketch_nov24a.ino:175: undefined reference to `wylaczStale()'

collect2.exe: error: ld returned 1 exit status

exit status 1

Błąd kompilacji dla płytki Arduino Uno.

Są dwa błędy
void wlaczNaStale();

  //włączenie wszystkich diod na stałe

void wylaczStale();

Jak widać to nie ma prawa działać z oczywistych powodów.Nie jest moją intencją krytykowanie  ale czy mógłbyś być bardziej staranny w tym co robisz.

Edytowano przez szymonw
Link to post
Share on other sites

O... Przepraszam. Jak pisałem, nie wrzuciłem całego kodu, bo f. włączania lub włączania stałego podświetlania nie ma tu znaczenia. Nie zauważyłem że nie wyciąłem wszystkich miejsc gdzie jest ona wymieniona. 

Wczoraj udało mi się rozwiązać powyższy problem, w sposób opisany w poprzenim poście (w skrócie pisząc,  sprawdzając w "kejsie" 7 czy jest naciśnięty drugi przycisk). 

 

Link to post
Share on other sites

Dołącz do dyskusji, napisz odpowiedź!

Jeśli masz już konto to zaloguj się teraz, aby opublikować wiadomość jako Ty. Możesz też napisać teraz i zarejestrować się później.
Uwaga: wgrywanie zdjęć i załączników dostępne jest po zalogowaniu!

Anonim
Dołącz do dyskusji! Kliknij i zacznij pisać...

×   Wklejony jako tekst z formatowaniem.   Przywróć formatowanie

  Dozwolonych jest tylko 75 emoji.

×   Twój link będzie automatycznie osadzony.   Wyświetlać jako link

×   Twoja poprzednia zawartość została przywrócona.   Wyczyść edytor

×   Nie możesz wkleić zdjęć bezpośrednio. Prześlij lub wstaw obrazy z adresu URL.

×
×
  • Utwórz nowe...

Ważne informacje

Ta strona używa ciasteczek (cookies), dzięki którym może działać lepiej. Więcej na ten temat znajdziesz w Polityce Prywatności.