7 Сегментно взаимодействие на дисплея с микроконтролер pic

Това е нашият 8-ми урок за обучение на PIC микроконтролери, използващи MPLAB и XC8. Измислихме целия път от инсталирането на MPLABX до използването на LCD с PIC MCU. Ако сте нов тук, тогава разгледайте предишни уроци, където можете да научите таймери, мигащ светодиод, свързващ LCD и т.н. Можете да намерите всички наши уроци за PIC тук. В последния ни урок видяхме как можем да генерираме персонализирани символи с нашия LCD дисплей 16 * 2, сега нека се оборудваме с друг тип дисплеен модул, наречен 7-сегментен дисплей, и да го свържем с PIC Microcontroller.

Въпреки че 16x2 LCD е много по-удобен от 7-сегментния дисплей, но има малко сценарии, при които 7-сегментният дисплей би бил по-удобен от LCD дисплея. LCD страда от недостатъка на ниския размер на символа и ще бъде прекалено голям за вашия проект, ако просто планирате да покажете някои цифрови стойности. 7-сегментите също имат предимството срещу лошото осветление и могат да се гледат от по-големи ъгли от нормалния LCD екран. И така, нека започнем да го знаем.

7-сегментен и 4-цифрен 7-сегментен дисплеен модул:

7-сегментният дисплей има седем сегмента и всеки сегмент има един светодиод вътре, за да покаже числата чрез осветяване на съответните сегменти. Подобно на това, ако искате 7-сегментът да показва числото "5", тогава трябва да светите сегменти a, f, g, c и d, като направите съответните им щифтове високи. Има два типа 7-сегментни дисплеи: Общ катод и Общ анод, тук използваме седемсегментен дисплей Общ ​​катод. Научете повече за 7-сегментния дисплей тук.

Сега знаем как да покажем желания цифров символ на един 7-сегментен дисплей. Но е очевидно, че ще се нуждаем от повече от един 7-сегментен дисплей, за да предадем всякаква информация, която е повече от една цифра. И така, в този урок ще използваме 4-цифрен 7-сегментен дисплеен модул, както е показано по-долу.

Както виждаме, има четири седем сегментни дисплея, свързани заедно. Знаем, че всеки 7-сегментен модул ще има 10 щифта и за 4 седем сегментни дисплея ще има общо 40 щифта и би било забързано всеки да ги запоява на платка, така че горещо препоръчвам на всеки да закупи модул или направете своя собствена платка за използване на 4-цифрен 7-сегментен дисплей. Схемата на връзката за същото е показана по-долу:

За да разберем как работи 4-цифрения седемсегментен модул, трябва да разгледаме горните схеми, както е показано, щифтовете A на всичките четири дисплея са свързани, за да се съберат като едно A и същото за B, C…. до DP. Така че, ако тригер А е включен, тогава всичките четири А трябва да отидат високо, нали?

Но това не се случва. Имаме допълнителни четири щифта от D0 до D3 (D0, D1, D2 и D3), които могат да се използват за контрол на това кой дисплей от четирите трябва да е висок. Например: Ако имам нужда моят изход да присъства само на втория дисплей, тогава само D1 трябва да бъде направен високо, като останалите пинове (D0, D2 и D3) са ниски. Просто можем да изберем кой дисплей трябва да стане активен, използвайки щифтовете от D0 до D3 и какъв символ да се показва, използвайки щифтовете от A до DP.

Свързване на 4-цифрен седемсегментен модул с PIC микроконтролер:

Тук използвахме PIC микроконтролер PIC16F877A и схемата за веригата е показана по-долу.

Имаме 12 изходни щифта от модула, от които 8 се използва за показване на символите и четири се използва за избор на един дисплей от четири. Следователно всичките 8 знакови щифта се присвояват на PORTD, а щифтовете за избор на дисплея се присвояват на първите четири щифта на PORTC.

Забележка: Заземяващият щифт на модула също трябва да бъде свързан със земята на MCU, което не е показано тук.

Програмиране с помощта на PIC16F877A:

Сега, след като знаем как всъщност работи този модул, нека се научим как да програмираме PIC16F877A, за да го накара да показва 4-цифрено число. Нека увеличим променлива от 0 до 1000 и я отпечатаме на 7-сегментния дисплей. Стартирайте програмата MPLABX и създайте нов проект, нека започнем с конфигурационните битове.

#pragma config FOSC = HS // Осцилатор битове за избор (HS осцилатор) #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT disabled) #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT enabled) # pragma config BOREN = ON // Brown-out Reset Enable bit (BOR enabled) #pragma config LVP = OFF // Нисковолтово (Едно захранване) Вътрешно верижно програмиране Бит за разрешаване (RB3 е цифров I / O, HV включен MCLR трябва да се използва за програмиране) #pragma config CPD = OFF // бит за защита на EEPROM данни за данни (защита на EEPROM код за данни изключена) #pragma config WRT = OFF // Flash Program Memory Активиране на битове (Защита срещу запис; цялата програмна памет може да се запише в контрола на EECON) #pragma config CP = OFF // Flash Program Memory бит за защита на кода (защита на кода изключена)

Както обикновено, ние използваме прозореца за зададени конфигурационни битове, за да зададем тези битове. Ако не сте сигурни какво означават, посетете ръководството за мигащи светодиоди тук.

След това нека дефинираме изходните щифтове за превключване между всяка цифра на дисплея.

// *** Определете сигналните щифтове на четирите дисплея *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Край на дефиницията ** ////

Тук щифтовете RC0, RC1, RC2 и RC3 се използват за избор между четирите цифри на нашия 7-сегментен дисплеен модул. Тези щифтове се дефинират като s1, s2, s3 и s4 съответно.

След това нека скочим в void main (), вътре в който имаме следната декларация на променлива:

int i = 0; // 4-цифрената стойност, която трябва да се покаже int flag = 0; // за създаване на забавяне unsigned int a, b, c, d, e, f, g, h; // само променливи без знак int seg = {0X3F, // шестнадесетична стойност за показване на числото 0 0X06, // шестнадесетична стойност за показване на числото 1 0X5B, // шестнадесетична стойност за показване на числото 2 0X4F, // шестнадесетична стойност за показване числото 3 0X66, // шестнадесетична стойност за показване на числото 4 0X6D, // шестнадесетична стойност за показване на числото 5 0X7C, // шестнадесетична стойност за показване на числото 6 0X07, // шестнадесетична стойност за показване на числото 7 0X7F, / / Шестнадесетична стойност за показване на числото 8 0X6F // Шестнадесетична стойност за показване на числото 9}; // Край на масива за показване на числа от 0 до 9

Тук променливите i и flag се използват за съхраняване на стойностите, които трябва да бъдат показани и създаване на закъснение съответно. На положително цяло променливите А до Н се използват за почивка на четирицифрени числа в едноцифрени числа и да ги съхранявате (което ще бъде обяснено по-късно тук).

Едно ключово нещо, което трябва да отбележим тук, е декларацията за масив "seg" . В тази програма използваме нов тип данни, наречен Array. Масивът не е нищо друго освен колекция от подобни стойности от тип данни. Тук използвахме този масив, за да съхраним всички еквивалентни шестнадесетични стойности за показване на число от 0 до 9.

Адресът на масива винаги започва от нула. Така че този масив ще има шестнадесетичната стойност на числово число (0-9), съхранявано в адреса, който е същият като този на числото, както е показано по-долу

Променлива:	сегмент	сегмент	сегмент	сегмент	сегмент	сегмент	сегмент	сегмент	сегмент	сегмент
Шестнадесетичен код:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Уравнение Цифров номер:	0	1	2	3	4	5	6	7	8	9

Така че просто, ако искате да покажете числото 0 на вашия 7-сегмент, можете да извикате сег, по същия начин, ако искате да покажете числото 6, просто трябва да използвате сегмент.

За да разберем как всъщност е получена HEX стойността, нека разгледаме таблицата по-долу. В равностоен HEX стойност за всеки десетичен номер е запазен в масива, така че да могат да бъдат призовани да се покаже един конкретен номер.

Сега нека преминем към следващата част от кода, която е I / O конфигурация:

// ***** I / O конфигурация **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Край на I / O конфигурацията ** ///

Конфигурацията на I / O е проста, защото всички изводи на нашия 7-сегмент са изходни изводи и връзките са показани в схемата по-горе, така че просто ги декларирайте като изходи и ги инициализирайте до нула.

Сега нека скочим в нашия безкраен цикъл (while (1)). Тук трябва да разделим стойността на "i" на четири цифри и да ги покажем на 7-сегмента. Първо нека започнем с разделяне на стойността на "i"

// *** Разделяне на "i" на четири цифри *** // a = i% 10; // 4-та цифра се запазва тук b = i / 10; c = b% 10; // тук се запазва 3-та цифра d = b / 10; e = d% 10; // тук се запазва 2-ра цифра f = d / 10; g = f% 10; // тук се запазва 1-ва цифра h = f / 10; // *** Край на разделянето *** //

Чрез използване на прост модул и операция на разделяне 4-цифреното число (i) се разделя на отделни числа. В нашия случай нека вземем пример, където стойността на "i" е 4578. Тогава в края на този процес променливата g = 4, e = 5, c = 7 и a = 8. Така че сега ще бъде лесно да покажете всяка цифра, като просто използвате тази променлива.

PORTD = сегмент; s1 = 1; // Включете дисплей 1 и отпечатайте 4-та цифра __delay_ms (5); s1 = 0; // Изключете дисплей 1 след 5 ms закъснение PORTD = сегмент; s2 = 1; // Включете дисплей 2 и отпечатайте 3-та цифра __delay_ms (5); s2 = 0; // Изключете дисплея 2 след 5 ms закъснение PORTD = сегмент; s3 = 1; // Включете дисплей 3 и отпечатайте 2-ра цифра __delay_ms (5); s3 = 0; // Изключете дисплея 3 след 5 ms закъснение PORTD = сегмент; s4 = 1; // Включете дисплей 4 и отпечатайте първа цифра __delay_ms (5); s4 = 0; // Изключете дисплея 4 след 5 ms закъснение

Това е действителното място, където MCU разговаря със 7-сегмента. Както знаем, можем да показваме само по една цифра в даден момент, но имаме четири цифри, които трябва да бъдат показани и само ако всичките четири цифри са На пълното четирицифрено число ще бъде видимо за потребителя.

И така, как да вървим с това?

За наш късмет MCU е много по-бърз от човешкото око, така че това, което всъщност правим: показваме по една цифра, но го правим много бързо, както е показано по-горе.

Избираме едноцифрен дисплей, който изчаква 5ms, за да може MCU и 7-сегментният да го обработят и след това да изключи тази цифра и да премине към следващата цифра и да направи същото, докато достигнем последната цифра. Това закъснение от 5 ms не може да се наблюдава от човешкото око и изглежда, че всичките четири цифри са включени едновременно.

Това е, накрая просто увеличаваме стойността на показаната цифра, като използваме забавяне, както е показано по-долу

if (flag> = 100) // изчакайте, докато флагът достигне 100 {i ++; flag = 0; // само ако флагът е сто "i" ще бъде увеличен} flag ++; // инкремент флаг за всяка светкавица

Забавянето се използва, така че времето, необходимо за промяна от едно число на друго, е достатъчно дълго, за да забележим промяната.

В пълния код е даден по-долу и на процеса също е обяснено в Видео в края.

Настройка и тестване на хардуер:

Както винаги нека симулираме програмата, използвайки Proteus, преди да започнем с нашия хардуер. Ако симулацията е успешна, трябва да видите нещо подобно

Този проект няма сложна хардуерна настройка, ние отново използваме същата PIC микроконтролерна платка, която сме създали в LED мигащ урок. Просто свържете 7-сегментния модул с вашата платка за микроконтролер PIC съгласно схемата за свързване. След като приключите с връзките, просто изхвърлете кода с помощта на вашия програмист PicKit 3 и това е, че ще се насладите на резултата.