Nozioni di base sul microcontrollore esplorate

Una cosa è fantastica dei circuiti integrati per microcontrollori, sono disponibili quasi in tutte le parti del mondo e nei rivenditori di elettronica.

introduzione

Fondamentalmente, i dispositivi a microcontrollore sono comunemente utilizzati in applicazioni che implicano la valutazione dell'ambiente circostante e in dispositivi elettronici simili.

È possibile trovare questi dispositivi utilizzati per visualizzare un determinato parametro, in applicazioni di controllo del motore, illuminazione a LED, sensori di vario tipo come sensore di inclinazione, accelerometro, misuratore di velocità, data logger, termoregolatori, tastiere ecc.

La comprensione principale dei microcontrollori potrebbe essere ottenuta facendo riferimento al microcontrollore AVR Amega32 che è così avanzato che a volte viene chiamato un computer all'interno di un chip.

Questo dispositivo è assegnato per eseguire una serie di comandi per formare un programma.

La lingua del programma che vedresti qui è C ++. Imparerai questa lingua in modo più approfondito nel corso qui.

Quando si tratta di MCU, hai la possibilità di avere la possibilità di controllare e configurare tutti i suoi pinout.

Se ti stai stancando un po 'con questo, rilassati perché non è affatto complesso, sarai facilitato attraverso tutti gli aspetti in modo costante ma deciso mentre andiamo avanti.

In un chip MCU tutti i pin tranne Vdd e Vss che sono i pin di alimentazione del chip, possono essere assegnati con designazioni esclusive.

Dettagli piedinatura

Se guardi il chip dall'alto, troverai una piccola tacca triangolare che indica l'inizio del punto da cui inizia la piedinatura, conta che il pin n. 1 del chip inizia appena sotto questa tacca.

Partendo da questo pin, troverai 20 pin fino in fondo su quel lato (a sinistra) e altri 20 pin sull'altro lato (a destra), continuando dal basso verso l'alto sul lato destro.

I primi 8 pin che iniziano dalla tacca sono i PBO-7 che formano i pin di indice dell'IC poiché tutti i programmi qui iniziano con lo zero di indice.

La serie di piedinature sopra è denominata PORTA B, mentre ci sono altri set identici di porte assegnate da A a D.

Queste porte possono essere assegnate per accettare e riconoscere un dato alimentato chiamato INPUT e anche per trasmettere dati in una forma specifica chiamata OUTPUT.

Due dei pin che rientrano nella categoria generale sono i pin (+) / (-) che sono anche indicati come Vdd e GND.

È possibile vedere un pin dalla PORTA D (PDO-6) situato sul lato sinistro del chip nell'area inferiore.

PD7, che è il pin n. 7 della PORTA D, potrebbe essere tracciato da solo e iniziando la serie di piedinature sul lato destro.

Ora spostandosi dal lato destro del chip dove finisce la PORTA D, la PORTA C inizia il suo conteggio verso l'alto nell'ordine.

Questi contribuiscono ai tanti pin interessanti dell'MCU proprio da quelli analogici a quelli digitali.

Questi pin sono presenti per diventare gli ingressi di rilevamento per rilevare i numerosi parametri attraverso stadi di circuiti analogici configurati esternamente.

I pin di cui sopra costituiscono il PORT A.

La conversione da analogico a digitale attraverso i pin di cui sopra potrebbe essere compresa con l'aiuto di un esempio in cui un livello di temperatura analogico rilevato utilizzando un sensore ordinario come un termistore viene applicato a uno dei pin PORT A che è prontamente accettato e convertitore dalla MCU per produrre una lettura digitale da zero a 255 gradi F (una cifra a 8 bit che potrebbe essere aggiornata per ottenere un'uscita a 10 bit).

Un'altra caratteristica che potrebbe essere osservata negli MCU è lo spazio di programmazione disponibile o la memoria che determina lo spazio per le variabili e il programma specificato per il microcontrollore.

Inoltre, le MCU hanno un clock integrato assegnato per il conteggio dei parametri rilevanti.

Le caratteristiche dell'orologio consentono all'MCU di applicarsi a molti differenti processi di conteggio che potrebbero essere rapidi nella gamma di microsecondi a seconda delle specifiche del particolare dispositivo, e potrebbero anche essere più lenti a qualsiasi estensione desiderata.

A questo punto potresti aver compreso il concetto di microcontrollore in una certa misura e per quanto riguarda le sue porte e pin.

Come creare un connettore SPI dal programmatore al microcontrollore

Ora è il momento di approfondire l'argomento e indagare sul mondo della programmazione.

Detto questo, prima di dedicarci a una procedura di caricamento del programma nel chip, dobbiamo trovare un modo corretto per integrare il connettore SPI (Serial Peripheral Interface) con l'MCU.

Tuttavia, anche dopo questo, non possiamo semplicemente spingere l'SPI nei pinout dell'MCU, vero? Né possiamo permettere che i cavi estesi dall'SPI vengano inseriti direttamente nella breadboard. Ciò potrebbe anche causare un'impostazione errata dei cavi collegati con i pin errati che creano cattive connessioni.

Pertanto, al fine di rendere le cose assolutamente impeccabili, eseguiamo le procedure su una piccola veroboard in cui otteniamo i necessari perni metallici di collegamento chiamati anche 'header' saldati. Questi pin di intestazione ora possono essere utilizzati per il collegamento con il connettore SPI. Le connessioni da questa intestazione possono essere terminate con un altro pin di intestazione parallelo che può essere utilizzato per le connessioni della breadboard.

Pertanto, l'assieme di cui sopra forma ora una piattaforma di collegamento intermedia comoda e affidabile per l'SPI all'MCU.

Fino ad ora tutto sembra bello e perfetto, quindi passiamo a guadagnare riguardo al programmatore richiesto tra il tuo PC e l'MCU.

Potrebbero esserci molte aziende che producono e vendono queste unità di programmazione, quindi procurarle non dovrebbe essere un problema per te, come Adafruit Industries, USBtinyISP o Sparkfun ecc.

Alcuni di questi potrebbero sembrare completamente diversi dai tipi convenzionali, ma fondamentalmente hanno tutto identico e seguono le regole di programmazione standard e possono essere utilizzati come interfaccia tra il PC e il microcontrollore AVR.

Tuttavia, assicurati di pensare, se stai usando un altro MCU e non un AVR Atmega32, potresti dover cercare un programmatore compatibile corrispondentemente per quel particolare chip MCU.

Si può osservare che parecchi di questi programmatori impiegano driver identici, qualcosa di cui occuparsi e ne impareremo di più nei capitoli successivi.

Collegare il tuo PC con il chip del microcontrollore è davvero semplice e sarai felice di sapere quanto sia semplice il procedimento per questo. Quindi premiamo subito il pulsante J.

Realizzare la scheda di interfaccia SPI sopra spiegata non è difficile, si tratta solo di far funzionare il saldatore attraverso tutte le connessioni attraverso le due file di intestazione mostrate su una piccola scheda per uso generale.

La figura sopra mostra i dettagli di connessione che dovresti seguire durante l'interconnessione dei fili tra le intestazioni.

Per rendere le cose ancora più semplici, esaminiamo i seguenti dettagli di connessione per lo stesso facendo riferimento all'immagine sopra:

Il pin SPI che inizia in alto a sinistra va a 'Master IN, Slave OUT' (MISO)

Il pin SPI dal centro a sinistra si collega al pin dell'orologio (SCK)

Il pin SPI in basso a sinistra si unisce al Reset. (Impareremo dettagliatamente su questo pin nei seguenti tutorial)

SPI relativo ai collegamenti in basso a destra con il pin GND dell'MCU, GND si riferisce al pin che forma la linea di alimentazione zero o il rail negativo (relativo) dell'alimentazione.

L'SPI che termina dall'intestazione centrale destra si collega al pin 'Master Out, Slave IN' (MOSI) dell'MCU.

SPI che esce dall'intestazione in alto a destra è cablato con il (+) dell'MCU che è ovviamente il Vdd o il pin di alimentazione positivo dell'MCU.

Questo è tutto.

Collega i due connettori come spiegato e la tua scheda di interfaccia SPI è pronta per le azioni richieste.

Per ulteriore aiuto puoi consultare la figura mostrata sopra, la tua scheda di interfaccia finale dovrebbe apparire così dopo che tutti i collegamenti dei cavi sono stati opportunamente eseguiti con l'aiuto della discussione sopra.

Spero che tu abbia già costruito l'interfaccia SPI come spiegato nel tutorial precedente, e ora è il momento di assicurarci che il nostro computer accetti il ​​programmatore che dobbiamo integrare tra il PC e l'MCU.

Creazione di un semplice codice di programmazione per un MCU

Prendiamo un'unità USBTinyISP disponibile da Sparkfun, per il collegamento del computer con il microcontrollore.

Sappiamo che qualsiasi sistema operativo per computer come Windows richiederà driver senza i quali sarebbe inutile caricare qualsiasi cosa nel computer, quindi il nostro programmatore avrà bisogno di driver per caricare nel tuo computer.

Diamo un'occhiata alle procedure richieste per l'installazione dei driver nel sistema operativo del tuo computer, qui prendiamo l'esempio del sistema operativo Windows 7 con specifiche a 32 o 64 bit.

Apri sparkfun.com e fai clic su 'pagina del programmatore AVR tascabile'. Il collegamento può essere facilmente visualizzato all'interno della pagina.

Quindi, trova 'Driver Windows' sotto i documenti e fai semplicemente clic su di esso.

Questo ti fornirà il file pocketprog-driver.zip nel tuo computer.

Vai al tuo computer, trova il percorso di download e decomprimi il file scaricato in una cartella.

Nel caso in cui il tuo computer sia un sistema operativo a 64 bit, devi seguire alcuni passaggi aggiuntivi come indicato sotto, con un sistema operativo a 32 bit, puoi iniziare direttamente l'installazione dal file decompresso.

Per un 64 bit segui questi, per 32 bit semplicemente ignora:

Google 'libusb sourceforge' e fare clic su questa ultima versione di collegamenti.

Potresti imbatterti in alcuni file aggiuntivi, tuttavia potresti essere interessato a trovare il file bib, ovvero: libusb-win32-bin - #. #. #. #. Zip

Ora vai e trova questo percorso di download sul tuo computer, decomprimilo e salvalo in una delle cartelle.

In questa cartella, naviga sulla cartella bin, procedendo alla cartella amd64.

Vedresti un paio di cartelle qui come: ghcalled libusb0.dll e libusb0.sys.

Potresti rinominarli come: libusb0_x64.dll e libusb0_x64.sys.

Ora dovrai copiare i file sopra nella cartella pocketprog-driver, semplicemente sovrascrivendo i file sulla versione esistente.

Per installare i driver di cui sopra, ti interesserebbe il seguente metodo, piuttosto non convenzionale nel suo tipo:

È una modalità 'aggiungi hardware legacy'.

Fare clic su 'Menu Start'

Quindi procedi facendo clic con il pulsante destro del mouse su 'computer'

Fare clic su 'Gestisci' e infine su 'Gestione dispositivi'

Quindi, all'interno del menu, scegli 'Aggiungi hardware legacy'

Continuare a premere 'Avanti', fino a quando non viene inserita la procedura guidata

Seguendo le istruzioni, fai clic su 'Installa l'hardware che dovresti selezionare da un elenco Avanzato', questo farà apparire l'icona del pulsante di opzione in quella particolare selezione. In realtà è un pulsante di controllo di Windows che ora apparirebbe come un minuscolo cerchio con una limatura blu tondeggiante all'interno.

Ora fai semplicemente clic su 'Avanti'

Questo ti mostrerà il menu 'Mostra tutti i dispositivi' su cui dovrai fare clic.

Dopodiché, fai clic sull'icona 'Disco driver'.

Con l'aiuto dell'icona 'Sfoglia', vai avanti alla posizione della cartella pocketprog-driver. Se la selezione è stata eseguita correttamente da te, visualizzerai il file pocketprog.inf posizionato in quella particolare cartella.

Fai doppio clic su questo file e vedrai sicuramente l'installazione del driver nel tuo PC.

Finita e finita !! Andiamo avanti con il nostro prossimo tutorial nella pagina successiva.

A questo punto potresti aver installato il software richiesto e costruito l'interfaccia SPI.

Come trasferire un programma in un chip del microcontrollore

Il passaggio successivo richiederà alcuni componenti come una breadboard, un LED e un resistore calcolato per l'applicazione prevista.

In questa sezione impareremo il metodo di test del programmatore e confermeremo l'installazione dei driver e del software pertinenti.

Per verificare se i driver e il software sono stati installati correttamente, implementeremo un semplice programma noto come avrdude.

AVRdude è un programma associato all'ultima installazione di WinAVR senza la quale non è possibile il trasferimento effettivo del file nell'MCU.

Questo programma è un formato di file .hex che diventa essenzialmente comprensibile all'MCU per le esecuzioni richieste.

Nel caso in cui la verifica non abbia esito positivo, il programmatore non sarà in grado di effettuare il trasferimento del file.

Vediamo rapidamente come possiamo implementare la procedura di test con l'aiuto delle seguenti istruzioni:

Aprire il prompt del DOS (sistema operativo del disco) facendo clic su 'menu di avvio' e digitando cmd.exe nella casella di ricerca fornita.

Ora l'esecuzione di AVRdude può essere eseguita semplicemente digitando avrdude –c usbtiny –p m32 sul prompt del DOS. Non appena viene implementato, il DOS riconoscerà immediatamente se la connessione è andata a buon fine.

Nel comando precedente, '-c' è un flag di notifica che include la specifica del parametro del programmatore 'usbtiny', mentre il tag '-p' identifica il dispositivo microcontrollore ('m32 indica Atmega32).

Se hai utilizzato un MCU diverso, dovresti includere i prefissi pertinenti per l'implementazione.

Una volta terminata la procedura di cui sopra, puoi digitare 'exit' sul prompt di DOS, e questo ti sposterà fuori dalla finestra.

Se ti stai seriamente chiedendo riguardo ai dettagli di programmazione effettivi, beh, per questo dovremmo prima saldare e costruire il circuito LED analogico esterno su cui il programma potrebbe essere implementato, perché a meno che non ci sia un sistema per riconoscere la risposta dall'MCU, la programmazione e il funzionamento del microcontrollore sarebbe del tutto privo di significato.

Realizzare la scheda LED è molto semplice, si tratta di saldare i due cavi del LED su un pezzo di veroboard e collegare il resistore con uno dei cavi del LED. Il ruolo di questo LED è solo quello di limitare la corrente al LED in modo che non si bruci a causa dell'eccesso di tensione e corrente dall'uscita MCU.

Il valore del resistore può essere calcolato utilizzando la seguente semplice formula:

R = (Ub - LEDfwd) / I

Dove Ub è la tensione di alimentazione, LEDfwd è la tensione operativa ottimale del LED utilizzato e I è i suoi amplificatori ottimali.

Supponiamo di utilizzare un LED ROSSO che ha una tensione diretta del LED = 2,5 V e corrente I = 20 mA, l'equazione sopra può essere risolta come segue:

Poiché la tensione dall'MCU sarebbe 5 V, può essere espressa come:

R = (5-2,5) /. 02 = 125 ohm, ¼ watt, il valore più vicino è 120 ohm.

Ora abbiamo il LED, una resistenza da 120 ohm e una veroboard, semplicemente interconnettere i componenti sopra come indicato nello schema con il microcontrollore.

Una volta fatto questo, l'MCU potrebbe essere programmato per la risposta prevista sulla configurazione del LED sopra.

Successivamente, la programmazione dell'MCU.

Per consentire al microcontrollore di eseguire alcune implementazioni significative, è imperativo scrivere istruzioni appropriate nell'MCU.

Come installare un ambiente di programmazione e indagare su WinAVR

Per questo potremmo probabilmente usare il nostro 'editor di testo' nel nostro PC, anche se molti di noi apprezzerebbero l'uso di un 'ambiente di programmazione' più professionale invece di un normale editor di testo, semplice perché questo approccio ti permetterebbe di goderti alcuni caratteristiche interessanti integrate in questo pacchetto 'ambiente di programmazione'.

Supporterebbe la creazione e la modifica di programmi in diversi linguaggi e li comporterebbe anche in una modalità di consegna facilmente comprensibile e accettata da un chip microcontrollore.

Alla fine questo sarebbe supportato da WinAVR e trasferito nel chip MCU interessato.

WinAVR potrebbe anche essere attrezzato per eseguire molte altre operazioni come la risoluzione dei problemi dei programmi e avvertirci sulla possibile sintassi e errori di compilazione ed errori. Discuteremo di questi nei nostri tutorial successivi.

Il corso di installazione di WinAVR dovrebbe essere estremamente rapido e scattante. Entriamo nei dettagli con i seguenti punti:

Dovrai scaricare le versioni più recenti dalla cartella dei file di forge di WinAVR. Potresti trovare alcune informazioni utili relative a questo download dal suo sito Web ufficiale.

Ti verrà richiesto di eseguire una query di sicurezza, in modo da poter rispondere se desideri che il download avvenga, viene chiesto che il file da scaricare sia un file eseguibile.

Scarica il file e avvia il processo di esecuzione facendo clic su di esso. Lascia che l'installazione abbia inizio.

Il processo ti guiderà con alcune domande a cui rispondere in modo che tu possa essere in grado di semplificare l'installazione secondo il tuo comfort. Vorresti ignorare molti di questi nelle loro forme predefinite, spetta a te selezionare quelli che ritieni siano più adatti per le azioni.

Fino ad ora avresti trovato tutto abbastanza normale e facile e avresti trovato alcune opzioni nel menu di avvio che ti venivano lanciate. Nessun problema, solo alcuni di questi utilizzerebbero effettivamente solo uno dei termini denominati 'programmers notepad'.

Una volta cliccato su questa icona, avvierà l'interfaccia utente in modo da poter applicare la scrittura dei programmi (come la creazione e la modifica). Saresti anche testimone del programma composto da comandi di menu per aiutarti a compilare i codici e incorporarli nel microcontrollore.

Il compito fondamentale del blocco note del programmatore di cui sopra è trasformare un codice leggibile dall'uomo che dovresti scrivere in una serie di istruzioni comprensibili solo all'MCU.

Il prossimo tutorial tratterà il test del programmatore di cui sopra in modo che possiamo essere sicuri della sua compatibilità con Windows e se 'stringe la mano' perfettamente con il tuo microcontrollore IC.

Come programmare un MCU per l'accensione di un LED

Una volta confermato ciò, si procederà alla creazione di un piccolo codice 'non fare nulla', proprio per garantire che la procedura di trasferimento del codice non incontri errori.

Ovviamente ora siamo pronti per implementare il nostro primo programma all'interno dell'MCU, ma prima sarebbe interessante riassumere velocemente cosa abbiamo fatto nel corso dei nostri tutorial precedenti:

Abbiamo procurato il microcontrollore AVR Atmel secondo le nostre specifiche richieste qui abbiamo utilizzato ATMega32 per le illustrazioni. Successivamente, abbiamo appreso le basi del microcontrollore e l'unità di programmazione che è responsabile del trasferimento di un programma nel chip MCU.

Successivamente, abbiamo costruito il connettore dell'interfaccia SP che è essenziale affinché il tuo computer possa essere collegato al microcontrollore per le azioni di programmazione.

Successivamente abbiamo verificato se i driver sono stati installati correttamente nel computer per un sistema operativo a 32 bit e 64 ma.

Successivamente, abbiamo installato l'ambiente di programmazione denominato Win AVR per facilitare la facile scrittura e il trasferimento dei codici nel microcontrollore, seguito dall'implementazione dell'avrdude per la verifica del programmatore con il vostro PC e il microcontrollore interconnessi.

Infine nel capitolo precedente abbiamo finito di costruire il circuito LED / resistore e lo abbiamo collegato con le relative uscite MCU.

È davvero un sacco di lavoro, ma è ora di dedicarsi subito a delle vere cose di programmazione!

Per cominciare vorremmo dividere il microcontrollore in tre categorie questo semplificherebbe molto la nostra comprensione:

Controllo, rilevamento e comunicazione

Sarebbe interessante sapere che le funzioni di cui sopra possono essere programmate in molti modi diversi.

Nel nostro primo programma proveremmo ad ordinare al microcontrollore di 'controllare' un parametro esterno, sì hai ragione sarebbe il LED che abbiamo costruito di recente.

Per essere precisi, diremo all'MCU di accendere il LED collegato, sì, lo so che sembra piuttosto primitivo, ma la fase di avvio deve essere sempre facile.

Andando avanti con il lavoro attuale, fare in modo che l'MCU controlli il LED è in realtà piuttosto semplice:

Per questo istruiamo il pin # 0 sulla PORTA B a produrre i 5V richiesti per il LED.

Ricordiamo dal tutorial precedente, abbiamo collegato l'anodo del LED al suddetto pin della MCU.

Ci sono due cose essenziali che devono essere indirizzate a questo pin dell'MCU: 1) uscita e 2) 5 volt

Impareremo un modo attraverso il quale possiamo istruire il particolare pin a diventare l'uscita dell'MCU.

Una volta impostato come uscita del chip, possiamo istruirlo su 'alto' (5 V) o 'basso' (0 V) come desiderato per un'applicazione.

Poiché qualsiasi circuito logico come un MCU i pin potrebbero essere un output o un input e potrebbero essere configurati per produrre un logico alto o logico basso, i pin devono essere assegnati solo per essere un logico alto o un logico basso , non ci sono stati intermedi o indefiniti oltre a questi due stati per microcontrollori o per qualsiasi IC digitale per quella materia. Lo stesso vale per ogni pin dell'MCU.

Per quanto riguarda le assegnazioni dei pin di ingresso e uscita, gli ingressi sarebbero posizionati per accettare segnali da stadi analogici esterni, mentre le uscite sarebbero responsabili dell'interpretazione di questi negli stati logici specificati, o una frequenza.

Sebbene gli incarichi di cui sopra potrebbero essere eseguiti in molti metodi diversi, ne discuteremo uno per semplicità. Tuttavia va notato che sebbene quello presentato in questo momento sembri facile e interessante, non è così praticabile e non è un tipo consigliato per tutte le applicazioni MCU, per lo stesso motivo per cui verrai introdotto a metodi di programmazione più popolari più avanti nel corso . Questi programmi consentiranno di assegnare solo i pin desiderati secondo le specifiche senza influenzare gli altri adiacenti che potrebbero essere già assegnati per svolgere altre funzioni.

Tuttavia in questo momento non ci preoccuperemo così tanto degli altri pin e utilizzeremo solo i pin rilevanti di interesse, evitando complicazioni in una certa misura.

Per assegnare un pin come uscita dobbiamo utilizzare il Data Direction Register (DDR). Se ti stai chiedendo cosa significhi registrare qui, è semplicemente uno spazio nell'MCU che consente al microcontrollore di rispondere in un modo specificato.

Usando la DDR possiamo impostare il pin per inviare un dato che è come un 'output', o accettare i dati che sono sotto forma di un 'input'.

Tuttavia potresti essere confuso riguardo alla parola, cosa significa? Un dato aggiunge una terza dimensione ai pin che possono essere assegnati in modo continuo a zero logico (0V) o logico alto (5V), ma per quanto riguarda i segnali che potrebbero variare rapidamente come una frequenza di impulsi. Una frequenza sarebbe accompagnata da logiche alta e bassa (5V e 0V) oscillanti con alcuni intervalli o periodi specificati, quindi diventa orientata al tempo e può essere regolata rispetto al tempo, ecco perché ci identifichiamo come 'dato' che significa un parametro che indica una funzione relativa a un'altra funzione (stati logici e tempo).

Un metodo per assegnare pin0 come uscita consiste nello scrivere il codice seguente:

DDRB = 0b00000001

Nel programma sopra, DDRB indica che il registro di direzione dei dati per la PORTA B 0b istruisce il compilatore sulla seguente espressione binaria di un numero mentre '1' alla fine dell'espressione indica la posizione del pin0, ovvero la sua posizione nel modulo del primo pin di PORT B.

Se ricordi che abbiamo appreso che la PORTA B associa 8 pin con essa (da 0 a pin7), e se noti che il codice sopra ha anche 8 cifre, significa che ogni cifra indica questi 8 pin della PORTA B.

Ora la procedura successiva sarebbe assegnare 5V a questo pin (pin0). Anche in questo caso il principio di funzionamento è identico a DDR come sopra espresso attraverso il seguente codice binario:

PORTB = 0b00000001

Come si può vedere, l'unica differenza tra il codice sopra e quello precedente è che in questo codice abbiamo fatto uso del registro PORT. Questo registro gestisce specificamente le assegnazioni dei pin di quella particolare porta per la quale è stato posizionato all'interno dell'MCU. Quindi ci permette di assegnare le logiche dei dati reali (0 o 1) per quei pinout.

Ora potremmo essere interessati a discuterne alcuni riguardo ai dettagli approssimativi del nostro programma. Come sappiamo tutti i programmi richiedono uno spazio particolare per avviare l'esecuzione, questo può essere paragonato a uno chef che conosce tutti gli ingredienti di una particolare ricetta ma non è istruito da dove cominciare.

La funzione 'principale' qui è la posizione in cui ciascuno dei programmi C / C ++ inizia l'esecuzione. Pertanto il main può essere creato come:

int main (void)
{
}

Tuttavia, per consentire al programma di interpretare i dettagli dei registri DDR e PORT e il loro funzionamento all'interno del chip MCU, è necessario includere un'istruzione aggiuntiva che può essere costituita da tutti i dati relativi all'MCU AVR. Forse vorremmo aggiungere questa inclusione in tutti i nostri programmi.

#includere
int main (void)
{
}

Non appena inizia la compilazione, la sezione del pre-processore del compilatore si concentra sulla directory AVR per identificare il file 'io.h'. L'estensione '.h' qui indica che è un file di intestazione e che questo codice all'interno del file verrebbe introdotto all'inizio (intestazione) del file sorgente che viene creato, da cui il nome 'intestazione'.

Qui possiamo introdurre le istruzioni DDR e PORT nel nostro codice, perché l'aggiunta del file di intestazione io.h avrebbe indirizzato il compilatore a riguardo.

#includere

int main (void)

{

DDRB = 0b00000001 // Data Direction Register impostando pin0 su output e i pin rimanenti come input

PORTB = 0b00000001 // Imposta pin0 a 5 volt

}

Quanto sopra fissa l'orientamento del pin0 come uscita, avente una grandezza di 5V. Tuttavia, c'è ancora un problema che non è stato determinato per questo pin, ovvero che questo pin deve ancora essere attivato per un tempo indefinito fintanto che l'MCU è alimentato. Questo ciclo di feedback infinito assicurerebbe che questo pin dall'MCU non si spenga, ma continui indefinitamente con l'uscita 5V.

Sebbene ci siano molti metodi diversi per applicare un'istruzione di ciclo per un pin, proveremmo a utilizzare il ciclo 'while' qui. Come suggerisce il nome, il loop 'while' dice al microcontrollore che 'mentre' l'alimentazione è disponibile è necessario rimanere attivato con i 5V assegnati per il pinout assegnato.

#includere

int main (void)

{

DDRB = 0b00000001 // Data Direction Register impostando pin0 su output e i pin rimanenti come input

PORTB = 0b00000001 // Imposta pin0 a 5 volt

mentre (1)

{

// Il codice sarebbe qui se avesse bisogno di essere eseguito più e più volte ... all'infinito

}

}

Potresti notare che, qui abbiamo usato '1' sotto forma di argomento per il ciclo 'while', poiché tutto tranne '0' potrebbe essere considerato un 'vero' logico.

Ciò implica che la considerazione del ciclo 'while' non sarebbe mai responsabile di nulla tranne che di un 'vero' logico, il che significa che il particolare pin si attaccherebbe indefinitamente allo stato specificato.

È possibile osservare che il LED è acceso permanentemente attraverso il pin assegnato fintanto che l'MCU ha ricevuto alimentazione attraverso i suoi Vdd e Vss.

Ecco fatto, ora abbiamo il risultato che volevamo ottenere e finalmente possiamo vederlo accadere dopo così tanto duro lavoro, ma tuttavia vedere il dolce risultato del nostro duro lavoro è così soddisfacente.

Nei prossimi tutorial impareremo come aggiungere una dimensione 'tempo' al LED sopra, ovvero come farlo lampeggiare a una certa velocità specificata.

In realtà, nell'implementazione di cui sopra, il LED sta effettivamente lampeggiando ma la frequenza del loop è così rapida che è quasi come un interruttore permanente su ON sopra l'illuminazione a LED.

Vedremo come questo loop può essere aggiunto con un ritardo a piacere per far lampeggiare il LED a quella velocità ritardata.

Come far lampeggiare un LED usando il microcontrollore AVR

Nell'ultima discussione, abbiamo imparato come accendere un LED tramite un microcontrollore, è stato eccezionale, no? Potrebbe non essere così tanto!

Qui impareremo come rendere più piccante l'illuminazione a LED sopra attribuendo una funzionalità bidirezionale, ovvero proveremo a farla lampeggiare o lampeggiare a una frequenza o velocità specificata. Vedremo anche come questo tasso potrebbe essere aumentato o diminuito come desiderato dall'utente.

Diamo un'occhiata a questo:

#includere

#includere

int main (void)

{

DDRB | = 1<< PINB0

mentre (1)

{

PORTB ^ = 1<< PINB0

_delay_ms (100)

}

}

Se ti senti sconcertato da quegli strani simboli (&, ^, | ecc.) Usati nell'espressione sopra (& non c'è ma potrebbe essere usato in altri codici simili), ecco le informazioni correlate che ti interesserebbe sapere su questi :

Include molti algoritmi logici standard come AND, OR, NOT e XOR che vengono tipicamente utilizzati con il codice precedente.

Queste funzionalità logiche confrontano specificamente i due bit '1' e '0' in base alle tabelle di verità assegnate.

Ci faremo un'idea analizzando la seguente disposizione dei bit:

01001011 e
10001101
è uguale a
00001001

Nel codice sopra & si riferisce a AND come utilizzato nella programmazione C.

Leggendo le righe verticalmente, suggerisce che 0 e 1 è uguale a 0, 1 e anche 0 è uguale a 0, 0 e 0 è uguale a 0, 1 e 1 è uguale a 1. Leggere è così semplice. Questi sono secondo la tabella di verità di un operatore AND.

Se valutiamo la seguente tabella, indica il simbolo '|' che denota l'uso della funzionalità 'OR', il '|' potrebbe essere trovato appena a sinistra di 'backspace' nella tastiera del computer:

01001011 |
10001101
è uguale a
11001111

In modo identico, questa tabella di verità di una funzionalità logica OR indica che i bit 0 o 1 sono uguali a 1, 1 o 0 sono uguali a 1, 0 o 0 sono uguali a 0, mentre 1 o 1 è uguale a 1.

La seguente combinazione di bit è per l'operatore logico XOR indicato con ^ e può essere studiata proprio come abbiamo fatto con le tabelle di verità AND, OR:

01001011 ^
10001101
è uguale a
11000110

Ora continuiamo con il primo programma e impariamo cosa significa la riga seguente:

#includere

Attraverso i nostri tutorial precedenti sappiamo come funziona l'espressione, quindi non la ripeteremo, tuttavia il loro sembra essere un nuovo 'include' espresso da #include che deve essere esaminato.

In questo 'include' il delay.h ci consente alcuni semplici metodi di implementazione.

Come suggerisce il nome, delay.h ci consente di indurre un ritardo nel particolare programma.

La prossima espressione int main (void) potrebbe essere omessa dalla discussione in corso poiché ne abbiamo già parlato nei nostri post precedenti.

Poi arriva la DDRB modificata.

Quanto segue mostra la forma precedente che non è un modo migliore di assegnare i pin poiché tutti i pin da 0 a 7 sono stati commutati per formare gli ingressi. Ma immagina solo quale sarebbe la situazione se volessimo creare un programma più lungo che richiede quei pin per qualche altra funzionalità? Ad esempio, pin2 potrebbe essere necessario per applicare una commutazione remota di un apparecchio. In tal caso non apprezzeremmo assegnare lo stesso di un input solo attraverso tentativi ed errori. Ciò potrebbe significare una risposta errata dal trasmettitore remoto al ricevitore dell'apparecchio.

DDRB = 0b00000001

Vogliamo piuttosto influenzare solo un bit, hat pin0 bit, dando un'occhiata alla funzionalità 'OR' che potrebbe essere eseguita attraverso un mascheramento binario.

DDRB = DDRB | 0b00000001

Qui è velato con una maschera 'OR': 0b00000001, anche se sembra essere un numero binario autentico, nel caso in cui il DDRB precedente ad esempio: 0b01001010, quindi applicare un OR a questo tramite mascheramento potrebbe dare: 0b01001010 | 0b00000001 = 0b01001011.

La differenza risultante come si è potuto vedere è solo con il pin0, i cui bit sono cambiati!

Comprimendo ulteriormente l'istruzione di cui sopra tramite C ++ si ottiene:

DDRB | = 0b00000001

Tuttavia, scopriamo che c'è ancora di più nel programma dato. Sebbene possa sembrare abbastanza legittimo e ovvio, dovremmo trarre vantaggio da alcune delle affermazioni del file di intestazione io.h, specialmente quando è creato fondamentalmente per nostra comodità?

Quindi, se '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.

Quindi iniziamo con 0b00000000 e mettiamo un '1' per produrre 0b0000001 e poi lo trasferiamo a sinistra 0 posizioni, che dà un 0b00000001 esattamente identico come sopra.

Ora, supponendo che fosse PINB4, l'affermazione potrebbe essere espressa come 1<< PINB4. I this case the “1” would be pushed to the left 4 locations producing: 0b00010000.

Attenzione, stiamo utilizzando un indice zero, il che significa che ci sono quattro zeri dopo '1'.

Ora procediamo al ciclo 'while' che avevamo notato in precedenza nel 'ciclo infinito'. Ma forse ora vogliamo che il microcontrollore implementi alcune delle esecuzioni desiderate. Questo può essere fattibile solo all'interno del ciclo dato. È il ciclo in cui la sequenza particolare viene ripetuta ancora e ancora.

Nel caso in cui l'esecuzione fosse stata inserita prima del ciclo, sarebbe stata implementata solo una volta.

Tuttavia, per far lampeggiare il LED indefinitamente, sarebbe necessario accendere / spegnere alternativamente il PINB0 all'interno del loop. Qui troviamo anche i ritardi in fase di introduzione, senza i quali il lampeggio del LED sarebbe impossibile. Ma questo costringerebbe il LED a lampeggiare ad una velocità molto rapida difficile da riconoscere ad occhio nudo, avrebbe bisogno di rallentare un po 'per diventare identificabile con i nostri occhi.

Siamo consapevoli della procedura di impostazione di un bit particolare nel numero binario, ma non siamo sicuri del metodo per applicare un bit specifico '0' nel caso in cui sia ancora un '1'.

Il seguente programma potrebbe essere visto mentre lo fa, ma scopriremo anche che potrebbe non essere visibile nel programma.

Le due istruzioni iniziali cambiano il bit in '1' (5V, LED acceso), quindi viene introdotta una pausa di 100 ms.

Il prossimo paio di righe trasforma il bit PINB0 in '0' (tensione zero, LED spento), ma scusate il confronto AND non sarà in grado di eseguire uno '0' dal bit, ma se usiamo NOT '~' per la maschera binaria potrebbe cambiare tutti gli 0 in 1 e viceversa.

Questo ci consentirà di influenzare solo il bit PINB0 e portarlo a '0'. La parentesi è stata inclusa per contenere l'esecuzione del mascheramento in modo tale che l'operazione NOT potesse essere applicata a tutte le maschere e non semplicemente sopra l ''1' prima dello shift a sinistra '<<”.

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

Al fine di creare ritardi ON OFF o periodi di uguale durata, possiamo accorciare le quattro righe precedenti a due e applicare la funzionalità XOR a nostro vantaggio. Va notato che un'esecuzione XOR ha assegnato un pin a 1 nel caso in cui sia 0 e viceversa. Questa esecuzione influenzerebbe solo il PINB0. Come molte volte il comando viene applicato, trasformerebbe semplicemente il bit nell'opposto della logica esistente.

PORTB ^ = 1<< PINB0
_delay_ms (100)

FATTO! Il tuo LED lampeggerebbe ora secondo la velocità impostata ... Semplice, non è vero?