Урок за асемблер на AVR 9: 7 стъпки

2024 Автор: John Day | [email protected]. Последно модифициран: 2024-01-30 07:49

Добре дошли в Урок 9.

Днес ще покажем как да управляваме както 7-сегментен дисплей, така и 4-цифрен дисплей, използвайки нашия код за сглобяване ATmega328P и AVR. В хода на това ще трябва да вземем отклонения за това как да използваме стека, за да намалим броя на регистрите, които трябва да свържем. Ще добавим няколко кондензатора (нискочестотни филтри), за да се опитаме да намалим шума на нашата клавиатура. Ще създадем усилвател на напрежение от няколко транзистора, така че нашият прекъсвач INT0 да работи по -добре за бутоните с по -ниско напрежение в долния ред на клавиатурата. И ние ще ударим главата си в стената малко, опитвайки се да намерим правилните резистори, така че нещото да работи правилно.

Ще използваме нашата клавиатура от Урок 7

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

1. 7-сегментен дисплей

   www.sparkfun.com/products/8546

2. 4-цифрен дисплей

   www.sparkfun.com/products/11407

3. Бутон за натискане

   www.sparkfun.com/products/97

4. Информационните листове за дисплея, които могат да бъдат изтеглени от съответните им страници, свързани по -горе.
5. Керамичен кондензатор 68 pf, няколко 104 кондензатора, куп резистори, два 2N3904 NPN транзистора.

Ето линк към пълната колекция от моите уроци за AVR асемблер:

Стъпка 1: Окабеляване на 7-сегментния дисплей

Ще използваме същия код, който използвахме в Урок 7 за клавиатурата за управление на 7-сегментния дисплей. Така че ще трябва да направите копие на това и ние ще го променим.

Ще картографираме сегментите към щифтовете на нашия микроконтролер, както следва:

(dp, g, f, e, d, c, b, a) = (PD7, PD6, PB5, PB4, PB3, PB2, PB1, PB0)

където буквите на сегментите са показани на снимката заедно с извода, съответстващ на общите 5V и всеки от LED сегментите, включително десетичната запетая (dp) в долния десен ъгъл на дисплея. Причината за това е, че можем да въведем целия номер в един регистър и да изведем този регистър към портове B и D, за да осветим сегментите. Както можете да видите, битовете са номерирани последователно от 0 до 7 и така те ще се съпоставят с правилните щифтове, без да се налага да задавате и изчиствате отделни битове.

Както можете да видите от кода, който сме прикачили в следващата стъпка, ние сме преместили нашата рутина за показване на макрос и сме освободили щифтовете SDA и SCL за бъдеща употреба в следващия урок.

Трябва да добавя, че трябва да поставите резистор между общия анод на дисплея и 5V шината. Избрах резистор от 330 ома, както обикновено, но ако искате, можете да изчислите минималното съпротивление, необходимо, за да извадите максималната яркост от дисплея, без да го пържите. Ето как да направите това:

Първо погледнете информационния лист и забележете, че на първата страница той дава различни свойства на дисплея. Важните величини са "Продължителен ток" (I_f = 20mA) и "Предна напрежение" (V_f = 2.2V). Те ви казват, че искате спадът на напрежението на дисплея да бъде, ако токът е равен на тока напред. Това е максималният ток, който дисплеят ще поеме без пържене. Следователно това е и максималната яркост, която можете да получите от сегментите.

Така че нека използваме закона на Ом и правилото на цикъла на Кирчоф, за да разберем какво минимално съпротивление ще трябва да поставим последователно с дисплея, за да получим максималната яркост. Правилото на Кирхоф казва, че сумата от промените в напрежението около затворен контур във верига е равна на нула, а законът на Ом казва, че спадът на напрежението в резистор на съпротивление R е: V = I R, където I е токът, протичащ през резистора.

Така че, като се има предвид източник на напрежение V и обикаляне на нашата верига, имаме:

V - V_f - I R = 0

което означава (V - V_f)/I = R. Така че съпротивлението, необходимо за получаване на максимална яркост (и вероятно пържене на сегментите), ще бъде:

R = (V - V_f)/I_f = (5.0V - 2.2V) /0.02A = 140 ома

Така че, ако искате, можете с удоволствие да използвате 150 ома без притеснения. Въпреки това, мисля, че 140 ома го прави твърде ярък, за да ми хареса и затова използвам 330 ома (което е нещо като моята лична устойчивост на Златокоска за светодиоди)

Стъпка 2: Код на сглобяване и видео

Прикачих кода за сглобяване и видео, показващо работата на клавиатурата с дисплея. Както можете да видите, ние просто сме пренасочили ключа за повторно набиране към "r", ключа за флаш към "F", звездичката до "A" и знака за хеш към "H". Те могат да бъдат съпоставени с различни операции като backspace, enter и какво ли още не, ако искате да продължите да използвате клавиатурата за въвеждане на номера на LCD дисплеи или 4-цифрени дисплеи. Този път няма да разглеждам кода ред по ред, тъй като той е много подобен на това, което вече направихме в предишните уроци. Разликите са само повече от същите неща, които вече знаем как да правим, като прекъсвания и таблици за търсене. Просто трябва да преминете през кода и да разгледате новите неща, които сме добавили, и нещата, които сме променили, и да го разберете от там. Ще се върнем към анализ по ред в следващия урок, когато въведем нови аспекти на кодирането на асемблерен език на AVR микроконтролери.

Нека сега разгледаме 4-цифрен дисплей.

Стъпка 3: Окабеляване на 4-цифрения дисплей

Според листа с данни, 4-цифреният дисплей има преден ток от 60 mA и напрежение напред от 2,2 волта. Така че, по същото изчисление, както преди, бих могъл да използвам 47 омов резистор, ако искам. Вместо това ще използвам … hrm.. нека да видя … какво ще кажете за 330 ома.

Начинът, по който 4-цифреният дисплей е свързан, е, че има 4 анода, по един за всяка от цифрите, а другите пинове контролират кой сегмент се включва във всеки. Можете да показвате 4 цифри едновременно, защото те са мултиплексирани. С други думи, точно както направихме за двойката зарове, ние просто циклично захранваме през всеки от анодите на свой ред и той ще ги мига един след друг. Това ще стане толкова бързо, че очите ни няма да видят мигането и ще изглежда, че и четирите цифри са включени. Въпреки това, за да сме сигурни, начинът, по който ще го кодираме, е да зададем и четирите цифри, след това да циклираме анодите, вместо да задаваме, преместваме, задаваме, преместваме и т.н. По този начин можем да получим точно време между осветяването на всяка цифра.

Засега нека тестваме дали всички сегменти работят.

Поставете своя 330 омов резистор между положителната релса на вашата дъска и първия анод на дисплея. Информационният лист ни казва, че щифтовете са номерирани от 1 до 16 обратно на часовниковата стрелка, започвайки от долния ляв ъгъл (когато гледате дисплея нормално.. с десетичните точки по дъното) и посочва, че анодите са пинови номера 6, 8, 9 и 12.

Така че свързваме щифт 6 към 5V и след това вземаме отрицателен проводник от вашата GND шина и го забиваме във всички останали щифтове и виждаме, че всички сегменти светват на цифрата, на която съответства (което всъщност е втората цифра от десния). Уверете се, че всичките 7 сегмента и десетичната запетая светват.

Сега залепете вашия GND проводник в един от щифтовете, за да светне един от сегментите и този път преместете резистора наоколо към другите 3 анода и вижте, че същият сегмент светва във всяка от другите цифри.

Нещо необичайно?

Оказва се, че изводът в листа с данни е грешен. Това е така, защото това е лист с данни и извод за 12-пинов, 4-цифрен дисплей. Т.е. такъв без двоеточие или горна десетична точка. Дисплеят, който получих, когато поръчах, е 16-пинов, 4-цифрен дисплей. Всъщност, при мен сегментните аноди са на пинове 1, 2, 6 и 8. Анодът на дебелото черво е щифт 4 (катоден щифт 12), а горният dp анод е щифт 10 (катодът е щифт 9)

Упражнение 1: Използвайте резистора и заземяващия проводник, за да определите кой щифт съответства на кой сегмент и десетична запетая на дисплея, за да получим правилните сегменти да светят, когато го кодираме.

Начинът, по който искаме да кодираме сегментната карта, е точно както направихме с едноцифрения 7-сегментен дисплей по-горе-не е нужно да променяме нещо в кода, единственото нещо, което променяме, е как са свързани проводниците на борда. Просто включете правилния портов щифт на микроконтролера към съответния щифт на 4-цифрения дисплей, така че например PB0 все още отива към щифта, съответстващ на сегмент a, PB1 отива в сегмент B и т.н.

Единствената разлика е, че сега имаме нужда от 4 допълнителни щифта за анодите, тъй като вече не можем просто да отидем до 5V шината. Нуждаем се от микроконтролера, за да решим коя цифра получава сока.

Така че ще използваме PC1, PC2, PC3 и PD4 за контрол на анодите на 4 -те цифри.

Можете също така да продължите и да включите кабелите. (не забравяйте резисторите 330 ома на анодните проводници!)

Стъпка 4: Кодиране на 4-цифрения дисплей

Нека помислим как искаме да кодираме този дисплей.

Бихме искали потребителят да натисне бутоните на клавиатурата и номерата да се показват последователно на дисплея, когато натискат всеки бутон. Така че, ако натисна 1, последвано от 2, той ще се покаже на дисплея като 12. Бих искал също да съхраня тази стойност, 12, за вътрешна употреба, но ще стигнем до това малко по -късно. Засега просто искам да напиша нов макрос, който взема вашите клавиши и ги показва. Въпреки това, тъй като имаме само 4 цифри, искам да се уверя, че ви позволява да въвеждате само четири числа.

Друг проблем е, че начинът на работа на мултиплексирания 4-цифрен дисплей е чрез циклиране на анодите, така че всяка цифра да е включена само за част от секундата, преди да покаже следващата, а след това следващата и накрая отново към първата и т.н. имам нужда от начин да кодирам това.

Искаме също така да премести „курсора“надясно на интервал, когато въвеждаме следващата цифра. Така че, ако искам да напиша 1234 например, след като въведа 1, курсорът ще се премести, така че следващата цифра, която въвеждам, ще се появи на следващия 7-сегментен дисплей и така нататък. През цялото време, докато това се случва, все още искам да мога да видя какво съм написал, така че все още трябва да се движи през цифрите и да ги показва.

Звучи като голяма поръчка?

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

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

Стъпка 5: Push 'n Pop

Имаме само няколко "Регистъра за общо предназначение", с които разполагаме и след като бъдат използвани, вече няма. Така че е добра програмна практика да ги използвате само за няколко променливи, които се използват като временно хранилище, от което се нуждаете за четене и писане в, портове и SRAM, или други, които ще ви трябват в подпрограми навсякъде и така вие назовете ги. Така че това, което направих, сега, когато сме инициализирали и се научаваме да използваме Stack, е да преминем през кода и да намерим наименованите регистри с общо предназначение, които се използват само вътре в една подпрограма или прекъсват и никъде другаде в кода и не заменят ги с един от нашите временни регистри и натискане и пускане в стека. Всъщност, ако погледнете кода, написан за по -малки микроконтролери, или ако се върнете назад във времето, когато всички чипове бяха по -малки, ще видите само няколко регистри с общо предназначение, които трябваше да се използват за всичко, така че не можете просто съхранявайте стойност там и я оставете на мира, тъй като със сигурност се нуждаете от този регистър за други неща. Така че ще видите бутане и изскачане навсякъде в кода. Може би трябваше да нарека нашите временни регистри с общо предназначение AX и BX като уважителна благодарност към онези отминали дни.

Пример ще помогне да стане по -ясно това.

Забележете, че в нашето аналогово -цифрово преобразуване пълно прекъсване ADC_int използваме регистър с общо предназначение, който сме кръстили buttonH, който използвахме за зареждане на стойността на ADCH и го сравняваме с нашата таблица за търсене на преобразувания на аналогови бутони. Ние използваме само този регистър buttonH в подпрограмата ADC_int и никъде другаде. Така че вместо това ще използваме нашата променлива temp2, която използваме като временна променлива, която можем да използваме в рамките на всяка подпрограма и нейната стойност няма да повлияе на нищо извън тази подпрограма (т.е. стойността, която й даваме в ADC_int, няма да се използва никъде друго).

Друг пример е в нашия макрос за забавяне. Имаме регистър, наречен „милисекунди“, който съдържа времето за забавяне в милисекунди. В този случай той е в макрос и ние припомняме, че начинът на работа на макроса е, че асемблерът поставя целия макро код в мястото на програмата, където е извикан. В този случай бихме искали да се отървем от променливата "милисекунди" и да я заменим с една от нашите временни променливи. В този случай ще го направя малко по -различно, за да ви покажа как дори стойността на променливата да е необходима на друго място, все още можем да я използваме, като използваме стека. Така че вместо милисекунди използваме "temp" и за да не прецакаме други неща, които също използват стойността на temp, просто започваме макроса "delay", като "натискаме" temp към стека, след което го използваме вместо милисекунди, а след това в края на макроса "изскачаме" предишната му стойност обратно от стека.

Нетният резултат е, че сме "заели" temp и temp2 за временно ползване и след това ги възстановихме до предишните им стойности, когато приключим.

Ето рутината за прекъсване ADC_int след извършване на тази промяна:

ADC_int:

температура на натискане; запазване на темп, тъй като го променяме тук push temp2; запишете temp2 lds temp2, ADCH; зареждане на клавиша ldi ZH, високо (2*числа) ldi ZL, ниско (2*числа) cpi temp2, 0 breq return; ако шумовите тригери не променят 7segnumber setkey: lpm temp, Z+; зареждане от таблица и инкремент на пост clc cp temp2, temp; сравнете натискането на клавиш с таблицата brlo PC+4; ако ADCH е по -нисък, опитайте отново lpm 7segnumber, Z; в противен случай заредете keyvalue таблица inc цифра; увеличете цифрата rjmp връщане; и връщане назад ZH: ZL, 1; прирастване Z rjmp setkey; и се върнете към началото връщане: pop temp2; възстановяване на temp2 pop temp; възстановяване на temp reti

Забележете, че начинът на работа на стека е, че първото включване е последното изключване. Точно като купчина документи. Виждате, че в първите ни два реда натискаме стойността на temp към стека, след това натискаме temp2 към стека, след което ги използваме в подпрограмата за други неща и накрая ги възстановяваме до предишните им стойности чрез първото изскачане на temp2 off (тъй като беше последното натиснато върху него, е в горната част на стека и ще бъде първото, което ще отскочим) и след това ще се появи temp.

Така че отсега нататък винаги ще използваме този метод. Единственият път, когато действително ще определим регистър за нещо различно от временна променлива, е когато ще имаме нужда от нея навсякъде. Например регистърът, наречен "препълнения", е този, който използваме на няколко различни места в програмата и затова бихме искали да му дадем име. Разбира се, все още бихме могли да го използваме по начина, по който сме го направили с temp и temp2, тъй като бихме възстановили стойността му, след като приключим. Но това би спагетирало твърде много нещата. Те са кръстени по някаква причина и ние имаме temp и temp2 вече определени за тази работа.

Стъпка 6: Нискочестотни филтри и усилвател на напрежение

За да премахнем малко шума и да подобрим работата на клавиатурата, искаме да добавим няколко нискочестотни филтъра. Те филтрират високочестотния шум и позволяват преминаването на нискочестотния сигнал. По същество начинът да направите това е просто да добавите 68 pf кондензатор между нашия аналогов вход и земя, както и 0,1 микрофарад (т.е. 104) кондензатор между нашето PD4 (INT0) прекъсване и земя. Ако играете с тях, докато натискате бутони на клавиатурата, ще можете да видите какво правят.

След това искаме да направим усилвател на напрежение. Оказва се, че долният ред клавиши на клавиатурата (както и клавиша за повторно набиране) излагат твърде ниско напрежение, за да прекъснат прекъсването INT0. Аналоговият порт е достатъчно чувствителен, за да прочете ниското напрежение от тези клавиши, но прекъсващият ни щифт не получава достатъчно добър нарастващ ръб, който да прекъсва, когато натискаме тези клавиши. Следователно бихме искали някакъв начин да се уверим, че приятният нарастващ ръб на напрежението удари PD4, но същото ниско напрежение удари ADC0. Това е доста висок ред, тъй като и двата сигнала идват от един и същ изходен проводник на нашата клавиатура. Има редица сложни начини да направите това, но няма да използваме нашата клавиатура повече след този урок, така че нека просто съберем заедно един метод, който работи (едва ли).

Първо трябва да свържете външен бутон, за да замените прекъсването INT0 и да контролирате дисплея, като задържите клавиш на клавиатурата и щракнете върху бутона. Това има по-малко проблеми с клавиатурата и ще ви позволи да сте сигурни, че вашите напрежения са зададени правилно в таблицата за търсене на клавиатурата. След като разберете, че клавиатурата е свързана правилно, отървете се от бутона и върнете прекъсването INT0 обратно. Има някои сериозни проблеми с шума и напрежението, които контролират клавиатурата по този начин, така че е добре да знаете, че всичко работи, така че бъдещите проблеми могат да бъдат изолирани към клавиша INT0.

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

Ако погледнете диаграмата, която съм приложил към тази стъпка, ще видите как ще работи усилвателят на напрежението. Използваме някои резистори и два транзистора. Начинът, по който работят транзисторите (вижте информационните листове!) Има ли минимално напрежение, което трябва да въведете към основния щифт на транзистора (средния щифт), което ще го насити и ще позволи ток да тече между колекторния щифт и излъчвателя щифт. В случая на транзистора 2N3904, който използваме тук, напрежението е 0.65V. Сега вземаме това напрежение от изхода си от клавиатурата и не искаме да променяме този изход, така че ще поставим голям резистор между изхода от клавиатурата и основата на първия транзистор (използвах 1Mohm). Обозначих това като R_1 в диаграмата. След това искаме да настроим делител на напрежение, така че основата на транзистора да е "почти" при 0,65 волта и само малко, малко повече ще го избута отгоре и ще го насити. Този малък мъничък бит ще дойде от изхода на клавиатурата, когато натиснем бутон. Тъй като долните клавиши на клавиатурата излъчват само малко напрежение, трябва да сме много близо до насищането, за да са достатъчни. Резисторите на разделителя на напрежението са обозначени с R_a и R_b на диаграмата. Използвах R_a = 1Mohm и R_b = 560Kohm, но е почти сигурно, че ще трябва да си поиграете с тези числа, за да се справите правилно с вашата настройка. Може да искате да имате стена наблизо, за да си ударите главата и две или три чаши скоч на ръка (бих препоръчал Laphroaig - скъп, но си струва, ако обичате да пушите. Ако нещата станат наистина луди, тогава просто вземете кана на BV и се настани за през нощта)

Сега нека разгледаме как транзисторите ще ни донесат приятно нарастващо предимство при влизане в ключа INT0 и генериране на нашето прекъсване при натискане на клавиш. Първо нека разгледаме какво се случва, когато не натискам клавиш. В този случай първият транзистор (обозначен с T1 на диаграмата) е изключен. Така че между щифтовете на колектора и излъчвателя не тече ток. Така основата на другия транзистор (обозначен с Т2) ще бъде издърпана високо и по този начин тя ще се насити, позволявайки на тока да тече между щифтовете му. Това означава, че излъчвателят на T2 ще бъде изтеглен ниско, тъй като е свързан към колектора, който сам е свързан със земята. По този начин изходът, който отива към нашия щифт за прекъсване при натискане на клавиш INT0 (PD4), ще бъде нисък и няма да има прекъсване.

Какво се случва, когато натисна клавиш? Е, тогава основата на T1 отива над 0,65V (в случая на долните клавиши едва надвишава!) И тогава ще бъде позволено да тече ток, който ще издърпа основата на T2 до ниско напрежение и това ще изключи T2. Но ние виждаме, че когато T2 е изключен, тогава изходът се издърпва високо и следователно ще получим 5V сигнал, отиващ към нашия щифт INT0 и това ще предизвика прекъсване.

Забележете какъв е нетният резултат тук. Ако натиснем клавиша 1, получаваме 5V към PD4, без да променяме значително изхода към ADC0, и по -важното е, че дори да натиснем звездичка, 0, Hash или Redial, също получаваме 5V сигнал към INT0 и също причинява прекъсване! Това е важно, тъй като ако просто преминем директно от изхода на клавиатурата към щифта INT0, тези клавиши не генерират почти никакво напрежение и няма да са достатъчни, за да задействат този прекъсвач. Нашият усилвател на напрежение е решил този проблем.

Стъпка 7: 4-цифрен код на дисплея и видео

Това е всичко за урок 9! Прикачих кода и видео, показващо операцията.

Това ще бъде последният път, когато ще използваме аналоговата клавиатура (слава богу). Беше трудно да се използва, но също така беше много полезно да ни помогне да научим за аналогово-цифровото преобразуване, аналоговите портове, прекъсванията, мултиплексирането, шумовите филтри, усилвателите на напрежението и много аспекти на асемблиращото кодиране от таблици за търсене до таймер/броячи и т.н. Затова решихме да го използваме. (плюс това е забавно да изчиствате неща).

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

След като комуникациите работят и ролките се показват на дисплеите, най -накрая можем да направим първото парче от нашия краен продукт. Ще забележите, че без всички аналогови портове, нашият код ще бъде значително по -кратък и вероятно по -лесен за четене.

За тези от вас, които са амбициозни. Ето един „проект“, който бихте могли да опитате, който със сигурност имате знанията да направите в този момент, ако сте преминали през всички тези уроци до този момент:

Проект: Направете калкулатор! Използвайте нашия 4-цифрен дисплей и нашата клавиатура и добавете външно натискане на бутон, който ще действа като клавиш „enter“. Съпоставете звездичката с „времена“, хешът за „разделяне“на повторното набиране на „плюс“и светкавицата на „минус“и напишете програма за калкулатор, която действа като един от онези стари калкулатори на HP за „обратно полиране“, които всички инженери имаха едно време. Т.е. начинът, по който те работят, е, че въвеждате номер и натискате "enter". Това избутва това число в стека, след което въвеждате второ число и натискате „enter“, което избутва второто число към стека. Накрая натискате една от операциите като X, /, + или - и тя ще приложи тази операция към първите две числа в стека, ще покаже резултата и ще натисне резултата върху стека, така че да можете да го използвате отново, ако като. Например, за да добавите 2+3, бихте направили: 2, "enter", 3, "enter", "+" и на дисплея след това ще се чете 5. Вие знаете как да използвате стека, дисплея, клавиатурата и вие повечето от фоновия код вече са написани. Просто добавете клавиша enter и подпрограмите, необходими за калкулатора. Това е малко по-сложно, отколкото си мислите в началото, но е забавно и изпълнимо.

До следващия път!