Łączenie rejestrów przesuwnych oraz sterowanie serwomechanizmami.

Na ostatnim spotkaniu przed przerwą świąteczną rozwinęliśmy projekt rozpoczęty na poprzednich zajęciach tj. wyświetlanie cyfr przy pomocy wyświetlacza siedmiosegmentowego oraz rejestru przesuwnego. Główną korzyścią tej metody jest użycie jedynie trzech pinów cyfrowych Arduino. Okazuje się, że dołączenie drugiego wyświetlacza siedmiosegmentowego wymaga podłączenia drugiego rejestru przesuwnego, ale liczba pinów cyfrowych pozostaje taka sama !

Logika stosowania wielu rejestrów przesuwnych może być porównana do tworzenia jednego rejestru, który przedłużamy kolejnymi chipami 74HC595.

Podłączenie drugiego układu scalonego 74HC595 ogranicza się do podłączenia pinów RCLK oraz SRCLK do tych samych pinów arduino co odpowiadające RCLK oraz SRCLK piny pierwszego rejestru. Będzie to oznaczało, że nowy chip będzie on otrzymywał te same sygnały sterujące co pierwszy. Różnicą jest podłączenie pinu SER. Zamiast bezpośrednio do Arduino, podłączamy ten pin do wyjścia 9 naszego pierwszego rejestru przesuwnego. Dzięki temu całość będzie funkcjonowała jak jeden, przedłużony rejestr przesuwny.

 

Nasuwa się pytanie: jak zmodyfikować ostatnio napisany przez nas program tak, by poprawnie działał?
Odpowiedź jest prosta. Przygotowaliśmy się na to już na poprzednim spotkaniu i wystarczy wprowadzić nową wartość dla zmiennej ileScalakow (widocznej od razu w pierwszej linijce kodu), tak by równała się liczbie zastosowanych rejestrów, czyli 2:

Cały kod pozwalający sprawdzić działanie wyświetlaczy

#define ileScalakow 2
#define ilePinow ileScalakow * 8
int SER=8; 
int RCLK=9;
int SRCLK=10; 
int rejestr[ilePinow];

void setup(){
  pinMode(SER, OUTPUT);
  pinMode(RCLK, OUTPUT);
  pinMode(SRCLK, OUTPUT);
  czyscRejestr();
  zapiszRejestr();
}
void czyscRejestr(){
  for(int i=0; i<ilePinow; i++)
    rejestr[i]=LOW;
}
void zapiszRejestr(){
  digitalWrite(RCLK, LOW); 
  for(int i=ilePinow-1; i>=0; i--){
    digitalWrite(SRCLK, LOW);
    digitalWrite(SER, rejestr[i]);
    digitalWrite(SRCLK, HIGH); 
  }
  digitalWrite(RCLK, HIGH); 
}
void ustawPin(int ktory, int wartosc){
  rejestr[ktory]=wartosc;
}

void loop(){
  int i;
  for(i=0;i<ilePinow;i++)
    ustawPin(i, LOW);
    zapiszRejestr();
    delay(500);
   for(i=0;i<ilePinow;i++){
    ustawPin(i, HIGH);
    zapiszRejestr();
    delay(500);
}
}

Po tej prostej zmianie kod działa poprawnie. Jest to przykład jak odpowiednie wprowadzanie zmiennych pozwala na skalowalność i rozwijanie kreowanych programów.

Sterowanie serwomechanizmami

Serwomechanizm, lub potocznie serwo, to nic innego jak silniczek prądu stałego sterowany PWM (modulator szerokości impulsu) z podłączonym odpowiednim układem zębatek. To niewielkie i niedrogie urządzenie pozwala wygenerować niespodziewanie dużą siłę i moment obrotowy, szczególnie zważywszy na jego rozmiary i nieduży pobór mocy (przy mini serwach np. używanych przez nas SG92r produkcji TowerPro rzędu kilku watów).

Przed rozpoczęciem jakichkolwiek doświadczeń z serwami warto pamiętać właśnie o poborze mocy. Rekomendowane jest zasilanie ich z zewnętrznego źródła mocy np. baterii lub zasilacza prądu stałego. Przyczyną jest niebezpieczeństwo, jakie niesie za sobą skok natężenia prądu podczas ruchu serw – podłączenie kilku na raz do Arduino może niechybnie doprowadzić do spalenia sterownika.

Znalezione obrazy dla zapytania arduino servo batteries

Tworzenie programu sterującego serwami

Arduino posiada dedykowaną bibliotekę do sterowania serwami, co niezwykle ułatwia sterowanie i zarządzanie.

#include <Servo.h>

Nasz program pozwala na wpisywanie wartości do monitora szeregowego i dyktowanie ich serwomechanizmom.

Servo serwomechanizm;
int pozycja = 90;

void setup() 
{ 
 serwomechanizm.attach(9);
 Serial.begin(9600);
}

„Servo” jest formą deklaracji, że dany obiekt o nazwie „Serwmechanizm” ma być traktowany przez interpreter kodu jako serwomechanizm. Deklarujemy je w tej samej konwencji, co np. zmienne typu integer. Traktowanie go jak serwomechanizm oznacza, że możemy przypisać mu jakiś pin oraz pozycję (będą to odpowiednie zmienne w obiekcie Servo).

W naszym kodzie w etapie setup() przypisaliśmy pozycję wyjściową 90 stopni (2. linijka), pin 9 (7. linijka) oraz uruchomiliśmy monitor szeregowy dla częstotliwości 9600 baud. Następnie w loop() przy pomocy metody „parseInt” każemy „nasłuchiwać” wartości, które zostaną przypisane zmiennej „pozycja”.

void loop() 
{ 
 if (Serial.available() > 0) {
pozycja = Serial.parseInt();
 }
 if (pozycja > 0 && pozycja < 180) { 
 serwomechanizm.write(pozycja);
 } else { 
 pozycja = pozycja%160+10;
 serwomechanizm.write(pozycja);
 } 
 
}

Tym sposobem możemy sterować serwomechanizmem z klawiatury przypisując mu kąt od 0 do 180 stopni. Warto jednak pamiętać, by unikać skrajnych pozycji takich jak 0 i 180 stopni, gdyż w niektórych przypadkach może to doprowadzić do uszkodzenia serwomechanizmu.

Adnotacja: W bloku „else” umieściłem zabezpieczenie, które nie pozwoli również na przypisanie wartości większych niż 180. Była to nadprogramowa metoda, która pozwala ograniczyć przypisywane na serwo wartości tak, by zamykały się pomiędzy bezpiecznymi kątami 10 – 170 stopni. Sposoby zabezpieczania zależą od nas, jednak nie warto ich zaniedbywać. Szkoda naszego sprzętu i nerwów!

 

Pomiar prądu płynącego przez serwo.

Na bardziej ciekawych czekała również możliwość pomiaru prądu płynącego przez serwo. Warto pamiętać, że pomiar natężenia prądu należy przeprowadzać szeregowo względem badanego układu. Oznacza to, że multimetr w trybie pomiaru prądu musi być „po drodze” prądu między źródłem zasilania, a serwem. Dlatego zrobiliśmy to w następujący sposób:

Źródło napięcia (bez obaw, 5V i prąd zdecydowanie poniżej 1 A można swobodnie „izolować” suchymi dłońmi) dołączyliśmy do czerwonej sondy multimetru, a czarną do wejścia 5V serwa – jest to właśnie połączenie szeregowe.

Przy okazji mogliśmy zbadać wartość prądu pobieraną przez pracujące serwo. Wartości te na ogół wynosiły kilkadziesiąt mA, ale czasami (w skarajnym położeniu a także podczas zmiany położenia) wynosiły 100-200 mA. Oznacza to, że podłączenie kilku serw do Arduino jako źródła napięcia (a nie tylko do zadawania sygnału) skończyłoby się spaleniem płytki. Dlatego budując bardziej złożone układy z pewnością użyjemy zewnętrznych źródeł napięcia.

Do zobaczenia na kolejnym spotkaniu!
Maciej (c)

Rejestr przesuwny 74HC595

Na ostatnich zajęciach nadal zajmowaliśmy się programowaniem wyświetlaczy siedmiosegmentowych. W przypadku podłączania wyświetlacza bezpośrednio do Arduino, zajmujemy aż osiem pinów cyfrowych. To sprawia, że płytka Arduino UNO (wyposażona w 14 wejść/wyjść cyfrowych) może sterować tylko jednym wyświetlaczem. Można co prawda wykorzystać piny analogowe (A0..A5) jako cyfrowe, ale to da możliwość podłączenia jedynie drugiego wyświetlacza. To mało. Jest jednak sposób, aby sterować wieloma wyświetlaczami bez straty wszystkich pinów cyfrowych. Umożliwia nam to rejestr przesuwny 74HC595. Dzięki temu małemu układowi scalonemu mamy możliwość sterowania osmioma wyjściami za pomocą jedynie trzech pinów cyfrowych z Arduino. Bardziej szczegółowe informacje o tym układzie znajdują się w jego specyfikacji technicznej (ang. datasheet).

Podłączanie rejestru przesuwnego

Rejestr przesuwny podłączamy używając schematu pokazanego poniżej. Należy zwrócić uwagę na wyżłobienie po jednej stronie układu, które oznacza górną część.

Wyjście 8 (GND) podłączamy standardowo do pinu o tej samej nazwie na Arduino. Układ wymaga zasilania (to oczywiste) – które podłączamy do pinu 16 (VCC). Rejstr akceptuje zasilanie z przedziału od 2 do 6V – dlatego pin 16 śmiało łączymy z pinem 5V w Arduino UNO. Dodatkowo wyjścia 10 i 16 rejestru łączymy ze sobą (10 to pin odpowiedzialny za czyszczenie stanów rejestru – my to będziemy robić „ręcznie”, więc ustawiamy go w stan wysoki). Kluczowe są wyjście 14, 12 i 11 rejestru, które sterują jego pracą – łączymy je z wybranymi pinami cyfrowymi Arduino (ja wybrałam piny 8,9 i 10 na mojej płytce Arduino). Osiem wyjść rejestru (QA..QH, czyli piny 15, 1..7) podłączamy do kolejnych ledów na wyświetlaczu według tego schematu:

Oczywiście aby układ działał prawidłowo, do wyświetlacza siedmiosegmentowego również należy podłączyć zasilanie i odpowiedni rezystor (poprzednie zajęcia).

Opis pinów i sposób działania rejestru

Do pinów cyfrowych Arduino podłączamy trzy wyjścia rejestru. Są one kluczowe we wzajemnej komunikacji.

  • Pin 11 SRCLK to pin przesuwający wszystkie osiem stanów rejestru – przesuwanie odbywa się zawsze do przodu. Praca rejestru polega właśnie na cyklicznym przesuwania swoich stanów. Aby wykonać przesunięcie ustawiamy SRCLK w stanie LOW, a potem w stanie HIGH – ta sekwencja to komenda „przesuń stany rejestru”.
  • Pin 14 SER to pin ustawiający pierwszy rejest w stanie wysokim (gdy SER= HIGH) lub niskim (gdy SER=LOW).
  • Pin 12 RCLK (latch pin) – ustawienie go w stan niski (LOW) powoduje zablokowanie wyjść rejestru QA..QH, przez co nie widać zmian na tych pinach a tym samym nie widać etapów przejściowych przesuwania (które są wymagane do uzyskania końcowej konfigurajci ośmiu pinów). Ustawienie go w stan wysoki (HIGH) powoduje aktywację pinów QA..QH i to, co jest do nich podłączone – działa tak, jak chcieliśmy. 

Rejestr przesuwny działa w taki sposób, że ustawia (bądź pozostawia je w stanie zerowym) pierwsze wyjście (SER), po czym stan wszystkich wejść przesuwa o jedno miejsce do przodu (SRCLK). Następnie powtarza te czynności tyle razy ile tego zarządamy, aż osiągniemy oczekiwany ciąg zer i jedynek.  Wynika z tego, że zapisując docelową konfigurację wyjść QA..QH w tablicy (gdzie na pierwszym miejscu tablicy powinien znajdować się pierwszy led itd) to odczyt takiej tablicy (i związane z tym ustawianie pinu SER) powinien odbywać się „od tyłu” – aby po ośmiu przesunięciach osiągnąć naszą konfigurację.

Kod programu

Na początku programu definiujemy dwie stałe (dyrektywy #define). Pierwsza stała oznacza liczbę  rejestrów przesuwnych (u nas na razie 1), natomiast druga całkowitą liczbę pinów podłączonych do wyświetlaczy ledowych (liczbę ileScalaków mnożymy razy osiem, ponieważ każdy wyświetlacz ma osiem ledów). Następnie deklarujemy trzy piny cyfrowe łączące Arduino z rejestrem. Należy zwrócić na to uwagę, gdyż w przypadku nieprawidłowego podłączenia, nasz program może zachowywać się nieprzewidywalnie, bądź nie działać. Tablica rejestr odnosi się do wcześniejszej stałej ilePinow, czyli oznacza całkowitą liczbę pinów, którymi będziemy sterować.

#define ileScalakow 1
#define ilePinow ileScalakow * 8
int SER=8; 
int RCLK=9;
int SRCLK=10; 
int rejestr[ilePinow];

Funkcja void czyscRejestr() pozwala na wyczyszczenie tablicy rejestr, aby umożliwić jej ponowne zapełnienie. Robimy to używając pętli for, ustawiając kolejno każdą wartość na zqero (LOW).

Funkcja void zapiszRejestr() to główna funkcja programująca rejest przesuwny – ustawia piny QA..QH w takich stanach, jakie ma tablica rejestr w pamięci Arduino. Ustawienie pinu RCLK na pozycję LOW zamraża stany QA..QH – nie widać przełączania (=przesuwania) stanów rejestru. Pętlę for wykonujemy od końca, od liczby pinów odejmujemy 1, ze względu na numerowanie tablic od 0. Dzięki włączeniu pinu RCLK w stan HIGH zobaczymy dokonane zmiany.

W funkcji void ustawPin(int ktory, int wartosc) zmieniamy tablicę rejestr na pozycji ktory, nadającj jej wartość. Można się jej pozbyć – programując bezpośrednio tablicę rejestr – ale funkcja ta powstała aby ćwiczyć programowanie strukturalne.

void setup(){
  pinMode(SER, OUTPUT);
  pinMode(RCLK, OUTPUT);
  pinMode(SRCLK, OUTPUT);
  czyscRejestr();
  zapiszRejestr();
}
void czyscRejestr(){
  for(int i=0; i<ilePinow; i++)
    rejestr[i]=LOW;
}
void zapiszRejestr(){
  digitalWrite(RCLK, LOW); 
  for(int i=ilePinow-1; i>=0; i--){
    digitalWrite(SRCLK, LOW);
    digitalWrite(SER, rejestr[i]);
    digitalWrite(SRCLK, HIGH); 
  }
  digitalWrite(RCLK, HIGH); 
}
void ustawPin(int ktory, int wartosc){
  rejestr[ktory]=wartosc;
}

W funkcji głównej void loop() tworzymy pętlę, która najpierw ustawi wszystkie piny w pozycję low, abyśmy mogli zobaczyć przyszłe zmiany. Program ten najpierw zapali wszystkie ledy, poczeka pół sekundy, po czym po kolei je zgasi i ponownie zapali po półsekundowej przerwie.

void loop(){
  int i;
  for(i=0;i<ilePinow;i++)
    ustawPin(i, LOW);
    zapiszRejestr();
    delay(500);
   for(i=0;i<ilePinow;i++){
    ustawPin(i, HIGH);
    zapiszRejestr();
    delay(500);
}
}

Nie jest to program wyświetlający cyferki 0,1,2,…9 a jedynie program testujący działanie ośmiu wyjść QA..QH rejestru – naszą pracą domową jest zamiana powyższego kodu aby wyświetlała cyferki.

Podsumowanie

W tym tygodniu poznaliśmy prosty sposób na sterowanie wyświetlaczem siedmiosegmentowym za pomocą jedynie trzech pinów cyfrowych. Stwarza to duże możliwości, ponieważ rejestry przesuwne można ze sobą łączyć – a ciągle do ich sterowania będą potrzebne tylko 3 piny cyfrowe  z Arduino! Ale o tym za tydzień.

Praca domowa

Wykorzystując powyższy kod, wyświetlić cyfry na wyświetlaczu.

(c) Ewelina, 2017

 

Sterowanie wyświetlaczem siedmiosegmentowym. Programowanie strukturalne.

Wyświetlacze siedmiosegmentowe (sevseg).

Na dzisiejszym spotkaniu poznaliśmy jedno z wielu praktycznych zastosowań LEDów. Siedmiosegmentowe wyświetlacze są układami diod emitujących światło w odpowiednim ustawieniu umożliwiającym wyświetlanie cyfr. Wyświetlacze te, nazywane sevseg (ang. seven sevseg

segment display) są wszechobecne w świecie elektroniki i służą reprezentowaniu danych w przystępny (i niedrogi) sposób. Tego typu wyświetlacz może zastąpić droższe ekrany (np. LCD) w przypadku gdy chcemy zobaczyć tylko wartości liczbowe.

Anoda czy katoda?

Najprostsze układy wyświetlaczy siedmiosegmentowych opierają się na wspólnej katodzie lub wspólnej anodzie, co oznacza (w przypadku wspólnej anody), że z aż 10 pinów dwa środkowe będą otrzymywały napięcie, a 8 pozostałych – uziemienia lub na odwrót (w przypadku wspólnej katody).

My pracowaliśmy na wyświetlaczu ze wspólną anodą. Każdy pin pozwala na przepływ prądu przez inny segment (LED) na obszarze wyświetlania. Segmenty mają swoje oznaczenia od a do g (oraz kropka dziesiętna DP – decimal point).
 

Sterowanie wyświetlaczem przy pomocy arduino

Po podłączeniu 8 pinów wyświetlacza do pinów cyfrowych Arduino oraz doprowadzeniu z Arduino zasilania (dodając po drodze opornik) przyszedł czas na programowanie.

Przed dowolnym programem należało przypisać odpowiednie piny w programie.

int start=6;
int end=13;
int i;

„Start” oznacza pierwszy z użytych pinów Arduino, „end” – ostatni. Zmienna „i” jest pomocniczym licznikiem do tablic.

Na próbę stworzyliśmy prosty program pozwalający zapalić wszystkie segmenty wyświetlacza, co pozwoliło przetestować prawidłowe podłączenie wyświetlacza.

void setup(){
  for(i=start;i<=end;i++){
      pinMode(i,OUTPUT);
      digitalWrite(i,1); //0=LOW, 1=HIGH
  }
}

void loop(){
  for(i=start;i<=end;i++)
      digitalWrite(i,1);
  delay(500);
  for(i=start;i<=end;i++)
      digitalWrite(i,0);
  delay(500);
}

W pętlach for widocznych w bloku funkcji void loop() możemy zobaczyć przypisanie stanów wysokich i niskich każdemu z pinów podłączonych do wyświetlacza. Ze względu na to, że jest to wyświetlacz o wspólnej anodzie, to stan niski powoduje zapalenie się lampek, gdyż następuje wtedy przepływ prądu.

Wyświetlanie cyfr

Następnie rozpoczęliśmy tworzenie programu wyświetlającego konkretne cyfry. Stworzyliśmy prosty program w którym wprowadziliśmy własne funkcje – wyświetlające jedynkę (funkcja void jedynka()) , dwójkę (void dwojka()) oraz „czyszczące” wyświetlacz (funkcja void nic()). Budowanie takich funkcji ma ogromny sens – będą to nasz „cegiełki”, które wielokrotnie można później używać – patrz główna funkcja loop() w Arduino. 

int i;
int ledA =8;
int ledB = 9;
int ledC = 11;
int ledD = 12;
int ledE = 13;
int ledF = 7;
int ledG = 6;
int ledDP = 10;
// Kolejność podpięcia diod a - g,DP to właśnie 8,9,11,12,13,7,6,10
void setup(){
  pinMode(ledA,OUTPUT);
  pinMode(ledB,OUTPUT);
  pinMode(ledC,OUTPUT);
  pinMode(ledD,OUTPUT);
  pinMode(ledE,OUTPUT);
  pinMode(ledF,OUTPUT);
  pinMode(ledG,OUTPUT);
  pinMode(ledDP,OUTPUT);
  digitalWrite(ledDP,1);
  nic();
}

void loop(){
  jedynka();
  delay (500);
  dwojka();
  delay (500);
  dwojka();
  delay (500);
  jedynka();
  delay (500);
  nic();
  delay (500);
}

void nic(){
  digitalWrite(ledA,1);
  digitalWrite(ledB,1);
  digitalWrite(ledC,1);
  digitalWrite(ledD,1);
  digitalWrite(ledE,1);
  digitalWrite(ledF,1);
  digitalWrite(ledG,1);
}//nic

void jedynka(){
  digitalWrite(ledA,1);
  digitalWrite(ledB,0);
  digitalWrite(ledC,0);
  digitalWrite(ledD,1);
  digitalWrite(ledE,1);
  digitalWrite(ledF,1);
  digitalWrite(ledG,1);
}//jedynka

void dwojka(){
  digitalWrite(ledA,0);
  digitalWrite(ledB,0);
  digitalWrite(ledC,1);
  digitalWrite(ledD,0);
  digitalWrite(ledE,0);
  digitalWrite(ledF,1);
  digitalWrite(ledG,0);
}//dwojka

W naszym kodzie, są również widoczne zmienne „ledA”, „ledB” itd (linijki 2 – 9), które były tworzone właśnie w nawiązaniu do nazewnictwa widocznym na rysunkach pokazującym budowę wyświetlacza (widocznym na samym początku wpisu). Warto zauważyć, że opłaca się używać nazw zmiennych mających jakieś konkretne znaczenie – tutaj wybraliśmy nazewnictwo zaczerpnięte z budowy sevseg-a. 

Łatwo zauważyć, że powyższy kod jest bardzo powtarzalny i wizualnie zajmuje sporo miejsca, przez co jest też mniej czytelny i nieprofesjonalny. W/w program jest przykładem programowania strukturalnego, czyli hierarchicznego podziału programu na odpowiednie procedury i bloki kodu. Widoczne są utworzone funkcje „nic()”, „jedynka()” i „dwojka()”. Analogicznie należy tworzyć kolejne funkcje generujące kolejne cyfry i wywoływać je w void loop().

Oczywiście na tym nie poprzestaliśmy.

Program z tablicami

Jak widać każda funkcja kolejno zapala odpowiednie segmenty wyświetlacza. Jest to robione „ręcznie”, tj za każdym razem musieliśmy przypisywać każdemu pinowi stan wysoki i niski. Znacznie bardziej optymalną metodą było stworzenie dwuwymiarowej tablicy. Każdy 8-elementowy wiersz tablicy odpowiadał przypisaniu odpowiedniego stanu logicznego danemu segmentowi (jest ich osiem, gdyż poza 7 segmentami jest również 'kropka dziesiętna' – decimal point). Ten proces pozwolił nam porzucić metodę nazywania każdej diody po kolei (tj. „ledA”, „ledB”…). Na potrzeby tej metody należało dodać tablicę kontrolną z numerami pinów do których podłączone są piny wyświetlacza (linijka 2).

int i;
int led[8]={8,9,11,12,13,7,6,10};
int digits[5][8]={ //na razie definiuje tylko 5 cyfr
// A B C D E F G DP
  {0,0,0,0,0,0,1,0}, //zero
  {1,0,0,1,1,1,1,0}, //wyswietla 1
  {0,0,1,0,0,1,0,0}, //wyswietla 2
  {0,0,0,0,1,1,0,0}, //wyswietla 3
  {1,0,0,1,1,0,0,0}
  }; //...
   //macierz, 4 tablice, kazda z osmioma elementami

void loop(){
  jedynka();
  delay (500);
  dwojka();
  delay (500);
  trojka();
  delay (500);
  czworka();
  delay (500);
  nic();
  delay (500);
}

  void nic(){
    for(i=0;i<8;i++)
      digitalWrite(led[i],digits[0][i]);
  }//nic

  void jedynka(){
    for(i=0;i<8;i++)
      digitalWrite(led[i],digits[1][i]);
  }//jedynka
  
  void dwojka(){
    for(i=0;i<8;i++)
      digitalWrite(led[i],digits[2][i]);
  }//dwojka

Teraz pozostało jedynie przewidzieć który segment ma dostać stan wysoki albo niski, by całość reprezentowała daną liczbę. Kolejne liczby były reprezentowane przez kolejne wiersze w tablicy dwuwymiarowej.

By zrozumieć działanie tej tablicy należy przyjrzeć się działaniu funkcji wywołujących kolejne liczby. Dla przykładu: „jedynka()” zamiast odwoływać się bezpośrednio do każdego pinu przez zmienne ledA, ledB, ledC… (poprzednio), zastąpiliśmy to teraz pętlą „for” przypisującą kolejne stany logiczne (zera lub jedynki) z wiersza tablicy. Każda kolumna tej tablicy odpowiada kolejnej diodzie w wyświetlaczu, czyli w pierwsza kolumna to (poprzednio) ledA (0=świeci, 1=nie świeci), druga to (poprzednio) ledB (0=świeci, 1=nie swieci) itd.

Jeśli wywołujemy jedynkę, pętla „bierze” drugi wiersz w tablicy „digits[]” (uwaga: indeksowanie od zera, więc indeks wiersza=1) i przypisuje diodzie „A” stan wysoki (obszar A nie zaświeci się), diodzie „B” stan niski (dioda zaświeci się). Rysowanie cyfry dwa to branie wiersza numer trzy (indeks wiersza tablicy=2) itd.

Ta operacja zarówno skraca kod, jak i zwiększa jego czytelność i wygodę dodawania kolejnych wyświetlanych liczb lub znaków.

Program wciąż można było ulepszyć.

Ostateczna wersja programu

Optymalizacja kodu dotyczy wywoływania liczb – mamy wiele podobnych funkcji (jedynka(), dwojka() itd). Zamiast tworzyć kolejne funkcje stworzyliśmy jedną funkcję void cyfra(int n), które wywoływały z tablicy dwuwymiarowej kolejne wiersze, czyli kolejne cyfry.

int i;
int led[8]={8,9,11,12,13,7,6,10};
int digits[5][8]={
// A B C D E F G DP
  {0,0,0,0,0,0,1,0}, //zero
  {1,0,0,1,1,1,1,0}, //swieci 1
  {0,0,1,0,0,1,0,0}, //swieci 2
  {0,0,0,0,1,1,0,0}, //swieci 3
  {1,0,0,1,1,0,0,0}
  }; //...
   //macierz, 4 tablice, kazda z osmioma elementami

void setup(){
    for(i=0;i<8;i++)
      pinMode(led[i],OUTPUT);
}

void cyfra(int nr){
  for(i=0;i<8;i++)
    digitalWrite(led[i],digits[nr][i]);
}

void loop(){
  cyfra(1);
  delay (500);
  cyfra(2);
  delay (500);
  cyfra(3);
  delay (500);
  cyfra(4);
  delay (500);
 }

Dodawanie kolejnych liczb stało się niezwykle proste i przejrzyste. Program sprawia wrażenie bardziej profesjonalnego i czytelnego. Uproszczone jest także wyświetlanie. Wystarczy rozszerzyć tablicę o kolejny wiersz i dopisać odpowiednie stany logiczne kolejnym segmentom wyświetlacza.

Podsumowanie

W tym tygodniu poznaliśmy czym jest wyświetlacz 7-segmentowy i w jaki sposób funkcjonuje, odkryliśmy kolejne zastosowania tablic oraz że tablica może być również macierzą, tj. mieć więcej niż jeden wymiar. Ostatecznie zastosowaliśmy metody programowania strukturalnego, które jest obok programowania obiektowego, jedną z najszerzej stosowanych metod w świecie programowania.

Praca domowa

Wykorzystać powyższy kod (np. w wirtualnym arduino) i rozbudować o wczytywanie cyfr z klawiatury (komunikacja szeregowa), czym bawiliśmy się poprzednio.

Do zobaczenia w przyszłym tygodniu!
(c) Maciej 2017