Изследвани основи на микроконтролера

Едно нещо е чудесно за микроконтролерните интегрални схеми, те се предлагат почти във всички части на света и електронните търговци.

Въведение

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

Можете да намерите тези устройства, които се използват за показване на определен параметър, в приложения за управление на двигателя, LED осветление, сензори от различен тип, като сензор за наклон, акселерометър, измервател на скоростта, регистратори на данни, температурни контролери, клавиатури и т.н.

Първичното разбиране по отношение на микроконтролерите може да бъде получено чрез препратка към микроконтролера AVR Amega32, който е толкова напреднал, че понякога се нарича компютър в чипа.

Това устройство е възложено да изпълнява поредица от команди за формиране на програма.

Езикът на програмата, който бихте виждали тук, е C ++. Ще научите този език в по-голяма дълбочина в курса тук.

Що се отнася до MCU, получавате възможност да контролирате и конфигурирате всички негови пиноути.

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

В чип MCU всички щифтове с изключение на Vdd и Vss, които са захранващите щифтове на чипа, могат да бъдат присвоени с изключителни обозначения.

Подробности за пиновете

Ако погледнете чипа отгоре, ще откриете малък триъгълен прорез, който показва началната точка, от която започват пиноутите, и се брои, че пинът №1 на чипа започва точно под този изрез.

Започвайки от този щифт, ще намерите 20 щифта до дъното от тази страна (вляво) и още 20 щифта от другата страна (вдясно), продължавайки отдолу нагоре от дясната страна.

Първите 8 пина, започващи от прореза, са PBO-7, които образуват индексните щифтове на IC, тъй като всички програми тук започват с индекс нула.

Горната серия от изводи се нарича ПОРТ В, докато има други идентични набори от портове, присвоени от А до D.

Тези портове могат да бъдат назначени да приемат и разпознават подадени данни, наречени INPUT, както и да предават данни в някаква определена форма, наречена OUTPUT.

Две от щифтовете, които влизат в общата категория, са (+) / (-) щифтовете, които също се наричат ​​Vdd и GND.

Може да се види един щифт от PORT D (PDO-6), разположен от лявата страна на чипа в долната част.

PD7, който е пин # 7 на PORT D, може да бъде проследен самостоятелно и да започне от серията пиноти от дясната страна.

Сега преминавайки от дясната страна на чипа, където PORT D завършва, PORT C започва броенето си нагоре в реда.

Те допринасят за много интересни щифтове на MCU точно от аналогови до цифрови.

Тези щифтове се превръщат в сензорни входове за откриване на много параметри чрез външно конфигурирани аналогови етапи на веригата.

Горните щифтове представляват ПОРТ А.

Аналогово-цифровото преобразуване през горните щифтове може да бъде разбрано с помощта на пример, при който аналогово температурно ниво, открито с помощта на обикновен сензор като термистър, се прилага към един от щифтовете PORT A, който лесно се приема и преобразува от MCU да се получи цифрово отчитане от нула до 255 градуса F (8-битова цифра, която може да бъде надстроена за постигане на 10-битова изходна мощност).

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

Освен това MCU имат вграден часовник, определен за преброяване на съответните параметри.

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

Досега може би сте разбрали концепцията за микроконтролера до известна степен и по отношение на неговите портове и щифтове.

Как да създам SPI конектор от програмиста към микроконтролера

Сега е време да навлезем малко по-дълбоко в темата и да изследваме света на програмирането.

Като казахме това, преди да се отдадем на процедура за зареждане на програма в чипа, трябва да намерим подходящ начин за интегриране на съединителя SPI (Serial Peripheral Interface) с MCU.

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

Следователно, за да направим нещата абсолютно безупречни, правим процедурите върху мъничък вероборд, в който получаваме необходимите свързващи метални щифтове, наричани също споени „хедър“. Тези щифтове на заглавката вече могат да се използват за свързване със съединителя SPI. Връзките от този хедър могат да бъдат прекъснати към други паралелни щифтове на хедъра, които могат да бъдат използвани за връзките на макета.

По този начин горният монтаж сега формира плътна и надеждна междинна свързваща платформа за SPI към MCU.

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

Може да има множество компании, които произвеждат и продават тези програмисти, така че набавянето им не би трябвало да представлява проблем за вас, като Adafruit Industries, USBtinyISP или Sparkfun и т.н.

Някои от тях могат да изглеждат напълно различни от конвенционалните типове, но в основата си имат всичко идентично и следват стандартните правила за програмиране и могат да се използват като интерфейс между вашия компютър и AVR микроконтролера.

Уверете се обаче, че ако използвате някакъв друг MCU, а не AVR Atmega32, може да се наложи да проверите за съответстващ съвместим програмист за този конкретен MCU чип.

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

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

Осъществяването на обяснената по-горе интерфейсна платка SPI не е трудно, всичко е свързано с това да започнете да работите чрез запояване чрез всички връзки през показаните два заглавни реда щифтове на малка дъска с общо предназначение.

Фигурата по-горе показва подробности за връзката, които би трябвало да следвате, докато свързвате проводниците между заглавките.

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

SPI щифт, започващ отгоре вляво, отива към „Master IN, Slave OUT“ (MISO)

SPI щифт от центъра вляво се свързва с часовника (SCK)

SPI щифтът отдолу вляво се свързва с Reset. (Ще научим подробно за този щифт в следващите уроци)

SPI, отнасящ се за долния десен кукич с GND щифт на MCU, GND се отнася до щифта, който образува нулевата захранваща линия или отрицателната (относителната) шина на захранването.

SPI, завършващ от средната дясна заглавка, се свързва с 'Master Out, Slave IN' (MOSI) щифт на MCU.

SPI, излизащ от горния десен хедър, е свързан с (+) на MCU, което съвсем очевидно е Vdd или положителният захранващ щифт на MCU.

Това е.

Свържете двата конектора, както е обяснено и вашата интерфейсна платка SPI е готова за необходимите действия.

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

Надявам се, че вече сте създали интерфейса SPI, както е обяснено в предишния урок, и сега е време да гарантираме, че нашият компютър приема програмиста, който трябва да интегрираме между компютъра и MCU.

Създаване на прост програмен код за MCU

Вземаме USBTinyISP устройство, предлагано от Sparkfun, за свързване на компютъра с микроконтролера.

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

Нека надникнем в процедурите, необходими за инсталиране на драйверите в операционната система на вашия компютър, тук ще вземем примера на Windows 7 OS с 32-битови или 64-битови спецификации.

Отворете sparkfun.com и кликнете върху „джобна страница на AVR програмист“. Връзката може лесно да се визуализира в рамките на страницата.

След това намерете „Драйвер за Windows“ под документите и просто кликнете върху него.

Това ще ви предостави файла pocketprog-driver.zip във вашия компютър.

Отидете до вашия компютър, намерете мястото за изтегляне и просто разархивирайте изтегления файл в папка.

В случай, че компютърът ви е 64-битова ОС, трябва да изпълните още няколко стъпки, както е дадено по-долу, с 32-битова ОС можете директно да започнете инсталацията от разархивирания файл.

За 64-битово следвайте тези, за 32-битово просто игнорирайте:

Потърсете в Google „libusb sourceforge“ и кликнете върху тази връзка най-новата версия.

Ще попаднете на няколко допълнителни файла, но би ви било интересно да намерите bib файла, а именно: libusb-win32-bin - #. #. #. #. Zip

Сега отидете и намерете това място за изтегляне във вашия компютър, разархивирайте го и го запазете в една от папките.

В тази папка навигирайте над папката bin, като продължите към папката amd64.

Тук ще видите няколко папки като: ghcalled libusb0.dll и libusb0.sys.

Бихте искали да ги преименувате като: libusb0_x64.dll и libusb0_x64.sys.

Сега ще трябва да копирате горните файлове в папката pocketprog-driver, просто презапишете файловете на съществуващата версия.

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

Това е режим „добавяне на наследствен хардуер“.

Щракнете върху „Старт меню“

След това продължете, като щракнете с десния бутон върху „компютър“

Кликнете върху „Управление“ и накрая върху „диспечер на устройства“

След това, в менюто, изберете „Добавяне на стар хардуер“

Продължете да натискате “next”, докато съветникът не се вмъкне

Следвайки инструкциите, щракнете върху „Инсталирайте хардуера, който ще трябва да изберете от разширен списък“, това ще подкани иконата на радио бутона в тази конкретна селекция. Това всъщност е бутон за управление на прозорци, който сега ще изглежда като малък кръг, който има закръглено синьо подаване вътре.

Сега просто щракнете върху „Напред“

Това ще ви покаже менюто „Показване на всички устройства“, което ще трябва да щракнете.

След това продължете да щракнете върху иконата “Have Disk”.

С помощта на иконата „Преглед“ преминете към местоположението на папката pocketprog-driver. Ако изборът е направен правилно от вас, ще визуализирате файла pocketprog.inf, поставен в конкретната папка.

Щракнете двукратно върху този файл и със сигурност ще станете свидетели на инсталирането на драйвера във вашия компютър.

Отново и отвън !! Нека да продължим със следващия урок на следващата страница.

Досега може да сте инсталирали необходимия софтуер и да сте изградили SPI интерфейс.

Как да прехвърля програма в чип на микроконтролер

Следващата стъпка ще изисква няколко компонента като макет, светодиод и изчислен резистор за предвиденото приложение.

В този раздел ще научим метода за тестване на програмиста и ще потвърдим инсталирането на съответните драйвери и софтуера.

За да проверим дали драйверите и софтуерът са инсталирани правилно, ще внедрим проста програма, известна като avrdude.

AVRdude е програма, свързана с най-новата инсталация на WinAVR, без която действителното прехвърляне на файла в MCU не може да бъде възможно.

Тази програма е .hex файлов формат, който по същество става разбираем за MCU за необходимите изпълнения.

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

Нека да видим бързо как можем да приложим процедурата за тестване с помощта на следните инструкции:

Отворете подканата DOS (Дискова операционна система), като щракнете върху „менюто старт“ и напишете cmd.exe в даденото поле за търсене.

Сега извършването на AVRdude може да се извърши, като просто напишете avrdude -c usbtiny -p m32 над DOS подканата. Веднага след като това бъде приложено, DOS незабавно ще потвърди дали връзката е била успешна.

В горната команда „-c“ е уведомителен флаг, който включва спецификацията на параметъра на програмиста „usbtiny“, докато тагът „-p“ идентифицира устройството на микроконтролера („m32, показващо Atmega32).

В случай, че сте използвали различен MCU, ще трябва да включите съответните префикси за изпълнението.

След като горната процедура приключи, можете да напишете „изход“ над подкана на DOS и това ще ви премести от прозореца.

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

Направата на LED платката е много проста, всичко е свързано с запояване на двата извода на LED върху парче veroboard и свързване на резистора с един от изводите на LED. Ролята на този светодиод е само да ограничи тока до светодиода, така че той да не изгори поради излишното напрежение и ток от изхода на MCU.

Стойността на резистора може да се изчисли, като се използва следната проста формула:

R = (Ub - LEDfwd) / I

Когато Ub е захранващото напрежение, LEDfwd е оптималното работно напрежение на използвания светодиод, а I е неговите оптимални усилватели.

Да предположим, че използваме ЧЕРВЕН LED, който има напрежение на светодиода напред = 2.5V и ток I = 20mA, горното уравнение може да бъде решено по следния начин:

Тъй като напрежението от MCU ще бъде 5V, то може да бъде изразено като:

R = (5 - 2,5) /. 02 = 125 ома, ¼ вата, най-близката стойност е 120 ома.

Сега имаме светодиода, 120 омов резистор и veroboard, просто свързваме горните компоненти, както е дадено на схемата с микроконтролера.

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

След това програмирането на MCU.

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

Как да инсталирате среда за програмиране и да проучите WinAVR

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

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

В крайна сметка това ще бъде подкрепено от WinAVR и прехвърлено в съответния MCU чип.

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

Бихте предпочели, че курсът на инсталиране на WinAVR е изключително бърз и бърз. Нека да се потопим в детайлите със следните точки:

Ще трябва да изтеглите най-новите версии от папката с подправени файлове на WinAVR. Ще намерите полезна информация, свързана с това изтегляне, от официалния му уебсайт.

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

Изтеглете файла и започнете процеса на изпълнение, като кликнете върху него. Оставете инсталацията да започне.

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

Досега бихте намерили всичко съвсем нормално и лесно и ще намерите няколко опции в менюто за стартиране, което ви хвърлят. Не се притеснявайте, само някои от тях всъщност ще използват само един от тем, наречен „програмист бележник“.

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

Основната работа на горния бележник на програмист е да трансформира читав за човека код, който бихте написали, в поредица от инструкции, разбираеми само за MCU.

Следващият урок ще обхване тестването на горния програмист, за да можем да бъдем сигурни по отношение на неговата съвместимост с Windows и дали той перфектно се „ръкува“ с вашата микроконтролерска интегрална схема.

Как да програмирате MCU за включване на светодиод

След като това се потвърди, ще пристъпим към създаването на малък код „не правете нищо“, само за да гарантираме, че процедурата за прехвърляне на код не среща грешки.

Разбира се, вече сме готови да внедрим първата си програма в MCU, но преди това би било интересно бързо да обобщим това, което направихме по време на предишните ни уроци:

Ние набавихме микроконтролера AVR Atmel в съответствие с необходимата ни спецификация, тук използвахме ATMega32 за илюстрациите. След това научихме за основите на микроконтролера и модула за програмиране, който е отговорен за прехвърлянето на програма в чипа MCU.

Освен това изградихме интерфейсния конектор SP, който е от съществено значение, за да може компютърът ви да бъде свързан с микроконтролера за програмиране.

След това потвърдихме дали драйверите са инсталирани правилно в компютъра за 32-битова, както и 64-операционна система.

След това инсталирахме средата за програмиране, наречена Win AVR, за улесняване на лесното писане на рекламен трансфер на кодовете в микроконтролера, последвано от внедряването на avrdude за проверка на програмиста с вашия компютър и взаимосвързания микроконтролер.

Накрая в предишната глава завършихме изграждането на веригата LED / резистор и го свързахме със съответните MCU изходи.

Това наистина е много работа, но е време да се насочите веднага към някои истински програмисти!

Като начало бихме искали да разделим микроконтролера на три категории, това би опростило много разбирането ни:

Контрол, откриване и комуникация

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

В първата ни програма бихме се опитали да наредим на микроконтролера да „контролира” външен параметър, да, прав сте, това би бил светодиодът, който изградихме наскоро.

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

Продължаването на настоящата работа, като накарате MCU да управлява светодиода, всъщност е доста просто:

За това инструктираме щифт # 0 на ПОРТ B да произведе необходимите 5V за светодиода.

Спомнете си от предишния урок, ние свързахме анода на светодиода към гореспоменатия щифт на MCU.

Има две основни неща, които трябва да бъдат адресирани към този щифт на MCU: 1) изход и 2) 5 волта

Ще научим начин, чрез който можем да инструктираме конкретния щифт да се превърне в изход на MCU.

След като бъде зададен да бъде изход на чипа, може да го инструктираме да бъде или „висок“ (5V), или „нисък“ (0V), както желаете за дадено приложение.

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

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

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

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

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

Използвайки DDR, можем да настроим пина да изпраща данни, които са като „изход“, или да приемаме данни, които са под формата на „вход“.

Въпреки това може да сте объркани по отношение на думата, какво означава това? Данните добавят трето измерение към щифтовете, които могат да бъдат присвоени непрекъснато на логическа нула (0V) или логически висока (5V), но какво да кажем за сигналите, които могат да варират бързо, като честота на импулсите. Честотата ще бъде придружена от високи и ниски логики (5V и 0V), осцилиращи с някои определени интервали или периоди, като по този начин тя става ориентирана към времето и може да бъде коригирана по отношение на времето, затова ние определяме като „данни“, което означава параметър, който показва функция спрямо друга функция (логически състояния и време).

Един метод за присвояване на pin0 като изход е чрез писане на следния код:

DDRB = 0b00000001

В горната програма DDRB означава регистър за насочване на данни за ПОРТ B 0b инструктира компилатора относно следния двоичен израз на число, докато „1“ в края на израза показва позицията на pin0, т.е. това е местоположението във формата на първия щифт на PORT B.

Ако си спомняте, научихме, че PORT B ​​свързва 8 пина с него (от 0 до pin7) и ако забележите, че горният код също има 8 цифри в себе си, което означава, че всяка цифра означава тези 8 пина на PORT B.

Следващата процедура би била да се присвои 5V на този щифт (pin0). Отново принципът на работа е идентичен с DDR, както е по-горе, изразен чрез следния двоичен код:

PORTB = 0b00000001

Както се вижда, единствената разлика между горния код и по-ранния е, че в този код сме използвали PORT регистъра. Този регистър специално обработва назначенията на щифтове на конкретния порт, за който е разположен вътре в MCU. По този начин тя ни позволява да присвоим реалните логики на данните (0 или 1) за тези пиноти.

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

'Основната' функция тук е мястото, където всяка от програмите C / C ++ инициира изпълнението. Следователно основният може да бъде създаден като:

int main (void)
{
}

За да се даде възможност на програмата да интерпретира данните за регистъра DDR и PORT и тяхното функциониране в чипа MCU, трябва да бъде включен допълнителен отчет, който може да се състои от всички данни относно AVR MCU. Може би бихме искали да добавим това включване във всички наши програми.

#include
int main (void)
{
}

Веднага след като компилацията стартира, секцията за предварително обработване на компилатора се фокусира върху директорията AVR, за да идентифицира файла „io.h“. Разширението „.h“ тук показва, че това е заглавен файл и че този код вътре във файла ще бъде въведен в началото (head) на изходния файл, който се създава, оттук и името „header“.

Тук можем да въведем DDR и PORT изразите в нашия код, защото добавянето на заглавния файл io.h би насочило компилатора към тях.

#include

int main (void)

{

DDRB = 0b00000001 // Настройка на регистър за насочване на данни pin0 за извеждане и останалите щифтове като вход

PORTB = 0b00000001 // Задайте pin0 на 5 волта

}

Горното фиксира ориентацията на pin0 като изход, имащ магнитуд 5V. Въпреки това все още има един проблем, който не е определен за този пин, т.е. този пин все още не е инструктиран да бъде включен за неопределено време, докато MCU е захранван. Този безкраен цикъл на обратна връзка би гарантирал, че този щифт от MCU не се изключва, а продължава с 5V изход за неопределено време.

Въпреки че има много различни методи за прилагане на инструкция за цикъл за пин, ние бихме се опитали да използваме цикъла “while” тук. Както подсказва името, цикълът “while” казва на микроконтролера, че “докато” захранването е на разположение, трябва да останете активирани със зададените 5V за назначения пиноут.

#include

int main (void)

{

DDRB = 0b00000001 // Настройка на регистър за насочване на данни pin0 за извеждане и останалите щифтове като вход

PORTB = 0b00000001 // Задайте pin0 на 5 волта

докато (1)

{

// Кодът ще бъде тук, ако трябва да се изпълнява отново и отново и отново ... безкрайно

}

}

Може да искате да отбележите, че тук използваме „1“ под формата на аргумент за цикъла „while“, тъй като всичко с изключение на „0“ може да се счита за логично „вярно“.

Това предполага, че разглеждането на цикъла „while“ никога не би било отговорно за нищо, освен за логическо „true“, което означава, че конкретният щифт би се фиксирал с определеното състояние за неопределено време.

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

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

В следващите уроци ще научим как да добавим измерение „време“ към горния светодиод, т.е. как да го накараме да мига с определена определена скорост.

Всъщност в горното изпълнение светодиодът всъщност мига, но скоростта на контура е толкова бърза, че е почти като постоянно включване на светодиодното осветление.

Ще видим как този цикъл може да бъде добавен със закъснение, както желаете, за да накара LED да мига при тази забавена скорост.

Как да направите LED мига с помощта на AVR микроконтролер

В последната дискусия научихме как да направим LED превключвател ВКЛЮЧЕН чрез микроконтролер, беше страхотно, нали? Може да не е толкова много!

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

Нека разгледаме това:

#include

#include

int main (void)

{

DDRB | = 1<< PINB0

докато (1)

{

PORTB ^ = 1<< PINB0

_delay_ms (100)

}

}

Ако се чувствате объркани с онези странни символи (&, ^, | и т.н.), използвани в горния израз (& не е там, но може да се използва в други подобни кодове), ето свързаната информация, която би ви било интересно да знаете за тях :

Той включва много стандартни логически алгоритми като AND, OR, NOT и XOR, които обикновено се използват с горния код.

Тази логическа функционалност конкретно сравнява двата бита '1' и '0' според присвоените им таблици на истината.

Ще получим идея, като анализираме следното подреждане на битовете:

01001011 &
10001101
равно на
00001001

В горния код & се отнася до И, както се използва при програмиране на C.

Четенето на редовете вертикално предполага, че 0 и 1 е равно на 0, 1 и 0 също е равно на 0, 0 и 0 е равно на 0, 1 и 1 е равно на 1. Четенето му е толкова просто, колкото това. Те са според таблицата на истината на оператор И.

Ако оценим следната таблица, тя показва символа '|' обозначаващ използването на функционалността „ИЛИ“, „|“ може да се намери точно отляво на „backspace“ в клавиатурата на компютъра ви:

01001011 |
10001101
равно на
11001111

По същия начин тази таблица на истината за логическа функционалност на ИЛИ показва, че битове 0 или 1 са равни на 1, 1 или 0, също е равно на 1, 0 или 0 е равно на 0, докато 1 или 1 е равно на 1.

Следващата комбинация от битове е за логически оператор XOR, обозначен с ^ и може да се изучава точно както направихме с таблиците ИСТИНА ИЛИ ИЛИ:

01001011 ^
10001101
равно на
11000110

Сега нека да продължим с първата програма и да научим какво означава следният ред в нея:

#include

Чрез нашите предишни уроци знаем как функционира изразът, така че няма да го повтаряме, но изглежда, че те са ново „включване“, изразено чрез #include, което трябва да бъде проучено.

В това „включване“ delay.h ни позволява някои лесни методи за изпълнение.

Както подсказва името, delay.h ни позволява да предизвикаме забавяне в конкретната програма.

Следващият израз int main (void) може да бъде пропуснат от продължаващата дискусия, тъй като вече сме го обхванали в предишните си публикации.

Следва изменената DDRB.

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

DDRB = 0b00000001

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

DDRB = DDRB | 0b00000001

Тук той е забулен с маска „ИЛИ“: 0b00000001, въпреки че изглежда доста автентичен двоичен номер, в случай че по-ранната DDRB например: 0b01001010, след това прилагането на ИЛИ към това чрез маскиране може да даде: 0b01001010 | 0b00000001 = 0b01001011.

Резултантната разлика, която може да се види, е само при pin0, чиито битове са се променили!

Компресирането на горното изявление още повече чрез C ++ дава:

DDRB | = 0b00000001

Откриваме обаче, че в дадената програма има още повече. Въпреки че може да изглежда съвсем легитимно и очевидно, трябва да се възползваме от някои от изявленията от заглавния файл io.h, особено когато той е създаден основно за наше удобство?

Така че, ако „DDRB | = 1<< PINBO, why it’s like that?

1<< PINBO is implemented for applying the masking effect. The “1” indicates what may be introduced inside the mask, while the < < is simply the left shift functionality. It executes exactly as it’s named, and PINBO is the number of locations that the “1” would sequence across the left hand side. To be precise PINBO may be equivalent of a 0.

Така че започваме с 0b00000000 и поставяме „1“, за да произведем 0b0000001 и след това го прехвърляме на ляво 0 позиции, което дава точно идентичен 0b00000001, както по-горе.

Сега, ако предположим, че е PINB4, изявлението може да бъде изразено като 1<< PINB4. I this case the “1” would be pushed to the left 4 locations producing: 0b00010000.

Внимавайте, ние използваме нулев индекс, което означава, че след „1“ има четири нули.

Сега пристъпвайки към цикъла „while“, по-рано отбелязахме през „безкрайния цикъл“. Но може би сега искаме микроконтролерът да приложи някои от желаните изпълнения. Това може да е осъществимо само в дадения цикъл. Това е цикълът, в който конкретната последователност се повтаря отново и отново.

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

Въпреки това, за да накара LED да мига безкрайно, ще е необходимо да включите / изключите PINB0 последователно в рамките на контура. Тук също намираме въвежданите закъснения, без които мигането на светодиода би било невъзможно. Но това би принудило светодиода да мига с много бърза скорост, която е трудно да се разпознае с невъоръжено око, ще трябва да забави малко, за да се разпознае с очите ни.

Наясно сме с процедурата за настройка на определен бит в двоичното число, но не сме сигурни, че методът за прилагане на конкретен бит „0“, в случай че все още е „1“.

Следващата програма може да бъде видяна да прави това, но също така ще открием, че тя може да не се вижда в програмата.

Първоначалните две твърдения променят бита на „1“ (5V, LED светлини), след което се въвежда пауза за 100 ms.

Следващите няколко реда превръщат бита PINB0 в „0“ (нулево напрежение, светодиодът е изключен), но съжалявам, че сравнението И няма да може да изпълни „0“ от бита, но ако използваме НЕ „~“ за двоичната маска тя може да превключва всички 0s в 1s и обратно.

Това ще ни позволи да въздействаме само на бита PINB0 и да го обърнем на „0“. Скобата беше включена, за да съдържа изпълнението на маскиране, така че операцията NOT да може да се приложи за всички маски, а не просто над „1“ преди лявата смяна „<<”.

PORTB | = 1<< PINB0
_delay_ms (100)
PORTB & = ~ (1<< PINB0)
_delay_ms (100)

За да създадем закъснения ON OFF или периоди с еднаква продължителност, можем да съкратим предишните четири реда на две и да приложим XOR функционалност в наша полза. Трябва да се отбележи при изпълнение на XOR присвоен пин на 1, в случай че е 0 и обратно. Това изпълнение би повлияло само на PINB0. Както може да се приложи командата, тя просто би превърнала бита в обратното на съществуващата логика.

PORTB ^ = 1<< PINB0
_delay_ms (100)

СВЪРШЕН! Вашият светодиод ще мига сега според зададената скорост ... Просто, нали?