7-segmentowy wyświetlacz współpracujący z mikrokontrolerem pic

To jest nasz 8 samouczek dotyczący nauki mikrokontrolerów PIC przy użyciu MPLAB i XC8. Przeszliśmy całą drogę od instalacji MPLABX do używania wyświetlacza LCD z MCU PIC. Jeśli jesteś tu nowy, spójrz na poprzednie samouczki, w których możesz nauczyć się timerów, migającej diody LED, interfejsu LCD itp. Możesz znaleźć wszystkie nasze samouczki PIC tutaj. W naszym ostatnim samouczku widzieliśmy, jak możemy generować niestandardowe znaki za pomocą naszego wyświetlacza LCD 16 * 2, teraz wyposażymy się w inny typ modułu wyświetlacza zwany wyświetlaczem 7-segmentowym i połączymy go z mikrokontrolerem PIC.

Chociaż wyświetlacz LCD 16x2 jest znacznie wygodniejszy niż wyświetlacz 7-segmentowy, ale istnieje kilka scenariuszy, w których wyświetlacz 7-segmentowy byłby wygodniejszy niż wyświetlacz LCD. LCD ma tę wadę, że ma mały rozmiar znaków i będzie przesadą dla twojego projektu, jeśli planujesz tylko wyświetlić niektóre wartości liczbowe. 7-segmentowe mają również tę zaletę w przypadku słabego oświetlenia i można je oglądać pod większym kątem niż normalny ekran LCD. Więc zacznijmy to wiedzieć.

7-segmentowy i 4-cyfrowy 7-segmentowy moduł wyświetlacza:

Wyświetlacz 7-segmentowy składa się z siedmiu segmentów, a każdy segment ma wewnątrz jedną diodę LED, która wyświetla cyfry, podświetlając odpowiednie segmenty. Jeśli chcesz, aby 7-segmentowy wyświetlał liczbę „5”, musisz zaświecić segment a, f, g, c i d, ustawiając odpowiednie szpilki w górę. Istnieją dwa typy wyświetlaczy 7-segmentowych: ze wspólną katodą i ze wspólną anodą, tutaj używamy siedmiosegmentowego wyświetlacza ze wspólną katodą. Dowiedz się więcej o 7-segmentowym wyświetlaczu tutaj.

Teraz wiemy, jak wyświetlić żądany znak numeryczny na pojedynczym 7-segmentowym wyświetlaczu. Ale jest całkiem oczywiste, że potrzebowalibyśmy więcej niż jednego siedmiosegmentowego wyświetlacza do przekazywania wszelkich informacji zawierających więcej niż jedną cyfrę. Tak więc w tym samouczku będziemy używać 4-cyfrowego 7-segmentowego modułu wyświetlacza, jak pokazano poniżej.

Jak widać, są połączone ze sobą cztery siedmiosegmentowe wyświetlacze. Wiemy, że każdy moduł 7-segmentowy będzie miał 10 pinów, a dla 4 wyświetlaczy siedmiosegmentowych łącznie byłoby 40 pinów i byłoby gorączkowo, gdyby ktoś lutował je na płytce z kropkami, więc gorąco polecam każdemu zakup modułu lub stwórz własną płytkę PCB do korzystania z 4-cyfrowego 7-segmentowego wyświetlacza. Schemat połączeń dla tego samego pokazano poniżej:

Aby zrozumieć, jak działa 4-cyfrowy moduł siedmiosegmentowy, musimy spojrzeć na powyższe schematy, jak pokazano, piny A wszystkich czterech wyświetlaczy są połączone jako jeden A i to samo dla B, C…. aż do DP. Tak więc, w zasadzie, jeśli wyzwalacz A jest włączony, wszystkie cztery A powinny iść wysoko, prawda?

Ale tak się nie dzieje. Mamy dodatkowe cztery piny od D0 do D3 (D0, D1, D2 i D3), za pomocą których możemy kontrolować, który z czterech wyświetlaczy powinien mieć stan wysoki. Na przykład: Jeśli potrzebuję, aby moje wyjście było obecne tylko na drugim wyświetlaczu, to tylko D1 powinno być ustawione wysoko, podczas gdy inne piny (D0, D2 i D3) powinny być niskie. Po prostu możemy wybrać, który wyświetlacz ma być aktywny za pomocą pinów od D0 do D3 i jaki znak ma być wyświetlany za pomocą pinów od A do DP.

Podłączanie 4-cyfrowego modułu siedmiosegmentowego z mikrokontrolerem PIC:

Tutaj użyliśmy mikrokontrolera PIC PIC16F877A, a schemat obwodu pokazano poniżej.

Mamy 12 pinów wyjściowych z modułu, z których 8 służy do wyświetlania znaków, a cztery do wyboru jednego z czterech wyświetlaczy. Stąd wszystkie 8-znakowe kołki są przypisane do PORTD, a kołki wyboru wyświetlania są przypisane do pierwszych czterech pinów PORTC.

Uwaga: pin uziemienia modułu powinien być również podłączony do uziemienia MCU, co nie jest tutaj pokazane.

Programowanie za pomocą PIC16F877A:

Teraz, gdy wiemy, jak faktycznie działa ten moduł, nauczmy się, jak zaprogramować PIC16F877A, aby wyświetlał 4-cyfrowy numer. Zwiększmy zmienną od 0 do 1000 i wydrukujmy ją na 7-segmentowym wyświetlaczu. Uruchom program MPLABX i stwórz nowy projekt, zacznijmy od bitów konfiguracyjnych.

#pragma config FOSC = HS // Bity wyboru oscylatora (oscylator HS) #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT wyłączony) #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT włączony) # pragma config BOREN = ON // Brown-out Reset Enable bit (BOR włączony) #pragma config LVP = OFF // Niskonapięciowe (pojedyncze zasilanie) In-Circuit Serial Programming Bit Enable (RB3 to cyfrowe we / wy, HV włączone Do programowania musi być używany MCLR) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off) #pragma config WRT = OFF // Flash Program Memory Write Enable bits (ochrona przed zapisem wyłączona; cała pamięć programu może być zapisywany przez sterowanie EECON) #pragma config CP = OFF // Bit ochrony kodu pamięci programu Flash (ochrona kodu wyłączona)

Jak zwykle do ustawienia tych bitów używamy okna set configuration bits. Jeśli nie masz pewności, co oznaczają, odwiedź samouczek dotyczący migania diod LED tutaj.

Następnie zdefiniujmy piny wyjściowe do przełączania między każdą cyfrą wyświetlacza.

// *** Zdefiniuj piny sygnałowe wszystkich czterech wyświetlaczy *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Koniec definicji ** ////

Tutaj piny RC0, RC1, RC2 i RC3 są używane do wyboru między czterema cyframi naszego 7-segmentowego modułu wyświetlacza. Te kołki są zdefiniowane odpowiednio jako s1, s2, s3 i s4.

Następnie przejdźmy do void main (), w którym znajduje się następująca deklaracja zmiennej:

int i = 0; // 4-cyfrowa wartość, która ma zostać wyświetlona int flag = 0; // do tworzenia opóźnienia bez znaku int a, b, c, d, e, f, g, h; // tylko zmienne unsigned int seg = {0X3F, // Wartość szesnastkowa, aby wyświetlić liczbę 0 0X06, // Wartość szesnastkowa, aby wyświetlić liczbę 1 0X5B, // Wartość szesnastkowa, aby wyświetlić liczbę 2 0X4F, // Wartość szesnastkowa do wyświetlenia liczba 3 0X66, // Wartość szesnastkowa, aby wyświetlić liczbę 4 0X6D, // Wartość szesnastkowa, aby wyświetlić liczbę 5 0X7C, // Wartość szesnastkowa, aby wyświetlić liczbę 6 0X07, // Wartość szesnastkowa, aby wyświetlić liczbę 7 0X7F, / / Wartość szesnastkowa, aby wyświetlić liczbę 8 0X6F // Wartość szesnastkowa, aby wyświetlić liczbę 9}; // End of Array do wyświetlania liczb od 0 do 9

Tutaj zmienne i i flag są używane do przechowywania wartości, które mają być wyświetlane i odpowiednio do tworzenia opóźnienia. W niepodpisane zmiennymi całkowitymi A do H są wykorzystywane do łamania numerów czterocyfrowych do jednej cyfry i przechowywać je (co zostanie później wyjaśnione tutaj).

Jedną z kluczowych rzeczy, na które należy zwrócić uwagę, jest deklaracja tablicy „seg” . W tym programie używamy nowego typu danych o nazwie Array. Tablica to nic innego jak zbiór podobnych wartości typu danych. Tutaj użyliśmy tej tablicy do przechowywania wszystkich równoważnych wartości szesnastkowych do wyświetlania liczby od 0 do 9.

Adres tablicy zawsze zaczyna się od zera. Więc ta tablica będzie miała wartość szesnastkową liczby numerycznej (0-9) przechowywanej w adresie, która jest taka sama jak liczba, jak pokazano poniżej

Zmienna:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Kod szesnastkowy:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Eq. Numer liczbowy:	0	1	2	3	4	5	6	7	8	9

Więc po prostu, jeśli chcesz wyświetlić numer 0 w swoim 7-segmentowym segmencie, możesz zadzwonić do seg, podobnie, jeśli chcesz wyświetlić numer 6, po prostu musisz użyć seg.

Aby zrozumieć, w jaki sposób faktycznie uzyskano wartość HEX, przyjrzyjmy się poniższej tabeli. Równoważną HEX dla każdej liczby dziesiętnej zapisane w tablicy, tak, że może być używana do wyświetlania jednego konkretnego numeru.

Przejdźmy teraz do następnej części kodu, czyli konfiguracji I / O:

// ***** Konfiguracja we / wy **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Koniec konfiguracji we / wy ** ///

Konfiguracja I / O jest prosta, ponieważ wszystkie piny w naszym 7-segmentowym segmencie są pinami wyjściowymi, a połączenia są pokazane na schemacie powyżej, więc po prostu zadeklaruj je jako wyjścia i zainicjuj je do zera.

Przejdźmy teraz do naszej nieskończonej pętli (while (1)). Tutaj musimy podzielić wartość „i” na cztery cyfry i wyświetlić je w 7-segmentach. Zacznijmy od podzielenia wartości na „i”

// *** Dzielenie "i" na cztery cyfry *** // a = i% 10; // 4. cyfra jest tutaj zapisana b = i / 10; c = b% 10; // 3. cyfra jest tutaj zapisana d = b / 10; e = d% 10; // 2. cyfra jest tutaj zapisana f = d / 10; g = f% 10; // Pierwsza cyfra jest tutaj zapisana h = f / 10; // *** Koniec podziału *** //

Dzięki zastosowaniu prostego modułu i operacji dzielenia 4-cyfrowy numer (i) jest rozdzielany na poszczególne liczby. W naszym przypadku weźmy przykład, gdzie wartość „i” wynosi 4578. Następnie na końcu tego procesu zmienna g = 4, e = 5, c = 7 i a = 8. Więc teraz łatwo będzie wyświetlić każdą cyfrę, używając po prostu tej zmiennej.

PORTD = seg; s1 = 1; // Włącz wyświetlacz 1 i wydrukuj czwartą cyfrę __delay_ms (5); s1 = 0; // WYŁĄCZ wyświetlacz 1 po 5 ms opóźnienia PORTD = seg; s2 = 1; // Włącz wyświetlacz 2 i wydrukuj trzecią cyfrę __delay_ms (5); s2 = 0; // WYŁĄCZ wyświetlacz 2 po 5 ms opóźnienia PORTD = seg; s3 = 1; // Włącz wyświetlacz 3 i wydrukuj 2. cyfrę __delay_ms (5); s3 = 0; // WYŁĄCZ wyświetlacz 3 po 5 ms opóźnienia PORTD = seg; s4 = 1; // Włącz wyświetlacz 4 i wydrukuj pierwszą cyfrę __delay_ms (5); s4 = 0; // Wyłącz wyświetlacz 4 po 5 ms opóźnienia

To jest rzeczywiste miejsce, w którym MCU rozmawia z 7-segmentowym. Jak wiemy , możemy wyświetlić tylko jedną cyfrę na raz, ale mamy cztery cyfry do wyświetlenia i tylko wtedy, gdy wszystkie cztery cyfry są włączone, cały czterocyfrowy numer będzie widoczny dla użytkownika.

Więc jak to zrobimy?

Na szczęście dla nas nasz MCU jest znacznie szybszy niż ludzkie oko, więc tak naprawdę robimy: wyświetlamy jedną cyfrę na raz, ale robimy to bardzo szybko, jak pokazano powyżej.

Wybieramy jedną cyfrę wyświetl, czekamy 5ms, aby MCU i 7-segmentowe mogły ją przetworzyć, a następnie wyłączamy tę cyfrę i przechodzimy do następnej cyfry i robimy to samo, aż dojdziemy do ostatniej cyfry. To opóźnienie 5 ms nie może być zaobserwowane ludzkim okiem i wszystkie cztery cyfry wydawały się być włączone w tym samym czasie.

To wszystko, w końcu po prostu zwiększamy wartość wyświetlanej cyfry za pomocą opóźnienia, jak pokazano poniżej

if (flag> = 100) // poczekaj, aż flaga osiągnie 100 {i ++; flag = 0; // tylko jeśli flaga wynosi sto „i” zostanie zwiększone} flag ++; // flaga przyrostu dla każdego flasha

Opóźnienie jest wykorzystywane tak, aby czas potrzebny na zmianę z jednej liczby na drugą był wystarczająco długi, abyśmy mogli zauważyć zmianę.

Kompletny kod znajduje się poniżej, a proces jest również wyjaśnione w Wideo na końcu.

Konfiguracja i testowanie sprzętu:

Jak zawsze pozwól nam zasymulować program za pomocą Proteusa, zanim faktycznie przejdziemy do naszego sprzętu. Jeśli symulacja się powiedzie, powinieneś zobaczyć coś takiego

Ten projekt nie ma skomplikowanej konfiguracji sprzętowej, ponownie używamy tej samej płytki mikrokontrolera PIC, którą stworzyliśmy w samouczku migania diod LED. Wystarczy podłączyć moduł 7-segmentowy do płytki mikrokontrolera PIC zgodnie ze schematem połączeń. Po zakończeniu połączeń po prostu zrzuć kod za pomocą programatora PicKit 3 i ciesz się wynikami.