Ta strona używa ciasteczek (plików cookies), dzięki którym może działać lepiej. Dowiedz się więcejRozumiem i akceptuję

Kurs Arduino II – #6 – wyświetlacze 7-segmentowe

Programowanie 01.02.2017 Damian (Treker)

ArdIkoKurs2_6Najczęściej w projektach bazujących na Arduino używane są wyświetlacze tekstowe, stosunkowo rzadko pojawiają się LCD graficzne.

Zaskakująco dużo osób zapomina o trzeciej opcji, czyli o wyświetlaczach 7-segmentowych. Za ich pomocą możliwe jest prezentowanie stosunkowo prostych informacji. Na pewno każdy kojarzy je z zegarów cyfrowych lub multimetrów.

Nawigacja serii artykułów:
« poprzednia częśćnastępna część »

Kup zestaw elementów i zacznij naukę w praktyce! Przejdź do strony dystrybutora »

Większość wyświetlaczy, z którymi się spotykamy, składa się z pikseli, czyli małych, świecących punktów. To właśnie z nich formowane są teksty/grafiki. W przypadku omawianych tu wyświetlaczy 7-segmentowych jest zupełnie inaczej – one zbudowane są z 7 dużych „punktów”.

Każdy z nich jest diodą świecącą zbliżoną kształtem do prostokąta. Segmenty przyjęto oznaczać literami: a, b, c, d, e, f, g – ich rozmieszczenie jest zawsze identyczne, zgodne z poniższym:

Opis segmentów wyświetlacza.

Wyświetlenie określonego znaku polega na zaświeceniu odpowiednich segmentów. Przykładowo cyfra 1 wymaga załączenia segmentów B i C, a cyfra 2 segmentów A, B, D, E, G itd.

Niektóre wyświetlacze maja dodatkowo osobne „ósme segmenty” oznaczone jako P. Są to kropki, które mogą przydać się podczas wyświetlania wartości niecałkowitych. Mogą również być użyte w zupełnie innej roli – wszystko zależy od pomysłu konstruktora. Element ten można traktować jako osobną diodę świecącą. Nie jest to kluczowa funkcja takiego wyświetlacza.

Czasami, mimo fizycznej obecności kropki na froncie wyświetlacza zdarza się,
że wcale nie ma tam diody i nie możemy nią sterować.

Konfiguracje wyświetlaczy 7-segmentowych

W sprzedaży znaleźć można wyświetlacze w przeróżnych konfiguracjach. Po pierwsze, mogą one mieć różne rozmiary i kolory. Po drugie, najczęściej w obudowie znajdziemy jeden wyświetlacz, ale są oczywiście produkowane również wersje, które mogą prezentować kilka cyfr obok siebie.

Przykłady różnych wyświetlaczy 7-segmentowych.

Sposób rozmieszczenia wyprowadzeń z obudowy może być w każdym przypadku inny, dlatego zawsze warto wspierać się notą katalogową wyświetlacza. Oczywiście można też starać się samodzielnie zidentyfikować wszystkie wyprowadzenia, ale zajmie to więcej czasu.

Wspólna katoda/anoda

Tak samo jak w przypadku diod RGB, tak również tutaj dla zaoszczędzenia miejsca wewnątrz tych wyświetlaczy producenci łączą katody/anody poszczególnych segmentów. W praktyce oznacza to, że wewnątrz obudowy znajdziemy jeden z poniższych wariantów:

Mówiąc najprościej: w jednej konfiguracji połączone są wszystkie „minusy” diod, wtedy segment zaświeci się po podaniu „plusa” na jego wejście. Natomiast w drugiej konfiguracji połączone są „plusy”, więc segmenty zaczynają świecić, po podaniu na wejście „minusa”.

Koniec jednak teoretyzowania, pora przejść do praktyki…

Zestaw elementów do przeprowadzenia wszystkich ćwiczeń

Gwarancja pomocy na forum dla osób, które kupią poniższy zestaw!

Części pozwalające wykonać ćwiczenia z kursu Arduino (poziom 2) dostępne są w formie gotowych zestawów! W komplecie m.in. diody programowalne, termometry analogowe i cyfrowe, czujnik ruchu (PIR), wyświetlacze 7-segmentowe oraz znacznie więcej!


Kup w Botlandzie »

Wyświetlacz LDD040AUE-101A

W zestawach elementów do tego kursu znajduje się podwójny wyświetlacz ze wspólną katodą. Symbol producenta, to: LDD040AUE-101A. Teraz potrzebny jest rzut oka do noty katalogowej, aby znaleźć opis wyprowadzeń:

Opis wyprowadzeń użytego wyświetlacza.

Jak widać struktury wewnątrz wyświetlacza są kompletnie niezależne – na dobrą sprawę mamy tu dwa osobne wyświetlacze w jednej obudowie. Warto przy okazji zauważyć, że nie ma tutaj żadnej informacji na temat pinów sterujących wyprowadzeniem P (kropka). Tak jak wspomniałem wcześniej, zdarza się, że punkt ten nie jest aktywny – tak będzie w tym przypadku.

Uwaga! Mam nadzieję, że na tym etapie kursu jest jasne, że diody trzeba zasilać przez rezystory. Tutaj jest to jeszcze ważniejsze diody umieszczone wewnątrz wyświetlacza przepalają się jeszcze łatwiej od zwykłych LEDów!

Pozostaje rozwiązanie zagadki, jak numerowane są wyprowadzenia. Tutaj będzie łatwo, ponieważ odpowiednie numerki (1 i 16) producent umieścił na odwrocie wyświetlacza:

Opis numeracji wyprowadzeń wyświetlacza.

Podłączmy teraz pierwszy z dwóch wyświetlaczy do Arduino. Tutaj mam złą wiadomość. Ładne podłączenie całego układu z tej części kursu będzie trudne. Można to oczywiście zrobić szybciej, w bardziej chaotyczny sposób. W moich rozwiązaniach starałem się zrobić to jednak dość ładnie..

Podłączenie wyświetlacza do Arduino

Interesuje nas pierwszy wyświetlacz, czyli segmenty podłączone do nóżek 1, 2, 3, 13, 14, 15, 16. Oczywiście do każdego z wyprowadzeń koniecznie musimy podłączyć rezystory i od tego warto zacząć. Diody w wyświetlaczu są jasne, więc spokojnie sprawdzi się tutaj rezystor 1k.

Zaczynamy więc od podłączenia rezystorów do każdego segmentu wyświetlacza nr 1. Zależy nam, aby później można było połączyć każdy rezystor przewodem z Arduino. U mnie wyglądało to tak:

W związku z tym, że płytka jest wąska (każdy sygnał ma tylko 5 wspólnych pinów) dla ładnego rozłożenia rezystorów musiałem również wykorzystać miejsce, które jest pod wyświetlaczem. Właśnie tą drogą poprowadziłem rezystor do nóżki nr 13 (segment B):

Kolejny krok jest prosty, łączymy każdy rezystor przewodem z Arduino UNO. Kolejność może być dowolna, ja przyjąłem następującą:

  • wyprowadzenie nr 1 (segment C), do pinu Arduino nr 2,
  • wyprowadzenie nr 2 (segment E), do pinu Arduino nr 3,
  • wyprowadzenie nr 3 (segment D), do pinu Arduino nr 4,
  • wyprowadzenie nr 13 (segment B), do pinu Arduino nr 5,
  • wyprowadzenie nr 14 (segment G), do pinu Arduino nr 6,
  • wyprowadzenie nr 15 (segment A), do pinu Arduino nr 7,
  • wyprowadzenie nr 16 (segment F), do pinu Arduino nr 8.

Na sam koniec pozostaje podłączyć masę do czwartego wyprowadzenia Arduino. Na poniższym zdjęciu widać, że zrobiłem to niebieskim przewodem oraz kawałkaiemodciętej nóżki rezystora.

Podłączenie masy do wyświetlacza.

Teraz można przejść do programu, który jest trywialny, po prostu sterujemy 7 diodami… Poniższy przykład powinien uruchamiać po kolei każdy z segmentów (od A do F). 

Oczywiście wszystko można napisać krócej, szybciej i lepiej. Skupiłem się jednak na tym, aby cały program był czytelny i prosty. Wszystkie segmenty działają poprawnie, gdy efekt jest następujący:

Test poszczególnych segmentów (animacja jest zapętlona, w praktyce na końcu wszystkie elementy będą się świecić cały czas).

Wyświetlanie pojedynczych cyfr

Na razie (!) sytuacja jest jeszcze prosta, więc bardzo łatwo możemy napisać własną funkcję, która jako argument będzie przyjmowała cyfrę, którą następnie ustawi na wyświetlaczu. Idealna będzie tutaj instrukcja switch opisana w 6. części pierwszego kursu Arduino.

Nasza funkcja może wyglądać następująco:

Włączanie i wyłączanie poszczególnych elementów rozpisałem na podstawie rozmieszczenia segmentów. Oczywiście każdy może wprowadzić swoje zmiany, aby dostosować „czcionkę”. Wystarczy mieć przed sobą poniższą rozpiskę:

Opis segmentów wyświetlacza.

Przykładowo cyfrę „1” można również wyświetlać na segmentach F oraz E.

Licznik na wyświetlaczu 7-segmentowym

Pora sprawdzić, czy napisana funkcja wyświetla kolejne cyfry. Poniższy program testowy składa się z pętli for (działającej w zakresie 0 – 9), która wywołuje kolejne cyfry:

Poprawne działanie programu widoczne jest na poniższej animacji:

Efekt działania licznika.

Zadanie dodatkowe 6.1

Rozbuduj funkcję wyswietlacz(), tak aby potrafiła wyświetlić informację o przekroczeniu zakresu. Jeśli na wejściu podamy wartość większą od 9, to naszym oczom powinien ukazać się symbol błędu składający się z zapalonych segmentów A, G, D.

W komentarzach jako rozwiązanie umieszczajcie
kody oraz zdjęcie działającego układu!

Zadanie dodatkowe 6.2

Do układu dodaj przyciski, które pozwolą zbudować licznik:

  • S1 – zwiększenie cyfry pokazywanej na wyświetlaczu o 1,
  • S2 – zmniejszenie cyfry pokazywanej na wyświetlaczu o 1,
  • S3 – zerowanie układu.

W komentarzach jako rozwiązania umieszczajcie swój kod oraz film z działania układu!

Wykorzystanie drugiego wyświetlacza

Teraz zrobi się trudniej... Przynajmniej od strony połączeń. Uruchomimy teraz drugi wyświetlacz. Najwygodniej byłoby go podłączyć do kolejnych 7 pinów w Arduino, jednak wtedy nie mielibyśmy już prawie żadnych wolnych wyprowadzeń.

Co gorsze, podłączenie większej ilości wyświetlaczy (np. 3) nigdy
nie byłoby możliwe. Na szczęście można zrobić to trochę sprytniej!

Na początku połączmy ze sobą segmenty obu wyświetlaczy. Dzięki temu korzystając z 7 pinów będziemy pokazywać wartości na obu wyświetlaczach jednocześnie – na razie będzie to taka sama cyfra. Wyświetlaniem różnych wartości zajmiemy się trochę później.

Czyli dążymy teraz do takiej sytuacji:

Uruchomienie drugiego wyświetlacza.

Połączenie segmentów obu wyświetlaczy można zrobić „ładnie” korzystając z nóżek odciętych od rezystorów. Jednak wymaga to pewnego ryzykownego rozwiązania. W związku z ograniczoną ilością miejsca będziemy umieszczać po 2 druciki w jednej dziurce płytki stykowej.

Rozwiązanie to jest ryzykowne i raczej nie należy go często stosować, bo może powodować ciężkie do zdiagnozowania usterki. Jednak przy tak prostym układzie, możemy zaryzykować.

Dla przypomnienia raz jeszcze rozpiska wyprowadzeń:

Opis wyprowadzeń użytego wyświetlacza.

Zaczynamy od segmentów C, D oraz E. Musimy więc połączyć wyprowadzenia w takiej kolejności:

  • 1 > 8
  • 2 > 7
  • 3 > 6

Można to zrobić następująco:

Połączenie segmentów dwóch wyświetlaczy.

Oczywiście, aby to połączenie było możliwe koniecznie trzeba odpiąć drucik, który doprowadzał masę do pierwszego wyświetlacza. Teraz masy wyprowadzimy na boki (w lewo od pierwszego, a w prawo od drugiego):

Wyprowadzenia wspólnych katod (mas) wyświetlaczy.

Kolejny krok, to połączenia pozostałych segmentów, czyli łączymy wyprowadzenia:

  • 13 > 12
  • 14 > 11
  • 15 > 10
  • 16 > 9

U mnie całość udało się złożyć w następujący sposób:

Oczywiście na koniec koniecznie trzeba dołożyć brakujące połączenia z masą. Na razie wystarczy proste połączenie przewodami. Na poniższym zdjęciu zawinąłem je w pętelki, aby było czytelniej:

Wyświetlanie tych samych wartości na wyświetlaczach.

Działanie wyświetlaczy jest sprawdzone, więc pora iść krok dalej. Podwójne wyświetlanie tej samej wartości raczej nam się nigdy nie przyda…

Multipleksowanie wyświetlaczy

Rozwiązaniem problemu jest multipleksowanie. Jeśli będziemy na zmianę włączać i wyłączać każdy z wyświetlaczy, to przy szybkiej zmianie wyświetlanej wartości będziemy mogli pokazywać na każdym wyświetlaczu inną cyfrę (takie będzie złudzenie dzięki bezwładności naszego wzroku)! Oczywiście nie będziemy odłączać katod od masy ręcznie. Wykorzystamy Arduino!

Przy włączeniu wszystkich segmentów cały wyświetlacz może pobrać
„z katody” ponad 20 mA, więc nie powinniśmy podłączać jej bezpośrednio do Arduino!

Sterowanie wyświetlaczami przez tranzystory

Dla bezpieczeństwa, Arduino będzie sterowało wspólnymi katodami przez tranzystory typu NPN. W zestawie elementów znajdują się tranzystory BC547, które sprawdzą się tu idealnie.

Mam nadzieję, że każdy już opanował tranzystory w praktyce.
Jeśli nie, to odsyłam do odpowiedniego odcinka kursu podstaw elektroniki!

Podłączenie będzie następujące:

  • Kolektory tranzystorów łączymy bezpośrednio z katodami wyświetlaczy. Czyli kolektor pierwszego tranzystora łączymy z nóżką nr 4 wyświetlacza, a kolektor drugiego BC546 łączymy z nóżką nr 5.
  • Bazy tranzystorów łączymy przez rezystor 10k z pinami Arduino. Bazę pierwszego tranzystora łączymy z pinem Arduino nr 10, a drugiego z pinem nr 9.
  • Emitery obu tranzystorów łączymy z masą.

Powyższe połączenie można zrealizować w następujący sposób:

Od teraz podanie stanu wysokiego na piny Arduino nr 9 lub 10
uruchomi jeden z wyświetlaczy.

Multipleksowanie w praktyce

Teraz pora wykorzystać dodane tranzystory w praktyce. Najpierw trzeba dodać nowe definicje:

Drugi krok to dodanie konfiguracji wyjść:

Teraz można już wykorzystać wyświetlacze osobno. Zacznijmy od programu, który będzie na zmianę (co sekundę) uruchamiał jeden z wyświetlaczy, pokazywał na nim jakąś wartość, a po chwili włączał drugi wyświetlacz z inną wartością. Czyli spodziewamy się takiego efektu:

Wyświetlanie różnych wartości na wyświetlaczach (animacja).

W pętli głównej programu musimy cyklicznie włączać pierwszy wyświetlacz, pokazywać na nim np. wartość 5. Następnie po sekundzie wyłączać go, włączać drugi wyświetlacz i pokazywać na nim wartość 3. Zadanie to realizuje poniższy program:

Koniecznie sprawdź, co dzieje się, gdy będziemy zmniejszać stopniowo czas pomiędzy zmianami. Warto sprawdzić np. 100 ms, 50 ms, 20 ms i 10 ms.

Przy bardzo szybkich zmianach zaczniemy „korzystać” z tego, że ludzkiego oko nie jest w stanie zauważyć tak częstych zmian. Przy ~10 ms, zamiast migania, będziemy widzieć stałą wartość 53!

O to właśnie chodziło – pamiętaj, że wyświetlacze podłączone
są praktycznie tak samo, a widzimy na nich różne wartości!

Zadanie dodatkowe 6.3

Napisz program licznika, którego wartość zmienia się od 0 do 99. Zmiana wartości może odbywać się automatycznie (co stały, ustalony czas) lub np. po wciśnięciu przycisku. Tak jak poprzednio w komentarzach oprócz kodów umieszczajcie zdjęcia/filmy pokazujące działanie układu.

Jak korzystać z takiego rozwiązania w praktyce?

Wszystkie podłączenia elektroniczne, które tutaj zrobiliśmy są dobre i na pewno można je użyć w wielu projektach. Jednak jeśli chodzi o stronę programistyczną, to takie podejście… jest słabe! 

Pisząc bardziej rozbudowane programy nie możemy pozwolić sobie,
aby wstrzymywać całość za pomocą takich opóźnień!

Celem powyższych ćwiczeń było praktyczne pokazanie jak działają wyświetlacze 7-seg. i na czym polega ich multipleksowanie. W praktyce sensowne multipleksowanie wymaga użycia bardziej skomplikowanych mechanizmów, które są wbudowane w mikrokontrolery.

Arduino znane jest jednak z tego, że do wszystkich zawiłych rzeczy
możemy znaleźć gotowe biblioteki!

Gotowa biblioteka do wyświetlaczy 7-seg.

Oczywiście do „sensownego” korzystania z wyświetlaczy 7-segmentowych znajdziemy wiele bibliotek, które zrobią w tle trudniejsze rzeczy. Nie chciałem od razu zaczynać od gotowca, bo część czytelników mogłaby nie zrozumieć zasady działania takiego wyświetlacza – stąd takie ręczne rzeźbienie kodu „na około”…

Pora uruchomić nasze wyświetlacze 7-segmentowe z wykorzystaniem gotowej biblioteki, co ułatwi ich wykorzystywanie w innych projektach. W Internecie znaleźć można przynajmniej kilka takich gotowych funkcji, podczas dalszego opisu skorzystamy z SevSeg Library.

Na powyższej stronie znajduje się informacja, że aktualny kod znajdziemy na GitHubie, aby pobrać bibliotekę korzystamy z przycisku Clone or download → Download ZIP:

Pobieranie najnowszej wersji kodu z GitHuba.

Następnie rozpakowujemy archiwum i kopiujemy z jego wnętrza cały folder SevSeg-master, który następnie wklejamy do katalogu z bibliotekami Arduino, w moim przypadku było to:

C:\Users\Damian\Documents\Arduino\libraries

Po ponownym uruchomieniu Arduino IDE w menu Plik → Przykłady znajdziemy nową kategorię nazwaną SevSeg. Oznacza to, że biblioteka została zainstalowana poprawnie. Nie będziemy teraz jednak korzystać z gotowych przykładów.

Spróbujmy samodzielnie uruchomić wyświetlacze – powinny do tego wystarczyć informacje podane w dokumentacji. Na początku znajdujemy fragment przykładowej konifguracji:

Oczywiście musimy go teraz dostosować do naszego sprzętu. Po pierwsze, zaczynamy od zmiany szerokości wyświetlacza (z 4 cyfr, do 2). Pierwsza linijka konfiguracji powinna więc wyglądać tak:

Dalej podajemy numery pinów, do których podłączone zostały tranzystory „sterujące cyframi”:

Następnie musimy dostarczyć informacje do biblioteki na temat połączenia segmentów (A-G):

W kolejnym kroku dodajemy informacje na temat sposobu podłączenia:

Pierwsza linia informuje o tym, że każdy z segmentów zasilany jest przez własny rezystor. Jak widać biblioteka dopuszcza również wersję bez takiego zabezpieczenia, jednak zdecydowanie odradzam zabawy z taką konfiguracją – bardzo łatwo uszkodzić wtedy wyświetlacz!

W drugiej linii podajemy natomiast informację na temat sposobu sterowania cyframi. Wykorzystanie tranzystora BC547 sprawiło, że cyfrę włączamy podając stan wysoki, więc z opisu udostępnionego w dokumentacji biblioteki najlepiej pasuje wersja „N_TRANSISTORS”:

N_TRANSISTORS – If you use N-type transistors to sink current
(or any other active-high, low-side switches).

Po uzupełnieniu powyższych informacji nasz szkic bazowy wygląda następująco:

Od teraz w programie możemy korzystać z obiektu sevseg. Zacznijmy od wyświetlenia liczby:

Pierwsza linia w pętli loop() odpowiada za wyświetlenie liczby 34 korzystając z 2 wyświetlaczy. W naszym przypadku drugim argumentem funkcji zawsze będzie 2, ponieważ nie mamy możliwości włączenia „kropek” w wyświetlaczu. Gdyby taka opcja istniała, to parametrem tym moglibyśmy ustawiać sposób formatowania liczb np. wartość 3 mogłaby być pokazywana jako „03” lub „3.0„.

Druga linia programu sevseg.refreshDisplay(); odpowiada za odświeżanie ekranu, czyli jego multipleksowanie, które poprzednio robiliśmy ręcznie. Biblioteka sama wylicza, na podstawie naszej konfiguracji, jak często należy przełączać wyświetlacze, aby obraz był stabilny.

Efekt działania programu, widoczny jest poniżej:

Wartość wyświetlona dzięki bibliotece SevSeg.

Omawiana biblioteka pozwala wykorzystać wyświetlacze 7-segmentowe w bardziej rozbudowany sposób. Przykładowo zdefiniowano tam również litery/symbole. Oczywiście większość z nich będzie wyświetlana słabo (lub wcale) przez ograniczoną ilość segmentów…

Jednak spokojnie da się odczytać litery typu A, b, H, C itd. Aby to zrobić należy użyć nowej funkcji sevseg.setChars();. Poniższy przykład wyświetli napis AC:

Efekt działania kodu widoczny jest na poniższym zdjęciu:

Tekst „AC” wyświetlony dzięki bibliotece SevSeg.

Wszystkie zdefiniowane znaki można podejrzeć w pliku SevSeg.cpp (który jest głównym plikiem omawianej biblioteki. Sam fragment z definicją wszystkich znaków wygląda następująco:

Ostatni przykład z wyświetlaczem 7-seg.

W ramach przykładu praktycznego warto byłoby podłączyć do Arduino czujnik, z którego informacje byłyby później pokazywane na wyświetlaczu. Idealnie sprawdzi się tutaj „coś”, co można odczytać w sposób analogowy. Może być to np. fotorezystor podłączony w układzie dzielnika napięcia.

Rozwiązanie to było wykorzystywane w kursie wiele razy, więc pomijam tę część sprzętową. Każdy pewnie znajdzie coś, co chciałby tam podłączyć. Na potrzeby mojego testu wykorzystałem ostatnie wolne miejsce na płytce stykowej i umieściłem tam potencjometr.

Podłączenie było następujące:

  • skrajne lewe wyprowadzenie do 5V,
  • środkowe wyprowadzenie do A0,
  • skrajne prawe wyprowadzenie do masy.

Podłączenie potencjometru (żółty – 5V, zielony A0, biały – GND).

W celu wyświetlenia aktualnej wartości na wyświetlaczu konieczne jest jej przeskalowanie. Tutaj oczywiście pomocna jest funkcja map(). Cały program widoczny jest poniżej:

Po jego uruchomieniu, na wyświetlaczu 7-segmentowym, ukaże się wartość z zakresu 0-99, którą możemy płynnie zmieniać za pomocą potencjometru:

Płynna regulacja wartości.

Biblioteka nie rozwiązuje wszystkich problemów

Opisana tutaj biblioteka pomaga w łatwiejszym skonfigurowaniu i uruchomieniu wyświetlaczy tego typu. Nie rozwiązuje ona jednak wszystkich problemów. Cały czas „problemem” jest konieczność częstego multipleksowania wyświetlaczy. W tym przypadku wymusza to częste wywoływanie funkcji sevseg.refreshDisplay();

W związku z powyższym programy, które mają działać z wyświetlaczami
7-segmentowymi nie mogą korzystać z funkcji opóźniającej delay()!

Wszystkie opóźnienia należy zastąpić bardziej rozbudowanym mechanizmem opartym o funkcję millis(). Zainteresowanych odsyłam do odpowiedniej dokumentacji Arduino oraz do przykładu umieszczonego w bibliotece SevSeg, czyli: Plik → Przykłady → SevSeg  → SevSeg_Counter.

Podczas tego kursu nie omawiam funkcji milis(), ponieważ tym tematem zajmę się
prawdopodobnie w osobnej serii dotyczącej „wielowątkowości w Arduino„.

Podsumowanie

Ten odcinek kursu wyszedł trochę przewrotny. Powstawał kilka razy praktycznie od zera, bo za każdym razem był na niego trochę inny plan. Mam nadzieję, że ostatecznie udało się za jego pomocą wyjaśnić działanie wyświetlacza, co pozwoli lepiej wykorzystywać go później w praktyce.

W kolejnym odcinku zajmiemy się nowymi czujnikami. Tym razem poznamy w praktyce analogowe oraz cyfrowe czujniki temperatury.

Kup zestaw elementów i zacznij naukę w praktyce! Przejdź do strony dystrybutora »

Autor kursu: Damian (Treker) Szymański

Powiadomienia o nowych, darmowych artykułach!

Komentarze

leepa79

13:38, 04.02.2017

#1

Moja interpretacja zadania 6.1

#define SEG_C 2

#define SEG_E 3

#define SEG_D 4

#define SEG_B 5

#define SEG_G 6

#define SEG_A 7

#define SEG_F 8

String odebraneDane = ""; //Pusty ciąg odebranych danych

boolean start = true; //Poczatek wpisu

String wpis = ""; //Wpisana liczba ile

int ile = 0; //Jakas zmienna na potrzeby wyswietlacza ;)

void setup() {

Serial.begin(9600); //Serial ruszyl z zawrotna predkoscia

//Konfiguracja pinow jako wyjscia

pinMode(SEG_A, OUTPUT);

pinMode(SEG_B, OUTPUT);

pinMode(SEG_C, OUTPUT);

pinMode(SEG_D, OUTPUT);

pinMode(SEG_E, OUTPUT);

pinMode(SEG_F, OUTPUT);

pinMode(SEG_G, OUTPUT);

}

void loop() {

while (start == true) //Kiedy podano cyferki lub inne liczbusie

{

Serial.println("Podaj cyfre z zakresu 0-9"); //Tekst jakis

while(Serial.available() == 0) //Poczekaj na wpisanie cyfry

{}

if(Serial.available() > 0) //Jeśli cyfra zostanie wpisana

{

wpis = Serial.readStringUntil('\n'); //Odczytaj cyfre

ile = wpis.toInt(); //Zmien String na int

wyswietlacz(ile); //Wrzuc to co odczytales na wyswietlacz

Serial.print("Podana cyfra: "); //Pokaz na porcie co wpisales

Serial.println(ile);

delay(1000); //Delay to przeklenstwo kazdego prgramu...

}

}

}

void wyswietlacz(int cyfra) {

//Instrukcja switch ustawia odpowiednie stany na wyjsciach

//w zaleznosci od podanej cyfry

switch (cyfra) {

case 0:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, HIGH);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, LOW);

break;

case 1:

digitalWrite(SEG_A, LOW);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, LOW);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, LOW);

break;

case 2:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, LOW);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, HIGH);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, HIGH);

break;

case 3:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, HIGH);

break;

case 4:

digitalWrite(SEG_A, LOW);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, LOW);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

case 5:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, LOW);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

case 6:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, LOW);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, HIGH);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

case 7:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, LOW);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, LOW);

break;

case 8:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, HIGH);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

case 9:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

}

//Jesli liczba inna niz z zakresu 0-9 wyswietl blad

if (cyfra > 9 || cyfra < 0){

error();

Serial.println("Bledna cyfra - podaj cyfre z zakresu 0-9");

delay(1000);

}

}

//Symbol bledu na wyswietlaczu

void error(){

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, LOW);

digitalWrite(SEG_C, LOW);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, HIGH);

}

I fotka

Teraz mała kawa i biorę się za dodawanie przycisków i zadanie 6.2 - mam nadzieję, że nie zapomnę o PULLUPach ;)

PS mała płytka stykowa powędrowała na robota (z kursu) podczas odklejania płytki z tej podstawki z kursu zobaczyłem jak wygląda płytka od środka - bardzo ciekawe doświadczenie ;)

ED:

Zadanie 6.2 jednak nie udało mi się na bazie poprzedniego kodu (zbyt mała wiedza)

Ale 'naskrobałem' coś takiego

//Wyswietlacz

#define SEG_C 2

#define SEG_E 3

#define SEG_D 4

#define SEG_B 5

#define SEG_G 6

#define SEG_A 7

#define SEG_F 8

//Przyciski

#define przDod 9

#define przUja 10

#define przRes 11

#define przLicz 12

int i = 0;

void setup() {

Serial.begin(9600); //Serial ruszyl z zawrotna predkoscia

//Konfiguracja pinow jako wyjscia

pinMode(SEG_A, OUTPUT);

pinMode(SEG_B, OUTPUT);

pinMode(SEG_C, OUTPUT);

pinMode(SEG_D, OUTPUT);

pinMode(SEG_E, OUTPUT);

pinMode(SEG_F, OUTPUT);

pinMode(SEG_G, OUTPUT);

//Konfiguracja dla przyciskow

pinMode(przDod, INPUT_PULLUP);

pinMode(przUja, INPUT_PULLUP);

pinMode(przRes, INPUT_PULLUP);

pinMode(przLicz, INPUT_PULLUP);

}

void loop() {

wyswietlacz(i); //Wyswietl wartosc na wyswietlaczu

if(digitalRead(przDod) == LOW){//Jesli przDod wcisniety

i++; //Dodaj 1 do wartosci

wyswietlacz(i); //Wrzuc na wyswietlacz

Serial.println(i); //Wrzuc na port

delay(500); //Delay dla poprawnego działania przycisku

}

if(digitalRead(przUja) == LOW){//Jesli przDod wcisniety

i--; //Wartosc w dol

wyswietlacz(i); //Wrzuc na wyswietlacz

Serial.println(i); //I serial

delay(500); //Delay dla poprawnego działania przycisku

}

if(digitalRead(przRes) == LOW){//Jesli przRes wcisniety

i=0; //Wyzeruj

wyswietlacz(i); //I wrzuc na wyswietlacz

Serial.println("Reczny restet"); //Plus komentarz na serialu

Serial.println(i);

delay(500); //Delay dla poprawnego działania przycisku

}

if(digitalRead(przLicz) == LOW){//Jesli przLicz wcisniety

for (i ; i > 0; i--) { //Petla odliczania do zera

wyswietlacz(i); //Wyswietl wartosc na wyswietlaczu

delay(1000); //Poczekaj 1000 ms (że niby sekunda ;) )

}

}

}

void wyswietlacz(int cyfra) {

//Instrukcja switch ustawia odpowiednie stany na wyjsciach

//w zaleznosci od podanej cyfry

switch (cyfra) {

case 0:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, HIGH);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, LOW);

break;

case 1:

digitalWrite(SEG_A, LOW);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, LOW);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, LOW);

break;

case 2:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, LOW);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, HIGH);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, HIGH);

break;

case 3:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, HIGH);

break;

case 4:

digitalWrite(SEG_A, LOW);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, LOW);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

case 5:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, LOW);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

case 6:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, LOW);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, HIGH);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

case 7:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, LOW);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, LOW);

break;

case 8:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, HIGH);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

case 9:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

}

//Jesli liczba inna niz z zakresu 0-9 wyswietl blad

if (cyfra > 9 || cyfra < 0){

error();

//Smieszny tekst zamrazajacy program na kilka sekund

Serial.println("Bledna cyfra - podaj cyfre z zakresu 0-9");

delay(500);

Serial.print("Nastapi");

delay(1000);

Serial.print(" automatyczny");

delay(1000);

Serial.println(" reset licznika");

delay(500);

i=0; //Wyzerowanie licznika

wyswietlacz(i);

delay(500);

}

}

//Symbol bledu na wyswietlaczu

void error(){

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, LOW);

digitalWrite(SEG_C, LOW);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, HIGH);

}

Jeszcze film i lecę dalej.

ED2:

Treker
Autor wpisu
Administrator

22:20, 04.02.2017

#2

leepa79, zastanów się, czy nie dasz rady zrobić rozpoznawania wartości "poza zakresem" również switch'em. Poczytaj jaka jest składnia całej instrukcji, może coś Ci się nasunie ;) A jeśli chodzi o sklejki/płytki stykowe/roboty, to niedługo będą pierwsze prototypy nowych rozszerzeń, więc będzie sporo nowych możliwości w tych tematach ;)

leepa79

9:49, 05.02.2017

#3

Treker, Na początku miałem takie rozwiązanie:

//Wyswietlacz

#define SEG_C 2

#define SEG_E 3

#define SEG_D 4

#define SEG_B 5

#define SEG_G 6

#define SEG_A 7

#define SEG_F 8

//Przyciski

#define przDod 9

#define przUja 10

#define przRes 11

#define przLicz 12

int i = 0;

void setup() {

Serial.begin(9600); //Serial ruszyl z zawrotna predkoscia

//Konfiguracja pinow jako wyjscia

pinMode(SEG_A, OUTPUT);

pinMode(SEG_B, OUTPUT);

pinMode(SEG_C, OUTPUT);

pinMode(SEG_D, OUTPUT);

pinMode(SEG_E, OUTPUT);

pinMode(SEG_F, OUTPUT);

pinMode(SEG_G, OUTPUT);

//Konfiguracja dla przyciskow

pinMode(przDod, INPUT_PULLUP);

pinMode(przUja, INPUT_PULLUP);

pinMode(przRes, INPUT_PULLUP);

pinMode(przLicz, INPUT_PULLUP);

}

void loop() {

wyswietlacz(i); //Wyswietl wartosc na wyswietlaczu

if(digitalRead(przDod) == LOW){//Jesli przDod wcisniety

i++; //Dodaj 1 do wartosci

wyswietlacz(i); //Wrzuc na wyswietlacz

Serial.println(i); //Wrzuc na port

delay(500); //Delay dla poprawnego działania przycisku

}

if(digitalRead(przUja) == LOW){//Jesli przDod wcisniety

i--; //Wartosc w dol

wyswietlacz(i); //Wrzuc na wyswietlacz

Serial.println(i); //I serial

delay(500); //Delay dla poprawnego działania przycisku

}

if(digitalRead(przRes) == LOW){//Jesli przRes wcisniety

i=0; //Wyzeruj

wyswietlacz(i); //I wrzuc na wyswietlacz

Serial.println("Reczny restet"); //Plus komentarz na serialu

Serial.println(i);

delay(500); //Delay dla poprawnego działania przycisku

}

if(digitalRead(przLicz) == LOW){//Jesli przLicz wcisniety

for (i ; i > 0; i--) { //Petla odliczania do zera

wyswietlacz(i); //Wyswietl wartosc na wyswietlaczu

Serial.println(i);

delay(1000); //Poczekaj 1000 ms (że niby sekunda ;) )

}

}

}

void wyswietlacz(int cyfra) {

//Instrukcja switch ustawia odpowiednie stany na wyjsciach

//w zaleznosci od podanej cyfry

switch (cyfra) {

case 0:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, HIGH);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, LOW);

break;

case 1:

digitalWrite(SEG_A, LOW);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, LOW);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, LOW);

break;

case 2:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, LOW);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, HIGH);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, HIGH);

break;

case 3:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, HIGH);

break;

case 4:

digitalWrite(SEG_A, LOW);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, LOW);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

case 5:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, LOW);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

case 6:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, LOW);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, HIGH);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

case 7:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, LOW);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, LOW);

break;

case 8:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, HIGH);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

case 9:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, HIGH);

digitalWrite(SEG_C, HIGH);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, HIGH);

digitalWrite(SEG_G, HIGH);

break;

case 10:

digitalWrite(SEG_A, HIGH);

digitalWrite(SEG_B, LOW);

digitalWrite(SEG_C, LOW);

digitalWrite(SEG_D, HIGH);

digitalWrite(SEG_E, LOW);

digitalWrite(SEG_F, LOW);

digitalWrite(SEG_G, HIGH);

delay(1000);

i=0;

wyswietlacz(i);

delay(500);

break;

}

}

Czyli case 10 :) Ale nie wiedziałem jak zrobić błąd dla wartości poniżej zera.

Cytat:

A jeśli chodzi o sklejki/płytki stykowe/roboty, to niedługo będą pierwsze prototypy nowych rozszerzeń

To jest wspaniała wiadomość. Ostatnio częściej zaglądam na forum i zastanawiam się jak to wszystko ogarniasz? :) Robicie naprawdę świetną robotę, więc z tej okazji wielkie dzięki - nie pierwsze i nie ostatnie.

Treker
Autor wpisu
Administrator

21:05, 06.02.2017

#4

leepa79 napisał/a:

Czyli case 10 Ale nie wiedziałem jak zrobić błąd dla wartości poniżej zera.

Nie do końca :) Można jeszcze dodać coś takiego:

switch (wyrażenie) {

case wartość1: /* instrukcje, jeśli wyrażenie == wartość1 */

break;

case wartość2: /* instrukcje, jeśli wyrażenie == wartość2 */

break;

/* ... */

default: /* instrukcje, jeśli żaden z wcześniejszych warunków nie został spełniony */

break;

}

Fragment zaczerpnięty z: https://pl.wikibooks.org/wiki/C/Instrukcje_steruj%C4%85ce#switch :)

leepa79 napisał/a:

To jest wspaniała wiadomość. Ostatnio częściej zaglądam na forum i zastanawiam się jak to wszystko ogarniasz? Robicie naprawdę świetną robotę, więc z tej okazji wielkie dzięki - nie pierwsze i nie ostatnie.

Dzięki za miłe słowa, zawsze motywują do dalszej pracy :)

leepa79

22:50, 07.02.2017

#5

A więc "default:" :) dzięki za radę. Teraz już wszystko wygląda ładnie. Jedziemy dalej. Następne zadanie robię na bazie tego poprzedniego. Mam już szkic i dwa problemy. Pierwszy - jak pogodzić ten delay (pińcet) który pomaga mi w kontrolowaniu zakłóceń w przycisku z tym szybkim delayem na dwóch wyświetlaczach? Drugi - przycisk odliczający od 99 do zera, ale tu jakoś dojdę do sedna :) (mam nadzieję) trochę się oderwałem od lekcji bo światłolub czekał ;) Oglądałem też te przykłady z SevSeg i tu z przykładami jakoś to poszło, ale nie idę dalej póki nie rozwiąże poprzednich zadań.

Treker
Autor wpisu
Administrator

23:11, 08.02.2017

#6

leepa79, w kursie staram się opisywać podstawy, a i tak czasami muszę długo przynudzać, więc niektóre rzeczy od pewnego poziomu warto jeszcze trenować we własnym zakresie.

Przy okazji aktualizacja: w związku z tym, że część o gotowej bibliotece zajęła więcej miejsca od tego, które pierwotnie założyłem, to dodałem jednak te informacje do opublikowanej już #6 części kursu. W kolejnej zajmiemy się już tylko termometrami. W związku z tym zainteresowanych wyświetlaczami zachęcam do lektury nowego kawałka artykułu: Kurs Arduino II – #6 – wyświetlacze 7-segmentowe. Publikację kolejnej części przesuwam o jeden dzień, aby nie pojawiło się zbyt dużo rzeczy jednocześnie :)

Loght

11:30, 12.06.2017

#7

Witam.

Próbuję wykonać stoper odliczający 60 sekund w duł. Jednak metodę jaką wykorzystałem podczas robienia takowego na wyświetlaczy LCD zawodzi. To jest

{ i=i-1; delay (1000);}
w funkcji loop.

Prosiłbym o pomoc.

Treker
Autor wpisu
Administrator

12:35, 12.06.2017

#8

Loght, witam na forum :)

Z podanego fragmentu ciężko wywnioskować co dokładnie jest źle. Wklej cały kod, najlepiej z komentarzami - bez tego nie damy rady Ci pomóc.

Loght

10:05, 15.06.2017

#9

Oto cały kod jaki próbowałem pisać.

#include "SevSeg.h"

SevSeg sevseg; //Instantiate a seven segment controller object

int i;

void setup() {

byte numDigits = 2;

byte digitPins[] = {10, 9};

byte segmentPins[] = {7, 5, 2, 4, 3, 8, 6};

bool resistorsOnSegments = true; // Use 'true' if on digit pins

byte hardwareConfig = N_TRANSISTORS; // See README.md for options

sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments);

i = 60;

}

void loop() {

sevseg.setNumber(i, 2); //Wyswietl liczbę 34, korzystając z dwóch wyswietlaczy

sevseg.refreshDisplay();

{

i=i-1;

delay (1000);

}

}

próbowałem również innych metod ta wydaje mi się najłatwiejsza ale nie działa.

Treker
Autor wpisu
Administrator

12:02, 16.06.2017

#10

Loght, niestety tak jak pisałem w artykule (oraz w poprzednich komentarzach) nie można korzystać z opóźnień (wykonywanych przez funkcję delay), ponieważ zatrzymują cały problem i blokują możliwość multipleksowania wyświetlacza. Jeśli koniecznie chcesz stworzyć taki program, to zainteresuj się funkcją milis(), której wykorzystanie zostało opisane np. tutaj: https://www.arduino.cc/en/Tutorial/BlinkWithoutDelay Za jej pomocą można odliczać czas bez zatrzymywania całego programu.

ponyyou

1:40, 25.06.2017

#11

Witam zadanie domowe wykonałem (dokładniej kod) w taki sposób :

#define C 3

#define E 5

#define D 6

#define B 11

#define G 2

#define A 7

#define F 10

#define button_0 8

#define button_plus 9

#define button_minus 4

void setup() {

pinMode(C, OUTPUT);

pinMode(E, OUTPUT);

pinMode(D, OUTPUT);

pinMode(B, OUTPUT);

pinMode(G, OUTPUT);

pinMode(A, OUTPUT);

pinMode(F, OUTPUT);

pinMode(button_0, INPUT_PULLUP);

pinMode(button_plus, INPUT_PULLUP);

pinMode(button_minus, INPUT_PULLUP);

}

int i = 0;

void loop() {

if(digitalRead(button_0) == LOW) {

i = 0;

wysw(i);

}

if(digitalRead(button_plus) == LOW && i < 11){

i = i+1;

wysw(i);

while(digitalRead(button_plus) == LOW) {

delay(20);

}

}

if(digitalRead(button_minus) == LOW){

i = i-1;

wysw(i);

while(digitalRead(button_minus) == LOW) {

delay(20);

}

}

}

void wysw(int cyfra){

switch (cyfra){

case 0:

digitalWrite(A, HIGH);

digitalWrite(B, HIGH);

digitalWrite(C, HIGH);

digitalWrite(D, HIGH);

digitalWrite(E, HIGH);

digitalWrite(F, HIGH);

digitalWrite(G, LOW);

break;

case 1:

digitalWrite(A, LOW);

digitalWrite(B, HIGH);

digitalWrite(C, HIGH);

digitalWrite(D, LOW);

digitalWrite(E, LOW);

digitalWrite(F, LOW);

digitalWrite(G, LOW);

break;

case 2:

digitalWrite(A, HIGH);

digitalWrite(B, HIGH);

digitalWrite(C, LOW);

digitalWrite(D, HIGH);

digitalWrite(E, HIGH);

digitalWrite(F, LOW);

digitalWrite(G, HIGH);

break;

case 3:

digitalWrite(A, HIGH);

digitalWrite(B, HIGH);

digitalWrite(C, HIGH);

digitalWrite(D, HIGH);

digitalWrite(E, LOW);

digitalWrite(F, LOW);

digitalWrite(G, HIGH);

break;

case 4:

digitalWrite(A, LOW);

digitalWrite(B, HIGH);

digitalWrite(C, HIGH);

digitalWrite(D, LOW);

digitalWrite(E, LOW);

digitalWrite(F, HIGH);

digitalWrite(G, HIGH);

break;

case 5:

digitalWrite(A, HIGH);

digitalWrite(B, LOW);

digitalWrite(C, HIGH);

digitalWrite(D, HIGH);

digitalWrite(E, LOW);

digitalWrite(F, HIGH);

digitalWrite(G, HIGH);

break;

case 6:

digitalWrite(A, HIGH);

digitalWrite(B, LOW);

digitalWrite(C, HIGH);

digitalWrite(D, HIGH);

digitalWrite(E, HIGH);

digitalWrite(F, HIGH);

digitalWrite(G, HIGH);

break;

case 7:

digitalWrite(A, HIGH);

digitalWrite(B, HIGH);

digitalWrite(C, HIGH);

digitalWrite(D, LOW);

digitalWrite(E, LOW);

digitalWrite(F, LOW);

digitalWrite(G, LOW);

break;

case 8:

digitalWrite(A, HIGH);

digitalWrite(B, HIGH);

digitalWrite(C, HIGH);

digitalWrite(D, HIGH);

digitalWrite(E, HIGH);

digitalWrite(F, HIGH);

digitalWrite(G, HIGH);

break;

case 9:

digitalWrite(A, HIGH);

digitalWrite(B, HIGH);

digitalWrite(C, HIGH);

digitalWrite(D, HIGH);

digitalWrite(E, LOW);

digitalWrite(F, HIGH);

digitalWrite(G, HIGH);

break;

case 10:

digitalWrite(A, HIGH);

digitalWrite(B, LOW);

digitalWrite(C, LOW);

digitalWrite(D, HIGH);

digitalWrite(E, LOW);

digitalWrite(F, LOW);

digitalWrite(G, HIGH);

break;

default:

digitalWrite(A, HIGH);

digitalWrite(B, HIGH);

digitalWrite(C, HIGH);

digitalWrite(D, HIGH);

digitalWrite(E, HIGH);

digitalWrite(F, HIGH);

digitalWrite(G, LOW);

i = 0;

break;

}

}

Można w jakoś zastąpić while ale nie samym delay bo wtedy przycisk działa z opóźnieniem .

Zobacz powyższe komentarze na forum

FORBOT Damian Szymański © 2006 - 2017 Zakaz kopiowania treści oraz grafik bez zgody autora. vPRsLH.