Open form

Wielozadaniowość Arduino - część pierwsza

Wielozadaniowość Arduino - część pierwsza

Większe i lepsze projekty

Jeśli opanowałeś już podstawowe migające diody LED, proste czujniki i serwomechanizmy, jesteś gotowy zacząć przygodę z większymi i lepszymi projektami. Zazwyczaj wiąże się to z łączeniem części prostszych szkiców i próbą ich wspólnego działania. Pierwszą odkrytą przez Ciebie rzeczą będzie to, że niektóre z tych szkiców, które osobno działają idealnie, nie zgrywają się z innymi.

 

Arduino to bardzo prosty moduł bez systemu operacyjnego, który może uruchomić tylko jeden program. W przeciwieństwie do Twojego osobistego komputera lub Raspberry Pi, Arduino nie ma możliwości ładowania i uruchamiania wielu programów. 

 

Nie oznacza to, że nie możemy wykonać wielu zadań w Arduino. Musimy po prostu użyć innej metody. Nie mamy systemu operacyjnego do pomocy, więc musimy wziąć sprawę we własne ręce.

 

Wielozadaniowość Arduino

Pozbądź się funkcji delay()

Pierwsze, czego się nauczyłeś podczas zabawy z Arduino, to najprawdopodobniej użycie powyższej funkcji (delay-opóźnienie). Funkcja delay() nie jest skomplikowana, ale sprawia ona problemy gdy dodaje się dodatkowe funkcje. Kłopotem jest to, że owa funkcja, jest "aktywnym czekaniem" (z ang. busy wait), która dominuje procesor. 

 

Podczas wywoływania tej funkcji, nie możesz reagować na wejścia, nie możesz przetwarzać żadnych danych i nie możesz zmienić jakiegokolwiek wyjścia. Blokuje ona cały procesor. Więc, jeśli któraś część Twojego kodu korzysta z tej funkcji, na ten czas, wszystko inne zostaje zatrzymane.

 

Pamiętasz Blink?

 

  1. /*
  2.  Blink
  3.  Turns on an LED on for one second, then off for one second, repeatedly.
  4.  
  5.  This example code is in the public domain.
  6.  */
  7.  
  8. // Pin 13 has an LED connected on most Arduino boards.
  9. // give it a name:
  10. int led = 13;
  11. // the setup routine runs once when you press reset:
  12. void setup() { 
  13.  // initialize the digital pin as an output.
  14.  pinMode(led, OUTPUT); 
  15. }
  16. // the loop routine runs over and over again forever:
  17. void loop() {
  18.  digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
  19.  delay(1000); // wait for a second
  20.  digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
  21.  delay(1000); // wait for a second
  22. }
  24.  

Prosty szkic Blink jest prawie cały czas w funkcji delay(). Więc w tym czasie, procesor nie może robić nic innego.

 

Nie zapomniałeś o sweep?

Sweep używa funkcji delay(), aby kontrolować swoją prędkość. Jeśli spróbujesz połączyć podstawowy szkic blink z przykładem serwomechanizmu sweep, zauważysz, że naprzemiennie miga dioda i porusza się serwo. Nie będzie jednak działo się to jednocześnie.

 

  1. #include 
  3. // Pin 13 has an LED connected on most Arduino boards.
  4. // give it a name:
  5. int led = 13;
  7. Servo myservo; // create servo object to control a servo
  8. // twelve servo objects can be created on most boards
  10. int pos = 0; // variable to store the servo position
  12. void setup()
  13. {
  14.  // initialize the digital pin as an output.
  15.  pinMode(led, OUTPUT);
  16.  myservo.attach(9); // attaches the servo on pin 9 to the servo object
  17. }
  19. void loop()
  20. {
  21.  digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
  22.  delay(1000); // wait for a second
  23.  digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
  24.  delay(1000); // wait for a second
  26.  for (pos = 0; pos <= 180; pos += 1) // goes from 0 degrees to 180 degrees
  27.  { // in steps of 1 degree
  28.  myservo.write(pos); // tell servo to go to position in variable 'pos'
  29.  delay(15); // waits 15ms for the servo to reach the position
  30.  }
  31.  for (pos = 180; pos >= 0; pos -= 1) // goes from 180 degrees to 0 degrees
  32.  {
  33.  myservo.write(pos); // tell servo to go to position in variable 'pos'
  34.  delay(15); // waits 15ms for the servo

 

Więc jak skontrolujemy opóźnienie bez użycia funkcji delay?

Użycie funkcji millis() w opóźnieniu

Prostą techniką wdrożenia opóźnienia jest zrobienie planu i obserwowanie zegarka. Zamiast skupiać się na funkcji delay, po prostu systematycznie sprawdzasz czas, aby wiedzieć kiedy działać. W międzyczasie, inne zadania mogą korzystać z procesora. Bardzo prostym tego przykładem jest szkic BlinkyWithoutDelay ze środowiskiem programistycznym. 

 

Schemat podłączenia dla powyższego kodu znajduje się poniżej:

  

Wielozadaniowość Arduino - schemat podłączenia

 

Migotanie bez opóźnień 

Oto przykładowy kod BlinkWithoutDelay:

 

  1. /* Blink without Delay
  2.  
  3.  Turns on and off a light emitting diode(LED) connected to a digital 
  4.  pin, without using the delay() function. This means that other code
  5.  can run at the same time without being interrupted by the LED code.
  6.  
  7.  The circuit:
  8.  * LED attached from pin 13 to ground.
  9.  * Note: on most Arduinos, there is already an LED on the board
  10.  that's attached to pin 13, so no hardware is needed for this example.
  11.  
  12.  
  13.  created 2005
  14.  by David A. Mellis
  15.  modified 8 Feb 2010
  16.  by Paul Stoffregen
  17.  
  18.  This example code is in the public domain.
  20.  http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
  21.  */
  22. // constants won't change. Used here to 
  23. // set pin numbers:
  24. const int ledPin = 13; // the number of the LED pin
  25. // Variables will change:
  26. int ledState = LOW; // ledState used to set the LED
  27. long previousMillis = 0; // will store last time LED was updated
  28. // the follow variables is a long because the time, measured in miliseconds,
  29. // will quickly become a bigger number than can be stored in an int.
  30. long interval = 1000; // interval at which to blink (milliseconds)
  31. void setup() {
  32.  // set the digital pin as output:
  33.  pinMode(ledPin, OUTPUT); 
  34. }
  35. void loop()
  36. {
  37.  // here is where you'd put code that needs to be running all the time.
  38. // check to see if it's time to blink the LED; that is, if the 
  39.  // difference between the current time and last time you blinked 
  40.  // the LED is bigger than the interval at which you want to 
  41.  // blink the LED.
  42.  unsigned long currentMillis = millis();
  43.  
  44.  if(currentMillis - previousMillis > interval) {
  45.  // save the last time you blinked the LED 
  46.  previousMillis = currentMillis;
  47. // if the LED is off turn it on and vice-versa:
  48.  if (ledState == LOW)
  49.  ledState = HIGH;
  50.  else
  51.  ledState = LOW;
  52. // set the LED with the ledState of the variable:
  53.  digitalWrite(ledPin, ledState);
  54.  }
  55. }
  56.  
  57.

Czy ma to jakiś sens?

Na pierwszy rzut oka, BlinkWithoutDelay nie wydaje się zbytnio interesujące. Wygląda jak bardziej skomplikowany sposób na włączenie diod LED. Jednakże, BlinkWithoutDelay prezentuje bardzo ważny koncept znany jako Automat skończony (z ang. State Machine).

Nie musisz już polegać na funkcji delay(), żeby stworzyć program migających diod. BlinkWithoutDelay zapamiętuje obecny status diod LED i ostatni czas, w którym się on zmienił. Po każdej pętli, sprawdza on zegar millis(), aby wiedzieć czy powinien ponownie zmienić status diod LED.

 

Witaj w maszynie

Zwróćmy uwagę na trochę bardziej interesujący wariant blink, który posiada różne czasy włączenia i wyłączenia. Nazwaliśmy go "FlashWithoutDelay"

 

  1. // These variables store the flash pattern
  2. // and the current state of the LED
  3. int ledPin = 13; // the number of the LED pin
  4. int ledState = LOW; // ledState used to set the LED
  5. unsigned long previousMillis = 0; // will store last time LED was updated
  6. long OnTime = 250; // milliseconds of on-time
  7. long OffTime = 750; // milliseconds of off-time
  8. void setup() 
  9. {
  10.  // set the digital pin as output:
  11.  pinMode(ledPin, OUTPUT); 
  12. }
  13. void loop()
  14. {
  15.  // check to see if it's time to change the state of the LED
  16.  unsigned long currentMillis = millis();
  17.  
  18.  if((ledState == HIGH) && (currentMillis - previousMillis >= OnTime))
  19.  {
  20.  ledState = LOW; // Turn it off
  21.  previousMillis = currentMillis; // Remember the time
  22.  digitalWrite(ledPin, ledState); // Update the actual LED
  23.  }
  24.  else if ((ledState == LOW) && (currentMillis - previousMillis >= OffTime))
  25.  {
  26.  ledState = HIGH; // turn it on
  27.  previousMillis = currentMillis; // Remember the time
  28.  digitalWrite(ledPin, ledState); // Update the actual LED
  29.  }
  30. }
  31.  
  32.

Status + Mashine = State Machine

Zauważ, że mamy zmienne, które śledzą czy dioda LED jest włączona czy wyłączona. Są też takie, które obserwują ostatnio zaszłą zmianę. Jest to część Automatu zwana Statusem.

 

Posiadamy również kod, który czuwa nad statusem i decyduje kiedy i jak trzeba go zmienić. To jest część zwana Maszyną. Po każdej pętli, "uruchamiamy maszynę", a ona aktualizuje status.

 

Następnie, sprawdzimy jak połączysz automaty jednocześnie je uruchamiając. 

 

Cel - dwa na raz

Czas na wielozadaniowość! Najpierw podłącz kolejną diodę LED, tak jak na schemacie poniżej:

 

Wielozadaniowość Arduino - schemat podłączenia diod LED

 

Następnie stworzymy kolejny automat dla drugiej diody LED, która miga z zupełnie innymi szybkościami. Użycie dwóch oddzielnych automatów sprawi, że te dwie diody będą migać, nie będąc od siebie zależne.

 

  1. // These variables store the flash pattern
  2. // and the current state of the LED
  3. int ledPin1 = 12; // the number of the LED pin
  4. int ledState1 = LOW; // ledState used to set the LED
  5. unsigned long previousMillis1 = 0; // will store last time LED was updated
  6. long OnTime1 = 250; // milliseconds of on-time
  7. long OffTime1 = 750; // milliseconds of off-time
  8. int ledPin2 = 13; // the number of the LED pin
  9. int ledState2 = LOW; // ledState used to set the LED
  10. unsigned long previousMillis2 = 0; // will store last time LED was updated
  11. long OnTime2 = 330; // milliseconds of on-time
  12. long OffTime2 = 400; // milliseconds of off-time
  13. void setup() 
  14. {
  15.  // set the digital pin as output:
  16.  pinMode(ledPin1, OUTPUT); 
  17.  pinMode(ledPin2, OUTPUT); 
  18. }
  19. void loop()
  20. {
  21.  // check to see if it's time to change the state of the LED
  22.  unsigned long currentMillis = millis();
  23.  
  24.  if((ledState1 == HIGH) && (currentMillis - previousMillis1 >= OnTime1))
  25.  {
  26.  ledState1 = LOW; // Turn it off
  27.  previousMillis1 = currentMillis; // Remember the time
  28.  digitalWrite(ledPin1, ledState1); // Update the actual LED
  29.  }
  30.  else if ((ledState1 == LOW) && (currentMillis - previousMillis1 >= OffTime1))
  31.  {
  32.  ledState1 = HIGH; // turn it on
  33.  previousMillis1 = currentMillis; // Remember the time
  34.  digitalWrite(ledPin1, ledState1); // Update the actual LED
  35.  }
  36.  
  37.  if((ledState2 == HIGH) && (currentMillis - previousMillis2 >= OnTime2))
  38.  {
  39.  ledState2 = LOW; // Turn it off
  40.  previousMillis2 = currentMillis; // Remember the time
  41.  digitalWrite(ledPin2, ledState2); // Update the actual LED
  42.  }
  43.  else if ((ledState2 == LOW) && (currentMillis - previousMillis2 >= OffTime2))
  44.  {
  45.  ledState2 = HIGH; // turn it on
  46.  previousMillis2 = currentMillis; // Remember the time
  47.  digitalWrite(ledPin2, ledState2); // Update the actual LED
  48.  }
  49. }
  50.  
  51.

Dziękuję serdecznie! Czy mogę dostać następny?

Możesz dodawać więcej automatów, dopóki będziesz mieć wystarczająco pamięci lub pinów GPIO. Każdy automat posiada swoją własną szybkość migotania. Jako zadanie, zedytuj powyższy kod, aby móc dodać trzeci automat. 

 

  • Po pierwsze, skopiuj wszystkie zmienne statusu i kod jednego z automatów.
  • Potem, nazwij ponownie każdą zmienną, aby uniknąć sprzeczności z pierwszą maszyną.

 

Nie jest to trudne do zrobienia. Lecz ciągłe przepisywanie kodu wydaje się raczej czasochłonne. Musi być jakiś inny sposób by to zrobić!

 

Istnieją lepsze metody radzenia sobie z tym. Są to techniki programowania, które są prostsze i bardziej efektywne. 

 

Klasy

Spójrzmy jeszcze raz na nasz ostatni szkic. Jak widzisz, jest on bardzo monotonny. Ten sam kod jest kopiowany niemalże słowo w słowo dla każdej migoczącej diody LED. Jedyną rzeczą, która się zmienia (w niewielkim stopniu) to nazwa zmiennych. 

 

Kod ten jest najlepszym kandydatem do programowania obiektowego (OOP, z ang. Object Oriented Programming)

 

OOP w pętli

Język Arduino jest odmianą języka C++, który obsługuje programowanie obiektowe. Korzystając z języka OOP możemy zebrać wszystkie zmienne statusu i funkcje migającej diody LED w klasie C++.

  

Nie jest to trudne do zrobienia, ponieważ już posiadamy cały napisany kod. Musimy tylko przepakować go jako klasę.

 

Określanie klasy:

Zaczynamy zadeklarowaniem klasy "Flasher":

  

Następnie dodajemy wszystkie zmienne z FlashWithoutDelay. Są one częścią klasy, więc znamy je jako zmienne składowe (member variables).

 

  1. class Flasher
  2. {
  3.  // Class Member Variables
  4.  // These are initialized at startup
  5.  int ledPin; // the number of the LED pin
  6.  long OnTime; // milliseconds of on-time
  7.  long OffTime; // milliseconds of off-time
  8. // These maintain the current state
  9.  int ledState; // ledState used to set the LED
  10.  unsigned long previousMillis; // will store last time LED was updated
  11. };
  12.  
  13.

Potem dodajemy konstruktor (constructor). Ma on tę samą nazwę co klasa, a jego zadaniem jest inicjować wszystkie zmienne.

 

  1. class Flasher
  2. {
  3.  // Class Member Variables
  4.  // These are initialized at startup
  5.  int ledPin; // the number of the LED pin
  6.  long OnTime; // milliseconds of on-time
  7.  long OffTime; // milliseconds of off-time
  8. // These maintain the current state
  9.  int ledState; // ledState used to set the LED
  10.  unsigned long previousMillis; // will store last time LED was updated
  11. // Constructor - creates a Flasher 
  12.  // and initializes the member variables and state
  13.  public:
  14.  Flasher(int pin, long on, long off)
  15.  {
  16.  ledPin = pin;
  17.  pinMode(ledPin, OUTPUT); 
  18.  
  19.  OnTime = on;
  20.  OffTime = off;
  21.  
  22.  ledState = LOW; 
  23.  previousMillis = 0;
  24.  }
  25. };
  26.  
  27.   

Na koniec, zmieniamy pętlę w funkcję składową nazwaną "Update()". 

 

  1. class Flasher
  2. {
  3.  // Class Member Variables
  4.  // These are initialized at startup
  5.  int ledPin; // the number of the LED pin
  6.  long OnTime; // milliseconds of on-time
  7.  long OffTime; // milliseconds of off-time
  8. // These maintain the current state
  9.  int ledState; // ledState used to set the LED
  10.  unsigned long previousMillis; // will store last time LED was updated
  11. // Constructor - creates a Flasher 
  12.  // and initializes the member variables and state
  13.  public:
  14.  Flasher(int pin, long on, long off)
  15.  {
  16.  ledPin = pin;
  17.  pinMode(ledPin, OUTPUT); 
  18.  
  19.  OnTime = on;
  20.  OffTime = off;
  21.  
  22.  ledState = LOW; 
  23.  previousMillis = 0;
  24.  }
  25. void Update()
  26.  {
  27.  // check to see if it's time to change the state of the LED
  28.  unsigned long currentMillis = millis();
  29.  
  30.  if((ledState == HIGH) && (currentMillis - previousMillis >= OnTime))
  31.  {
  32.  ledState = LOW; // Turn it off
  33.  previousMillis = currentMillis; // Remember the time
  34.  digitalWrite(ledPin, ledState); // Update the actual LED
  35.  }
  36.  else if ((ledState == LOW) && (currentMillis - previousMillis >= OffTime))
  37.  {
  38.  ledState = HIGH; // turn it on
  39.  previousMillis = currentMillis; // Remember the time
  40.  digitalWrite(ledPin, ledState); // Update the actual LED
  41.  }
  42.  }
  43. };
  44.  
  45.

Zmieniając nasz kod w klasę Flasher, zwęziliśmy wszystkie zmienne (status) i funkcje (maszyna) migającej diody LED.

 

A teraz użyjmy tego:

Dla każdej diody LED, którą chcemy zaświecić, tworzymy przykład klasy Flasher przywołując konstruktor. Przy każdym przejściu przez pętlę, musimy przywołać Update() dla każdego przykładu Flashera. 

 

Już nie trzeba powtarzać całego kodu automatu. Pozostaje nam tylko prosić o kolejne przykłady klasy Flasher!

 

  1. class Flasher
  2. {
  3.  // Class Member Variables
  4.  // These are initialized at startup
  5.  int ledPin; // the number of the LED pin
  6.  long OnTime; // milliseconds of on-time
  7.  long OffTime; // milliseconds of off-time
  8. // These maintain the current state
  9.  int ledState; // ledState used to set the LED
  10.  unsigned long previousMillis; // will store last time LED was updated
  11. // Constructor - creates a Flasher 
  12.  // and initializes the member variables and state
  13.  public:
  14.  Flasher(int pin, long on, long off)
  15.  {
  16.  ledPin = pin;
  17.  pinMode(ledPin, OUTPUT); 
  18.  
  19.  OnTime = on;
  20.  OffTime = off;
  21.  
  22.  ledState = LOW; 
  23.  previousMillis = 0;
  24.  }
  25. void Update()
  26.  {
  27.  // check to see if it's time to change the state of the LED
  28.  unsigned long currentMillis = millis();
  29.  
  30.  if((ledState == HIGH) && (currentMillis - previousMillis >= OnTime))
  31.  {
  32.  ledState = LOW; // Turn it off
  33.  previousMillis = currentMillis; // Remember the time
  34.  digitalWrite(ledPin, ledState); // Update the actual LED
  35.  }
  36.  else if ((ledState == LOW) && (currentMillis - previousMillis >= OffTime))
  37.  {
  38.  ledState = HIGH; // turn it on
  39. previousMillis = currentMillis; // Remember the time
  40.  digitalWrite(ledPin, ledState); // Update the actual LED
  41.  }
  42.  } 
  43. };
  45. Flasher led1(12, 100, 400);
  46. Flasher led2(13, 350, 350);
  47. void setup()
  48. {
  49. }
  50. void loop()
  51. {
  52.  led1.Update();
  53.  led2.Update();
  54. }
  55.  

 

Mniej oznacza więcej!

Nareszcie - każda dodatkowa dioda LED wymaga tylko dwóch linijek kodu!

 

Kod ten jest krótszy i łatwiejszy w odczytaniu. A ponieważ nie ma zduplikowanego kodu, jest mniej do skompilowania! To wszystko oszczędza pamięć na inne projekty!

 

Co jeszcze możemy zrobić?

Zastosujmy te same zasady do kodów serwomechanizmów i zacznijmy działać. 

 

Najpierw, połącz ze sobą dwa serwa na płytce stykowej, tak ja na rysunku poniżej. Następnie, podłącz również trzecią diodę LED.

 

Wielozadaniowość Arduino - schemat podłączenia serw i diod LED

  

Oto standardowy kod sweep serwa. Zauważ, że przywołuje on niechcianą przez nas funkcję delay(). Weźmiemy części tego kodu, aby zbudować automat "Sweeper".

 

  1. // Sweep
  2. // by BARRAGAN  
  3. // This example code is in the public domain.
  5. #include  
  6.  
  7. Servo myservo; // create servo object to control a servo 
  8.  // a maximum of eight servo objects can be created 
  9.  
  10. int pos = 0; // variable to store the servo position 
  11.  
  12. void setup() 
  13. { 
  14.  myservo.attach(9); // attaches the servo on pin 9 to the servo object 
  15. } 
  16.  
  17.  
  18. void loop() 
  19. { 
  20.  for(pos = 0; pos < 180; pos += 1) // goes from 0 degrees to 180 degrees 
  21.  { // in steps of 1 degree 
  22.  myservo.write(pos); // tell servo to go to position in variable 'pos' 
  23.  delay(15); // waits 15ms for the servo to reach the position 
  24.  } 
  25.  for(pos = 180; pos>=1; pos-=1) // goes from 180 degrees to 0 degrees 
  26.  { 
  27.  myservo.write(pos); // tell servo to go to position in variable 'pos' 
  28.  delay(15); // waits 15ms for the servo to reach the position 
  29.  } 
  30. }

 

Poniższa klasa Sweeper streszcza akcję sweep, ale używa funkcji millis() do ustawienia opóźnienia. 

 

Musimy także dodać funkcje Attach() i Detach(), żeby powiązać serwo z konkretnym pinem:

 

  1. class Sweeper
  2. {
  3.  Servo servo; // the servo
  4.  int pos; // current servo position 
  5.  int increment; // increment to move for each interval
  6.  int updateInterval; // interval between updates
  7.  unsigned long lastUpdate; // last update of position
  8. public: 
  9.  Sweeper(int interval)
  10.  {
  11.  updateInterval = interval;
  12.  increment = 1;
  13.  }
  14.  
  15.  void Attach(int pin)
  16.  {
  17.  servo.attach(pin);
  18.  }
  19.  
  20.  void Detach()
  21.  {
  22.  servo.detach();
  23.  }
  24.  
  25.  void Update()
  26.  {
  27.  if((millis() - lastUpdate) > updateInterval) // time to update
  28.  {
  29.  lastUpdate = millis();
  30.  pos += increment;
  31.  servo.write(pos);
  32.  Serial.println(pos);
  33.  if ((pos >= 180) || (pos <= 0)) // end of sweep
  34.  {
  35.  // reverse direction
  36.  increment = -increment;
  37.  }
  38.  }
  39.  }
  40. };

 

Jak dużo?

Teraz możemy tworzyć tyle egzemplarzy Flasherów i Sweeperów, ile tylko chcemy.

 

Każdy przykład Flashera wymaga 2 linii kodu:

  • jedną, aby zadeklarować przykład
  • drugą, żeby przywołać aktualizację w pętli

 

Każdy przykład Sweepera wymaga tylko 3 linii kodu:

  • jedną, aby zadeklarować przykład
  • drugą, żeby powiązać serwo z pinem
  • i trzecią, aby przywołać aktualizację w pętli

 

  1. #include 
  2. class Flasher
  3. {
  4.  // Class Member Variables
  5.  // These are initialized at startup
  6.  int ledPin; // the number of the LED pin
  7.  long OnTime; // milliseconds of on-time
  8.  long OffTime; // milliseconds of off-time
  9. // These maintain the current state
  10.  int ledState; // ledState used to set the LED
  11.  unsigned long previousMillis; // will store last time LED was updated
  12. // Constructor - creates a Flasher 
  13.  // and initializes the member variables and state
  14.  public:
  15.  Flasher(int pin, long on, long off)
  16.  {
  17.  ledPin = pin;
  18.  pinMode(ledPin, OUTPUT); 
  19.  
  20.  OnTime = on;
  21.  OffTime = off;
  22.  
  23.  ledState = LOW; 
  24.  previousMillis = 0;
  25.  }
  26. void Update()
  27.  {
  28.  // check to see if it's time to change the state of the LED
  29.  unsigned long currentMillis = millis();
  30.  
  31.  if((ledState == HIGH) && (currentMillis - previousMillis >= OnTime))
  32.  {
  33.  ledState = LOW; // Turn it off
  34.  previousMillis = currentMillis; // Remember the time
  35.  digitalWrite(ledPin, ledState); // Update the actual LED
  36.  }
  37.  else if ((ledState == LOW) && (currentMillis - previousMillis >= OffTime))
  38.  {
  39.  ledState = HIGH; // turn it on
  40.  previousMillis = currentMillis; // Remember the time
  41.  digitalWrite(ledPin, ledState); // Update the actual LED
  42.  }
  43.  }
  44. };
  45. class Sweeper
  46. {
  47.  Servo servo; // the servo
  48.  int pos; // current servo position 
  49.  int increment; // increment to move for each interval
  50.  int updateInterval; // interval between updates
  51.  unsigned long lastUpdate; // last update of position
  52. public: 
  53.  Sweeper(int interval)
  54.  {
  55.  updateInterval = interval;
  56.  increment = 1;
  57.  }
  58.  
  59.  void Attach(int pin)
  60.  {
  61.  servo.attach(pin);
  62.  }
  63.  
  64.  void Detach()
  65.  {
  66.  servo.detach();
  67.  }
  68.  
  69.  void Update()
  70.  {
  71.  if((millis() - lastUpdate) > updateInterval) // time to update
  72.  {
  73.  lastUpdate = millis();
  74.  pos += increment;
  75.  servo.write(pos);
  76.  Serial.println(pos);
  77.  if ((pos >= 180) || (pos <= 0)) // end of sweep
  78.  {
  79.  // reverse direction
  80.  increment = -increment;
  81.  }
  82.  }
  83.  }
  84. };
  85.  
  86.  
  87. Flasher led1(11, 123, 400);
  88. Flasher led2(12, 350, 350);
  89. Flasher led3(13, 200, 222);
  90. Sweeper sweeper1(15);
  91. Sweeper sweeper2(25);
  92.  
  93. void setup() 
  94. { 
  95.  Serial.begin(9600);
  96.  sweeper1.Attach(9);
  97.  sweeper2.Attach(10);
  98. } 
  99.  
  100.  
  101. void loop() 
  102. { 
  103.  sweeper1.Update();
  104.  sweeper2.Update();
  105.  
  106.  led1.Update();
  107.  led2.Update();
  108.  led3.Update();
  109. }

 

W tej chwili mamy 5 niezależnych zadań działających non-stop, bez zakłóceń. A nasza funkcja loop() posiada tylko 5 linijek kodu! 

Wszystko razem!

Chcemy też Twojego wejścia

Kolejnym problemem z taktowaniem bazującym na funkcji delay(), jest to, że wejście użytkownika, takie jak wciśnięcie przycisku, jest często ignorowane. Dzieje się tak dlatego, że procesor nie potrafi sprawdzić stanu przycisku kiedy jest w funkcji delay(). Z opóźnieniem na bazie funkcji millis(), procesor może regularnie sprawdzać stan przycisków i innych wejść. To pozwala nam zbudować złożone programy, które mogą robić wiele rzeczy na raz i nadal reagować.

 

Zademonstrujemy to dodając przycisk do naszego obwodu, tak jak na rysunku:

 

Wielozadaniowość Arduino - schemat podłączenia z przyciskiem

 

Poniższy kod sprawdzi stan przycisku na każdym przejściu pętli. Led1 i sweeper2 nie będą aktualizowane podczas wciśnięcia przycisku.

 

  1. #include 
  3. class Flasher
  4. {
  5.  // Class Member Variables
  6.  // These are initialized at startup
  7.  int ledPin; // the number of the LED pin
  8.  long OnTime; // milliseconds of on-time
  9.  long OffTime; // milliseconds of off-time
  10. // These maintain the current state
  11.  int ledState; // ledState used to set the LED
  12.  unsigned long previousMillis; // will store last time LED was updated
  13. // Constructor - creates a Flasher 
  14.  // and initializes the member variables and state
  15.  public:
  16.  Flasher(int pin, long on, long off)
  17.  {
  18.  ledPin = pin;
  19.  pinMode(ledPin, OUTPUT); 
  20.  
  21.  OnTime = on;
  22.  OffTime = off;
  23.  
  24.  ledState = LOW; 
  25.  previousMillis = 0;
  26.  }
  27. void Update()
  28.  {
  29.  // check to see if it's time to change the state of the LED
  30.  unsigned long currentMillis = millis();
  31.  
  32.  if((ledState == HIGH) && (currentMillis - previousMillis >= OnTime))
  33.  {
  34.  ledState = LOW; // Turn it off
  35.  previousMillis = currentMillis; // Remember the time
  36.  digitalWrite(ledPin, ledState); // Update the actual LED
  37.  }
  38.  else if ((ledState == LOW) && (currentMillis - previousMillis >= OffTime))
  39.  {
  40.  ledState = HIGH; // turn it on
  41.  previousMillis = currentMillis; // Remember the time
  42.  digitalWrite(ledPin, ledState); // Update the actual LED
  43.  }
  44.  }
  45. };
  46. class Sweeper
  47. {
  48.  Servo servo; // the servo
  49.  int pos; // current servo position 
  50.  int increment; // increment to move for each interval
  51.  int updateInterval; // interval between updates
  52.  unsigned long lastUpdate; // last update of position
  53. public: 
  54.  Sweeper(int interval)
  55.  {
  56.  updateInterval = interval;
  57.  increment = 1;
  58.  }
  59.  
  60.  void Attach(int pin)
  61.  {
  62.  servo.attach(pin);
  63.  }
  64.  
  65.  void Detach()
  66.  {
  67.  servo.detach();
  68.  }
  69.  
  70.  void Update()
  71.  {
  72.  if((millis() - lastUpdate) > updateInterval) // time to update
  73.  {
  74.  lastUpdate = millis();
  75.  pos += increment;
  76.  servo.write(pos);
  77.  Serial.println(pos);
  78.  if ((pos >= 180) || (pos <= 0)) // end of sweep
  79.  {
  80.  // reverse direction
  81.  increment = -increment;
  82.  }
  83.  }
  84.  }
  85. };
  86.  
  87.  
  88. Flasher led1(11, 123, 400);
  89. Flasher led2(12, 350, 350);
  90. Flasher led3(13, 200, 222);
  91. Sweeper sweeper1(15);
  92. Sweeper sweeper2(25);
  93.  
  94. void setup() 
  95. { 
  96.  Serial.begin(9600);
  97.  sweeper1.Attach(9);
  98.  sweeper2.Attach(10);
  99. } 
  100.  
  101.  
  102. void loop() 
  103. { 
  104.  sweeper1.Update();
  105.  
  106.  if(digitalRead(2) == HIGH)
  107.  {
  108.  sweeper2.Update();
  109.  led1.Update();
  110.  }
  111.  
  112.  led2.Update();
  113.  led3.Update();
  114. }

 

3 diody LED będą migać we własnym tempie. 2 sweepery też będą działać z własną szybkością. Ale po wciśnięciu przycisku, sweeper2 i led1 zostaną zatrzymane, dopóki nie zwolnimy przycisku. 

 

wielozadaniowość Arduino - działanie

 

Mamy teraz 5 zadań z wejściem użytkownika, działających niezależnie. Nie ma żadnych opóźnień, które zablokują procesor. A nasz wydajny kod programowania obiektowego pozostawia dużo miejsca na rozszerzenia!

 

Wnioski:

W tym przewodniku pokazaliśmy, że Arduino potrafi wykonywać wiele różnych zadań i nadal reagować na zewnętrzne zdarzenia. 

 

  • Nauczyliśmy się jak mierzyć czas za pomocą funkcji millis() zamiast delay(), co pozwoliło procesorowi robić inne rzeczy.
  • Dowiedzieliśmy się jak określać zadania jako automaty, które mogą działać w tym samym czasie co inne automaty, ale niezależnie od nich.
  • Odkryliśmy jak zawrzeć te automaty w klasach C++, aby kod pozostał prosty i zwięzły.

 

Techniki te nie zmienią Twojego Arduino w superkomputer. Jednakże, pomogą Ci wydobyć to co najlepsze z tego małego, ale zadziwiająco potężnego modułu.

W części drugiej, będziemy budować korzystając z tych technik. Odkryjemy też inne sposoby na to, aby Arduino reagowało na zewnętrzne zdarzenia utrzymując przy tym działanie wielu zadań.  

 

część druga ->

 

Źródło: https://learn.adafruit.com/multi-tasking-the-arduino-part-1

zapraszamy do współpracy!