Microcontroller Basics onderzocht

Eén ding is geweldig aan microcontroller-IC's, deze zijn bijna overal ter wereld en in elektronische winkels verkrijgbaar.

Invoering

In wezen worden microcontroller-apparaten in de volksmond gebruikt in toepassingen met beoordelingen van de omgeving en in soortgelijke elektronica.

Je zou kunnen zien dat deze apparaten worden gebruikt voor het weergeven van een bepaalde parameter, in motorbesturingstoepassingen, LED-verlichting, sensoren van verschillende typen, zoals hellingsensor, accelerometer, snelheidsmeter, dataloggers, temperatuurregelaars, toetsenborden enz.

Het primaire begrip van microcontrollers kan worden verkregen door te verwijzen naar de AVR Amega32-microcontroller die zo geavanceerd is dat het soms een computer in een chip wordt genoemd.

Dit apparaat is toegewezen om een ​​reeks opdrachten uit te voeren om een ​​programma te vormen.

De taal van het programma dat u hier zou zien, is C ++. Deze taal leert u hier in de cursus dieper.

Als het om MCU's gaat, krijgt u de mogelijkheid om al zijn pinouts te beheren en te configureren.

Als je hier een beetje moe van wordt, ga dan gewoon chillen, want het is helemaal niets ingewikkelds, je zult gestaag maar vastberaden door alle aspecten heen worden geleid terwijl we verder gaan.

In een MCU-chip kunnen alle pinnen behalve de Vdd en Vss, die de stroompinnen van de chip zijn, worden toegewezen met exclusieve aanduidingen.

Pinout-details

Als je de chip van bovenaf bekijkt, zou je een kleine driehoekige inkeping vinden die het beginpunt aangeeft van waar de pinouts beginnen. Het tellen is dat de # 1 pin van de chip net onder deze inkeping begint.

Vanaf deze pin zou je aan die kant (links) 20 pinnen tot aan de onderkant vinden, en nog eens 20 pinnen aan de andere kant (rechts), van onder naar boven aan de rechterkant.

De eerste 8 pinnen die beginnen vanaf de inkeping zijn de PBO-7 die de indexpinnen van het IC vormen, aangezien alle programma's hier beginnen met de index nul.

De bovenstaande reeks pinouts wordt POORT B ​​genoemd, terwijl er andere identieke sets poorten zijn toegewezen aan A tot D.

Deze poorten kunnen worden toegewezen om gevoede gegevens genaamd INPUT te accepteren en te herkennen, en ook om gegevens te verzenden in een gespecificeerde vorm, OUTPUT genaamd.

Twee van de pinnen die in de algemene categorie vallen, zijn de (+) / (-) pinnen die ook wel Vdd en GND worden genoemd.

Een pin van POORT D (PDO-6) bevindt zich aan de linkerkant van de chip aan de onderkant.

PD7 die pin # 7 van POORT D is, kan alleenstaand worden getraceerd en begint met de reeks pinouts aan de rechterkant.

Ga nu verder vanaf de rechterkant van de chip waar POORT D eindigt, POORT C begint zijn aftellen in de volgorde.

Deze dragen bij aan de vele interessante pinnen van de MCU, van analoog tot digitaal.

Deze pinnen worden gebruikt om de detectie-ingangen te worden voor het detecteren van de vele parameters via extern geconfigureerde analoge circuittrappen.

De bovenstaande pinnen vormen de PORT A.

De analoog naar digitaal conversie over de bovenstaande pinnen kan worden begrepen met behulp van een voorbeeld waarin een analoog temperatuurniveau dat wordt gedetecteerd met behulp van een gewone sensor zoals een thermister wordt toegepast op een van de PORT A-pinnen die gemakkelijk wordt geaccepteerd en omgezet door de MCU om een ​​digitale uitlezing te produceren van nul tot 255 graden F (een 8-bits cijfer dat kan worden opgewaardeerd om een ​​10-bits uitvoer te bereiken).

Een ander kenmerk dat bovendien in MCU's kan worden waargenomen, is de beschikbare programmeerruimte of het geheugen dat de ruimte bepaalt voor de variabelen en het programma dat is gespecificeerd voor de microcontroller.

Bovendien hebben de MCU's een ingebouwde klok die is toegewezen voor het tellen van de relevante parameters.

De klokkenmerken stellen de MCU in staat om zichzelf toe te passen voor veel verschillende telprocessen die snel zouden kunnen zijn in het bereik van microseconden, afhankelijk van de specificatie van het specifieke apparaat, en ook langzamer zouden kunnen zijn tot elke gewenste mate.

Misschien heb je het concept van de microcontroller tot op zekere hoogte en met betrekking tot de poorten en pinnen ervan begrepen.

Hoe u een SPI-connector maakt van de programmeur naar de microcontroller

Nu is het tijd om wat dieper op het onderwerp in te gaan en de wereld van programmeren te onderzoeken.

Dat gezegd hebbende, voordat we ons overgeven aan een programma-laadprocedure in de chip, moeten we een goede manier vinden om de SPI-connector (Serial Peripheral Interface) te integreren met de MCU.

Maar zelfs daarna kunnen we de SPI niet gewoon in de MCU-pinouts duwen, toch? Evenmin kunnen we toestaan ​​dat de verlengde draden van de SPI rechtstreeks in het breadboard worden gestoken. Dit kan ook leiden tot een onjuiste instelling van de draden die zijn verbonden met de verkeerde pinnen die slechte verbindingen maken.

Om alles absoluut onberispelijk te maken, doen we de procedures daarom over een klein verobord waarin we de vereiste metalen verbindingspennen, ook wel de 'header' genoemd, gesoldeerd krijgen. Deze header-pinnen kunnen nu worden gebruikt om verbinding te maken met de SPI-connector. De verbindingen van deze header kunnen worden beëindigd met andere parallelle headerpennen die kunnen worden gebruikt voor de breadboard-verbindingen.

Aldus vormt de bovenstaande montage nu een knus en betrouwbaar tussenliggend verbindingsplatform voor de SPI naar de MCU.

Tot nu toe ziet alles er goed en perfect uit, dus laten we verder gaan om te verdienen met betrekking tot de programmeur die nodig is tussen uw pc en de MCU.

Er kunnen een groot aantal bedrijven zijn die deze programmeereenheden maken en verkopen, dus het zou voor u geen probleem moeten zijn om deze aan te schaffen, zoals Adafruit Industries, USBtinyISP of Sparkfun enz.

Een paar van deze kunnen er heel anders uitzien dan de conventionele typen, maar in principe hebben ze alles identiek en volgen ze de standaard programmeerregels en kunnen ze worden gebruikt als een interface tussen uw pc en de AVR-microcontroller.

Zorg er echter voor dat u er zeker van bent dat als u een andere MCU gebruikt en geen AVR Atmega32, u wellicht moet zoeken naar een overeenkomstig compatibele programmeur voor die specifieke MCU-chip.

Het kan worden opgemerkt dat nogal wat van deze programmeurs identieke stuurprogramma's gebruiken, iets waar voor moet worden gezorgd en we zullen er meer over leren in onze volgende hoofdstukken.

Het aansluiten van uw pc op de microcontroller-chip is echt heel eenvoudig en u zou graag willen weten hoe eenvoudig de procedure hiervoor is. Dus laten we meteen op de knop drukken J

Het maken van de hierboven toegelichte SPI-interfacekaart is niet moeilijk, het gaat erom dat uw soldeerbout door alle verbindingen over de getoonde twee koprijen met pinnen op een klein bord voor algemene doeleinden werkt.

De bovenstaande afbeelding toont de verbindingsdetails die u zou moeten volgen bij het verbinden van de draden tussen de headers.

Om het nog eenvoudiger te maken, laten we de volgende verbindingsdetails voor hetzelfde doornemen door naar de bovenstaande afbeelding te verwijzen:

SPI-pin vanaf linksboven gaat naar de 'Master IN, Slave OUT' (MISO)

SPI-pin van midden links verbindt met de klokpin (SCK)

SPI-pin linksonder sluit aan bij de Reset. (We zullen uitgebreid leren over deze pin in de volgende tutorials)

SPI relevant voor rechtsonder sluit aan op de GND-pin van de MCU, GND verwijst naar de pin die de nultoevoerlijn of de negatieve (relatieve) rail van de voeding vormt.

SPI die eindigt vanaf de middelste rechterkop, verbindt met de 'Master Out, Slave IN' (MOSI) -pin van de MCU.

SPI die uit de koptekst rechtsboven komt, is aangesloten op de (+) van de MCU, wat overduidelijk de Vdd of de positieve voedingspin van de MCU is.

Dat is het.

Verbind de twee connectoren zoals uitgelegd en uw SPI-interfacekaart is klaar voor de vereiste acties.

Voor verdere hulp kunt u de bovenstaande afbeelding raadplegen. Uw uiteindelijke interfacekaart zou er zo uit moeten zien nadat alle draadverbindingen op de juiste manier zijn gemaakt met behulp van de bovenstaande discussie.

Ik hoop dat je de SPI-interface misschien al hebt geconstrueerd zoals uitgelegd in de vorige tutorial, en dat het nu tijd is om ervoor te zorgen dat onze computer de programmeur accepteert die we nodig hebben om te integreren tussen de pc en de MCU.

Een eenvoudige programmeercode maken voor een MCU

We nemen een USBTinyISP-eenheid die verkrijgbaar is bij Sparkfun, om de computer met de microcontroller te verbinden.

We weten dat elk computerbesturingssysteem, zoals Windows, stuurprogramma's nodig heeft, zonder welke het nutteloos zou zijn om iets op de computer te laden, dus onze programmeur heeft stuurprogramma's nodig om op uw computer te laden.

Laten we eens kijken naar de procedures die nodig zijn voor het installeren van de stuurprogramma's in het besturingssysteem van uw computer, hier nemen we het voorbeeld van Windows 7 OS met 32-bits of 64-bits specificaties.

Open sparkfun.com en klik op 'pocket AVR programmeur pagina'. De link kan gemakkelijk worden gevisualiseerd binnen de pagina.

Zoek vervolgens 'Windows-stuurprogramma' onder documenten en klik erop.

Hiermee krijgt u het bestand pocketprog-driver.zip op uw computer.

Ga naar je computer, zoek de downloadlocatie en pak het gedownloade bestand uit in een map.

Als uw computer een 64-bits besturingssysteem is, moet u nog een paar stappen volgen, zoals beschreven onder, bij een 32-bits besturingssysteem kunt u de installatie direct starten vanuit het uitgepakte bestand.

Voor een 64-bits volg deze, voor 32-bits negeer gewoon:

Google 'libusb sourceforge' en klik op de laatste versie van deze link.

Je zou een paar extra bestanden tegenkomen, maar je zou geïnteresseerd zijn om het bib-bestand te vinden, dat wil zeggen: libusb-win32-bin - #. #. #. #. Zip

Ga nu en zoek deze downloadlocatie op uw computer, pak het uit en sla het op in een van de mappen.

Navigeer in deze map over de bin-map en ga verder naar de map amd64.

Je zou hier een aantal mappen zien als: ghcalled libusb0.dll en libusb0.sys.

U zou deze willen hernoemen als: libusb0_x64.dll en libusb0_x64.sys.

Nu moet u de bovenstaande bestanden naar de map pocketprog-driver kopiëren, overschrijf gewoon de bestanden op de bestaande versie.

Om de bovenstaande stuurprogramma's te installeren, zou de volgende methode, die nogal ongebruikelijk is in zijn soort, u interesseren:

Het is een modus voor het toevoegen van oudere hardware.

Klik op 'Start Menu'

Ga vervolgens verder door met de rechtermuisknop op 'computer' te klikken

Klik op 'Beheren' en klik ten slotte op 'apparaatbeheer'

Kies vervolgens in het menu 'Legacy hardware toevoegen'

Ga verder met 'volgende', totdat de wizard wordt ingevoegd

Volg de instructies en klik op 'Installeer de hardware die u nodig hebt om te selecteren uit een geavanceerde lijst'. Dit zal het radioknoppictogram in die specifieke selectie plaatsen. Het is eigenlijk een Windows-bedieningsknop die er nu uitziet als een kleine cirkel met een ronde blauwe vijl erin.

Klik nu gewoon op 'Volgende'

Dit zal je 'Show all Devices' menu tonen waarop je moet klikken.

Ga hierna verder om op het pictogram 'Diskette' te klikken.

Ga met behulp van het pictogram 'Bladeren' naar de locatie van de map pocketprog-driver. Als de selectie correct door u is gedaan, zou u het pocketprog.inf-bestand visualiseren dat in die specifieke map is geplaatst.

Dubbelklik op dit bestand en u zou zeker zien dat het stuurprogramma op uw pc wordt geïnstalleerd.

Over en uit!! Laten we verder gaan met onze volgende tutorial op de volgende pagina.

Inmiddels heeft u wellicht de vereiste software geïnstalleerd en de SPI-interface gebouwd.

Hoe u een programma overzet naar een microcontroller-chip

De volgende stap vraagt ​​om een ​​paar componenten zoals een breadboard, een LED en een berekende weerstand voor de beoogde toepassing.

In dit gedeelte leren we de testmethode van de programmeur en bevestigen we de installatie van de relevante stuurprogramma's en de software.

Om te controleren of de stuurprogramma's en de software correct zijn geïnstalleerd, implementeren we een eenvoudig programma dat bekend staat als avrdude.

De AVRdude is een programma dat is gekoppeld aan de nieuwste WinAVR-installatie, zonder welke de daadwerkelijke overdracht van het bestand naar de MCU niet mogelijk is.

Dit programma is een .hex-bestandsindeling die in wezen begrijpelijk wordt voor de MCU voor de vereiste uitvoeringen.

Als de verificatie niet lukt, is de programmeur niet in staat het bestand over te dragen.

Laten we snel kijken hoe we de testprocedure kunnen implementeren met behulp van de volgende instructies:

Open de DOS-prompt (Disk operating system) door op “startmenu” te klikken en cmd.exe in het opgegeven zoekvak te typen.

Nu kan het uitvoeren van de AVRdude worden gedaan door simpelweg avrdude –c usbtiny –p m32 te typen over de DOS-prompt. Zodra dit is geïmplementeerd, zal de DOS onmiddellijk erkennen of de verbinding een succes was.

In het bovenstaande commando is de '-c' een signalerende vlag die de 'usbtiny' programmeurparameterspecificatie bevat, terwijl de '-p' -tag het microcontroller-apparaat identificeert ('m32 geeft Atmega32 aan).

Als u een andere MCU heeft gebruikt, moet u de relevante voorvoegsels opnemen voor de implementatie.

Zodra de bovenstaande procedure is voltooid, kunt u 'exit' typen over de DOS-prompt, en dat zal u uit het venster halen.

Als je je serieus afvraagt ​​over de feitelijke programmeerdetails, daarvoor zouden we eerst het externe analoge LED-circuit moeten solderen en construeren waarop het programma kan worden geïmplementeerd, want tenzij er een systeem is om de reactie van de MCU te erkennen, is de programmering en het runnen van de microcontroller zou volkomen zinloos zijn.

Het maken van het LED-bord is heel eenvoudig, het gaat erom de twee draden van de LED over een stuk verobord te solderen en de weerstand te verbinden met een van de draden van de LED. De rol van deze LED is alleen om de stroom naar de LED te beperken, zodat deze niet doorbrandt vanwege de te hoge spanning en stroom van de MCU-uitgang.

De waarde van de weerstand kan worden berekend met behulp van de volgende eenvoudige formule:

R = (Ub - LEDfwd) / I

Waar Ub de voedingsspanning is, is LEDfwd de optimale bedrijfsspanning van de gebruikte LED, en I de optimale versterkers.

Stel dat we een RODE LED gebruiken met een LED voorwaartse spanning = 2,5 V en stroom I = 20 mA, dan kan de bovenstaande vergelijking als volgt worden opgelost:

Aangezien de spanning van MCU 5V zou zijn, kan dit worden uitgedrukt als:

R = (5 - 2,5) /. 02 = 125 ohm, ¼ watt, de dichtstbijzijnde waarde van 120 ohm is voldoende.

Nu hebben we de LED, een weerstand van 120 ohm en een verobord, verbind eenvoudig de bovenstaande componenten zoals weergegeven in het diagram met de microcontroller.

Zodra dit is gebeurd, kan de MCU worden geprogrammeerd voor de beoogde reactie op de bovenstaande LED-opstelling.

Vervolgens de programmering van de MCU.

Om de microcontroller in staat te stellen een aantal zinvolle implementaties uit te voeren, is het noodzakelijk om de juiste instructies in de MCU te schrijven.

Hoe een programmeeromgeving te installeren en WinAVR te onderzoeken

Hiervoor zouden we waarschijnlijk onze eigen 'teksteditor' op onze pc kunnen gebruiken, hoewel velen van ons het gebruik van een professionelere 'programmeeromgeving' in plaats van een gewone teksteditor zouden waarderen, eenvoudig omdat deze benadering u in staat zou stellen om van wat te genieten. ingebouwde interessante functies binnen dit 'programmeeromgeving' -pakket.

Het zou het maken en bewerken van programma's in verschillende talen ondersteunen en ze ook compileren in een leverbare modus die gemakkelijk te begrijpen en te accepteren is door een microcontrollerchip.

Uiteindelijk zou dit worden ondersteund door WinAVR en overgebracht naar de betreffende MCU-chip.

WinAVR zou ook kunnen worden uitgerust om vele andere bewerkingen uit te voeren, zoals het oplossen van problemen met de programma's en ons waarschuwen voor mogelijke syntaxis en compileerfouten en fouten. We zullen deze bespreken in onze latere tutorials.

U zou de installatie van WinAVR extreem snel en pittig willen laten verlopen. Laten we met de volgende punten naar de details kijken:

U moet de nieuwste versies downloaden uit de WinAVR-map met smeedbestanden voor bronbestanden. U zou nuttige informatie over deze download tegenkomen op de officiële website.

U wordt gevraagd om een ​​beveiligingsvraag, zodat u kunt antwoorden als u wilt dat de download plaatsvindt. Hierop wordt gevraagd of het te downloaden bestand een uitvoerbaar bestand is.

Download het bestand en start het uitvoeringsproces door erop te klikken. Laat de installatie beginnen.

Het proces zal u begeleiden met enkele beantwoorde vragen, zodat u de installatie mogelijk kunt stroomlijnen volgens uw comfort. Je zou veel van deze naar hun standaardformulieren willen negeren, het zou allemaal aan jou om degene te selecteren die volgens jou het meest geschikt zijn voor de acties.

Tot nu toe zou je alles heel normaal en gemakkelijk vinden en een paar opties vinden in het startmenu dat naar je toe wordt gegooid. Geen zorgen, slechts enkele hiervan zouden eigenlijk slechts één van de tem genaamd 'programmeurs kladblok' gebruiken.

Eenmaal op dit pictogram geklikt, wordt de gebruikersinterface gestart zodat u het schrijven van de programma's kunt toepassen (zoals maken en bewerken). Je zou ook getuige zijn van het programma dat bestaat uit menuopdrachten om je te helpen de codes te compileren en ze in de microcontroller in te bedden.

De fundamentele taak van het bovenstaande programmeerkladblok is om een ​​voor mensen leesbare code die u zou schrijven om te zetten in een reeks instructies die alleen voor de MCU begrijpelijk zijn.

De volgende tutorial behandelt het testen van de bovenstaande programmeur, zodat we zeker kunnen zijn van de compatibiliteit met Windows en of het perfect 'hand schudt' met je microcontroller IC.

Hoe een MCU te programmeren om een ​​LED in te schakelen

Zodra dit is bevestigd, gaan we verder met het maken van een kleine 'niets doen' -code, alleen om ervoor te zorgen dat de procedure van codeoverdracht geen fouten oplevert.

Natuurlijk zijn we nu klaar om ons eerste programma in de MCU te implementeren, maar daarvoor zou het interessant zijn om snel samen te vatten wat we deden in de loop van onze vorige tutorials:

We hebben de AVR Atmel-microcontroller aangeschaft volgens onze vereiste specificatie, hier hebben we de ATMega32 gebruikt voor de illustraties. Vervolgens leerden we over de basisprincipes van de microcontroller en de programmeereenheid die verantwoordelijk is voor het overbrengen van een programma naar de MCU-chip.

Verder hebben we de SP-interfaceconnector gebouwd die essentieel is zodat uw computer kan worden gekoppeld aan de microcontroller voor de programmeeracties.

Hierna hebben we bevestigd of de stuurprogramma's correct op de computer waren geïnstalleerd voor zowel een 32-bits als een 64-maar-besturingssysteem.

Vervolgens hebben we de programmeeromgeving Win AVR geïnstalleerd om het schrijven van advertenties en het overbrengen van de codes naar de microcontroller te vergemakkelijken, gevolgd door de implementatie van de avrdude voor het verifiëren van de programmeur met uw pc en de onderling verbonden microcontroller.

Ten slotte hebben we in het vorige hoofdstuk het bouwen van het LED / weerstandscircuit voltooid en deze verbonden met de relevante MCU-uitgangen.

Dat is inderdaad veel werk, maar het is tijd om meteen wat echte programmeeractiviteiten te beginnen!

Om te beginnen zouden we de microcontroller in drie categorieën willen verdelen, dit zou ons begrip aanzienlijk vereenvoudigen:

Controle, detectie en communicatie

Het zou interessant zijn om te weten dat de bovenstaande functies op veel verschillende manieren kunnen worden geprogrammeerd.

In ons eerste programma zouden we proberen de microcontroller opdracht te geven om een ​​externe parameter te 'besturen', ja je hebt gelijk, het zou de LED zijn die we onlangs hebben gebouwd.

Om precies te zijn, zullen we de MCU vertellen om de aangesloten LED aan te zetten, ja ik weet dat dit er nogal primitief uitziet, maar de startfase moet altijd gemakkelijk zijn.

Doorgaan met de huidige taak, de MCU-besturing van de LED maken, is eigenlijk vrij eenvoudig:

Hiervoor instrueren we pin # 0 op POORT B ​​om de vereiste 5V voor de LED te produceren.

Herinner je aan de vorige tutorial, we hebben de anode van de LED verbonden met de bovengenoemde pin van de MCU.

Er zijn twee essentiële dingen die aan deze pin van de MCU moeten worden geadresseerd: 1) output en 2) 5 volt

We zullen een manier leren waarop we de specifieke pin kunnen instrueren om de uitvoer van de MCU te worden.

Als het eenmaal is ingesteld als de uitvoer van de chip, kunnen we hem instrueren om ofwel 'hoog' (5V) of 'laag' (0V) te zijn, zoals gewenst voor een toepassing.

Aangezien elk logisch circuit, zoals een MCU, de pinnen een uitgang of een ingang kunnen zijn en kunnen worden geconfigureerd om een ​​logisch hoog of logisch laag te produceren, hoeven de pinnen alleen te worden toegewezen om een ​​logisch hoog of logisch laag te zijn. , er zijn geen tussenliggende of ongedefinieerde toestanden behalve deze paar toestanden voor microcontrollers of voor welke digitale IC dan ook. Hetzelfde geldt ook voor elke pin van de MCU.

Wat betreft de invoer- en uitvoerpintoewijzingen, zouden de ingangen zo worden geplaatst dat ze signalen van externe analoge trappen accepteren, terwijl de uitgangen verantwoordelijk zouden zijn voor het interpreteren van deze in de gespecificeerde logische toestanden of een frequentie.

Hoewel de bovenstaande opdrachten op veel verschillende manieren zouden kunnen worden gedaan, zouden we omwille van de eenvoud een ervan bespreken. Er moet echter worden opgemerkt dat, hoewel degene die nu zou worden gepresenteerd er gemakkelijk en interessant uitziet, het niet zo levensvatbaar is en niet een aanbevolen type voor alle MCU-toepassingen, om dezelfde reden dat u later in de cursus kennis zou maken met meer populaire programmeermethoden . Met deze programma's kunnen alleen de gewenste pinnen worden toegewezen volgens de specificaties, zonder de andere aangrenzende pinnen te beïnvloeden, die mogelijk al zijn toegewezen om andere functies uit te voeren.

Op dit moment zullen we ons echter niet zo druk maken over de andere pinnen en zouden we alleen de relevante pinnen gebruiken, waardoor complicaties tot op zekere hoogte worden vermeden.

Voor het toewijzen van een pin als uitgang hebben we het Data Direction Register (DDR) nodig. Als u zich afvraagt ​​wat registreren hier betekent, is het gewoon een spatie in de MCU waarmee de microcontroller op een bepaalde manier kan reageren.

Met behulp van de DDR kunnen we de pin instellen om ofwel gegevens te verzenden die als een 'uitvoer' zijn, of gegevens te accepteren in de vorm van een 'invoer'.

U kunt echter in de war raken over het woord, wat houdt dit in? Een data voegt een derde dimensie toe aan de pinnen die kunnen worden toegewezen om continu op logisch nul (0V) of logisch hoog (5V) te staan, maar hoe zit het met de signalen die snel kunnen variëren, zoals een frequentie van pulsen. Een frequentie zou gepaard gaan met hoge en lage logica (5V en 0V) die oscilleren met een aantal gespecificeerde intervallen of perioden, dus het wordt tijdgericht en kan worden aangepast met betrekking tot de tijd, daarom identificeren we als 'data', wat een parameter betekent die aangeeft een functie ten opzichte van een andere functie (logische toestanden en tijd).

Een methode om pin0 als uitgang toe te wijzen, is door de volgende code te schrijven:

DDRB = 0b00000001

In het bovenstaande programma betekent DDRB Data Direction Register for PORT B ​​0b instrueert de compiler met betrekking tot de volgende binaire uitdrukking van een getal, terwijl de '1' aan het einde van de uitdrukking de positie van pin0 aangeeft, dat is de locatie in de vorm van de eerste pin van PORT B.

Als je je herinnert, hebben we geleerd dat POORT B ​​8 pinnen ermee associeert (van 0 tot pin 7), en als je merkt dat de bovenstaande code ook 8 cijfers bevat, wat betekent dat elk cijfer deze 8 pinnen van POORT B ​​aangeeft.

Nu zou de volgende procedure zijn om 5V aan deze pin (pin0) toe te wijzen. Nogmaals, het werkingsprincipe is identiek aan DDR zoals hierboven uitgedrukt door de volgende binaire code:

PORTB = 0b00000001

Zoals te zien is, is het enige verschil tussen de bovenstaande code en de eerdere dat we in deze code gebruik hebben gemaakt van het PORT-register. Dit register behandelt specifiek de pintoewijzingen van die specifieke poort waarvoor het in de MCU is geplaatst. Het stelt ons dus in staat om de echte datalogica (0 of 1) voor die pinouts toe te wijzen.

Nu zijn we misschien geïnteresseerd om wat te bespreken met betrekking tot de geschatte details van ons programma. Zoals we weten, hebben alle programma's een bepaalde ruimte nodig om de uitvoering te starten, dit kan worden vergeleken met een chef-kok die alle ingrediënten van een bepaald recept kent, maar niet weet waar hij moet beginnen.

De 'hoofd' -functie hier is de locatie waar elk van de C / C ++ -programma's de uitvoering initieert. Daarom kan de hoofdpagina worden gemaakt als:

int main (ongeldig)
​
​

Om het programma echter in staat te stellen de DDR- en PORT-registergegevens en hun werking in de MCU-chip te interpreteren, moet een aanvullende verklaring worden opgenomen die kan bestaan ​​uit alle gegevens met betrekking tot de AVR MCU. Misschien willen we deze opname in al onze programma's toevoegen.

#inclusief
int main (ongeldig)
​
​

Zodra de compilatie begint, concentreert het pre-processorgedeelte van de compiler zich op de AVR-directory om het 'io.h' -bestand te identificeren. De extensie '.h' geeft hier aan dat het een header-bestand is, en dat deze code in het bestand wordt geïntroduceerd aan het begin (head) van het bronbestand dat wordt gemaakt, vandaar de naam 'header'.

Hier kunnen we de DDR- en PORT-statements in onze code introduceren, omdat de toevoeging van het io.h-headerbestand de compiler hierover zou hebben geleid.

#inclusief

int main (ongeldig)

​

DDRB = 0b00000001 // Data Direction Register instelling pin0 voor output en de overige pinnen als input

PORTB = 0b00000001 // Stel pin0 in op 5 volt

​

Het bovenstaande legt de oriëntatie van de pin0 vast als de output, met een magnitude van 5V. Er is echter nog een probleem dat niet is vastgesteld voor deze pin, dat wil zeggen dat deze pin nog moet worden geïnstrueerd om voor onbepaalde tijd te worden ingeschakeld zolang de MCU van stroom wordt voorzien. Deze oneindige feedbacklus zou ervoor zorgen dat deze pin van de MCU niet uitschakelt, maar voor onbepaalde tijd doorgaat met de 5V-uitgang.

Hoewel er veel verschillende methoden zijn om een ​​lusinstructie voor een pin toe te passen, zouden we proberen de 'while' -lus hier te gebruiken. Zoals de naam doet vermoeden, vertelt de 'while' -lus de microcontroller dat 'terwijl' de stroom beschikbaar is, u geactiveerd moet blijven met de toegewezen 5V voor de toegewezen pinout.

#inclusief

int main (ongeldig)

​

DDRB = 0b00000001 // Data Direction Register instelling pin0 voor output en de overige pinnen als input

PORTB = 0b00000001 // Stel pin0 in op 5 volt

terwijl (1)

​

// Code zou hier zijn als het steeds opnieuw en opnieuw moest worden uitgevoerd ... eindeloos

​

​

Merk op dat we hier ‘1’ hebben gebruikt in de vorm van een argument voor de 'while' -lus, aangezien alles behalve '0' als een logische 'waar' kan worden beschouwd.

Dat houdt in dat de overweging van de 'while' -lus nooit verantwoordelijk zou zijn voor iets anders dan een logische 'true', wat betekent dat de specifieke pin voor onbepaalde tijd in de gespecificeerde toestand zou blijven hangen.

U kunt zien dat de LED permanent AAN is over de toegewezen pin, zolang de MCU stroom ontvangt over zijn Vdd en Vss.

Dat is het, nu hebben we het resultaat dat we wilden bereiken en kunnen we het eindelijk zien gebeuren na zoveel hard werken, maar toch is het zo bevredigend om het zoete resultaat van ons harde werk te zien.

In de volgende tutorials zullen we leren hoe we een 'tijd' -dimensie kunnen toevoegen aan de bovenstaande LED, dat is hoe we deze kunnen laten knipperen met een bepaalde gespecificeerde snelheid.

In de bovenstaande implementatie knippert de LED eigenlijk, maar de lussnelheid is zo snel dat het bijna lijkt op een permanente schakelaar op de LED-verlichting.

We zullen zien hoe deze lus naar wens kan worden toegevoegd met een vertraging om de LED met die vertraagde snelheid te laten knipperen.

Een LED laten knipperen met behulp van de AVR-microcontroller

In de laatste discussie hebben we geleerd hoe we een LED kunnen inschakelen via een microcontroller, het was uitstekend, nietwaar? Misschien niet zo veel!

Hier zullen we leren hoe we de bovenstaande LED-verlichting kunnen opfleuren door een bidirectionele functionaliteit toe te kennen, dat wil zeggen dat we zullen proberen het te laten knipperen of knipperen met een bepaalde frequentie of snelheid. We zullen ook zien hoe dit tarief naar wens van de gebruiker kan worden verhoogd of verlaagd.

Laten we dit eens bekijken:

#inclusief

#inclusief

int main (ongeldig)

​

DDRB | = 1<< PINB0

terwijl (1)

​

PORTB ^ = 1<< PINB0

_vertraging_ms (100)

​

​

Als je je verbijsterd voelt over die vreemde symbolen (&, ^, | enz.) Die in de bovenstaande uitdrukking worden gebruikt (& is er niet, maar kan in andere vergelijkbare codes worden gebruikt), dan is hier de gerelateerde informatie die je hierover zou willen weten :

Het bevat veel standaard logische algoritmen zoals AND, OR, NOT en XOR die doorgaans worden gebruikt met de bovenstaande code.

Deze logische functionaliteit vergelijkt specifiek de twee bits '1' en '0' volgens hun toegewezen waarheidstabellen.

We krijgen een idee door de volgende bitopstelling te analyseren:

01001011 &
10001101
gelijk is
00001001

In de bovenstaande code verwijst & naar AND zoals gebruikt in C-programmering.

Als je de rijen verticaal leest, suggereert het dat 0 en 1 gelijk is aan 0, 1 en 0 ook gelijk is aan 0, 0 en 0 gelijk is aan 0, 1 en 1 is gelijk aan 1. Het lezen is zo simpel als dat. Deze zijn volgens de waarheidstabel van een AND-operator.

Als we de volgende tabel beoordelen, geeft dit het symbool '|' aan ter aanduiding van het gebruik van de 'OF' -functionaliteit, de '|' kan worden gevonden net aan de linkerkant van 'backspace' op uw computertoetsenbord:

01001011 |
10001101
gelijk is
11001111

Identiek geeft deze waarheidstabel van een OF-logische functionaliteit aan dat bits 0 of 1 gelijk is aan 1, 1 of 0 ook gelijk is aan 1, 0 of 0 gelijk is aan 0, terwijl 1 of 1 gelijk is aan 1.

De volgende bitcombinatie is voor de logische XOR-operator aangeduid met ^ en kan worden bestudeerd net zoals we deden met de EN-, OF-waarheidstabellen:

01001011 ^
10001101
gelijk is
11000110

Laten we nu doorgaan met het eerste programma en leren wat de volgende regel erin betekent:

#inclusief

Door onze eerdere tutorials weten we hoe de uitdrukking werkt, dus we zullen het niet herhalen, maar het lijkt een nieuwe 'include' te zijn, uitgedrukt door #include, die moet worden onderzocht.

In deze 'include' stelt delay.h ons enkele eenvoudige implementatiemethoden in staat.

Zoals de naam suggereert, stelt de delay.h ons in staat om een ​​vertraging in het specifieke programma op te wekken.

De volgende uitdrukking int main (void) kan worden weggelaten uit de lopende discussie, aangezien we dit al hebben behandeld in onze eerdere berichten.

Vervolgens komt de gewijzigde DDRB.

Het volgende toont de eerdere vorm, die geen betere manier is om de pinnen toe te wijzen, aangezien alle pinnen van 0 tot 7 werden verwisseld om de ingangen te vormen. Maar stel je eens voor wat de situatie zou zijn als we een langer programma wilden maken dat die pinnen nodig heeft voor een andere functionaliteit? Pin2 kan bijvoorbeeld nodig zijn voor het op afstand schakelen van een apparaat. In dat geval zouden we het niet op prijs stellen om hetzelfde als een invoer toe te wijzen met vallen en opstaan. Dat kan een onjuiste reactie van de externe zender op de ontvanger van het apparaat betekenen.

DDRB = 0b00000001

We willen liever slechts één bit beïnvloeden, hat pin0 bit, kijkend naar de 'OR' -functionaliteit die kan worden uitgevoerd door middel van een binaire maskering.

DDRB = DDRB | 0b00000001

Hier is het versluierd met een 'OF' -masker: 0b00000001, hoewel het nogal een authentiek binair getal lijkt te zijn, in het geval dat de eerdere DDRB bijvoorbeeld: 0b01001010, dan zou het toepassen van een OR hierop door middel van maskeren kunnen geven: 0b01001010 | 0b00000001 = 0b01001011.

Het resulterende verschil zoals kon worden gezien, is alleen met de pin0, waarvan de bits zijn veranderd!

Door de bovenstaande verklaring nog verder te comprimeren via C ++:

DDRB | = 0b00000001

We ontdekken echter dat er nog meer in het gegeven programma zit. Hoewel het er redelijk legitiem en voor de hand liggend uitziet, moeten we de voordelen van enkele van de verklaringen uit het io.h-headerbestand gebruiken, vooral wanneer het fundamenteel voor ons gemak is gemaakt?

Dus als '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.

Dus we beginnen met een 0b00000000, en plaatsen een '1' om 0b0000001 te produceren en dan verplaatsen we het naar links 0 posities, wat een exact identieke 0b00000001 geeft als hierboven.

Stel dat het PINB4 was, dan zou de verklaring kunnen worden uitgedrukt als 1<< PINB4. I this case the “1” would be pushed to the left 4 locations producing: 0b00010000.

Pas op, we gebruiken een nulindex, wat betekent dat er vier nullen na de '1' staan.

We gaan nu verder met de 'while' -lus die we eerder over de 'oneindige lus' hadden opgemerkt. Maar misschien willen we nu dat de microcontroller enkele van de gewenste uitvoeringen implementeert. Dit is wellicht alleen mogelijk binnen de gegeven lus. Het is de lus waarin de specifieke reeks keer op keer wordt herhaald.

In het geval dat de uitvoering vóór de lus zou worden geplaatst, zou deze slechts één keer zijn geïmplementeerd.

Om de LED echter oneindig te laten knipperen, zou het nodig zijn om de PINB0 afwisselend AAN / UIT binnen de lus te schakelen. Hier vinden we ook de vertragingen die worden geïntroduceerd, zonder welke het knipperen van de LED onmogelijk zou zijn. Maar dit zou de LED dwingen om met een zeer hoge snelheid te knipperen die moeilijk te herkennen is met het blote oog, het zou een beetje langzamer moeten worden om herkenbaar te worden met onze ogen.

We zijn ons bewust van de procedure voor het instellen van een bepaald bit in het binaire getal, maar we zijn niet zeker van de methode om een ​​specifiek bit '0' toe te passen voor het geval het al een '1' is.

Het volgende programma kan dit zien, maar we zullen ook ontdekken dat het mogelijk niet zichtbaar is in het programma.

De eerste twee instructies veranderen de bit in '1' (5V, LED-lampjes), waarna een pauze van 100 ms wordt geïntroduceerd.

De volgende paar regels veranderen de PINB0-bit in '0' (nulspanning, LED uitgeschakeld), maar sorry, de EN-vergelijking kan geen '0' van de bit uitvoeren, maar als we NIET '~' gebruiken voor het binaire masker zou het alle nullen in enen kunnen veranderen en vice versa.

Dit stelt ons in staat om alleen de PINB0-bit te beïnvloeden en deze naar '0' te draaien. Het haakje is toegevoegd om de maskeeruitvoering zodanig te bevatten dat de NOT-bewerking kan worden toegepast op de hele maskers en niet simpelweg op de '1' voorafgaand aan de linker shift '<<”.

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

Om de AAN UIT-vertragingen of de perioden van gelijke duur te creëren, kunnen we de vorige vier regels terugbrengen tot twee en XOR-functionaliteit in ons voordeel toepassen. Er moet worden opgemerkt dat een XOR een toegewezen pin uitvoert op een 1 in het geval dat het 0 is en vice versa. Deze uitvoering zou alleen de PINB0 beïnvloeden. Hoe vaak het commando ook wordt toegepast, het zou de bit eenvoudig in het tegenovergestelde van de bestaande logica veranderen.

PORTB ^ = 1<< PINB0
_vertraging_ms (100)

GEDAAN! Je LED zou nu knipperen volgens de ingestelde snelheid ... Simpel, nietwaar?