Exploração de princípios básicos do microcontrolador

Uma coisa é ótima sobre os ICs de microcontroladores, eles estão disponíveis em quase todas as partes do mundo e em varejistas eletrônicos.

Introdução

Dispositivos microcontroladores fundamentalmente são usados ​​popularmente em aplicações que envolvem avaliações do ambiente circundante e em eletrônicos semelhantes.

Você pode encontrar esses dispositivos sendo usados ​​para exibir um determinado parâmetro, em aplicações de controle de motor, iluminação LED, sensores de vários tipos, como sensor de inclinação, acelerômetro, medidor de velocidade, registradores de dados, controladores de temperatura, teclados etc.

O entendimento primário sobre microcontroladores pode ser obtido referindo-se ao microcontrolador AVR Amega32, que é tão avançado que às vezes é chamado de computador dentro de um chip.

Este dispositivo é designado para executar uma série de comandos para formar um programa.

A linguagem do programa que você veria aqui é C ++. Você aprenderá esse idioma com mais profundidade no curso aqui.

Quando se trata de MCUs, você tem a facilidade de ter a opção de controlar e configurar todas as suas pinagens.

Se você está ficando um pouco cansado com isso, relaxe porque não é nada complexo, você será facilitado por todos os aspectos de forma constante, mas firme, à medida que avançamos.

Em um chip MCU, todos os pinos, exceto o Vdd e o Vss, que são os pinos de alimentação do chip, podem ser atribuídos com designações exclusivas.

Detalhes de pinagem

Se você olhar o chip de cima para baixo, encontrará um pequeno entalhe triangular que indica o ponto inicial de onde a pinagem começa, conta que é o pino nº 1 do chip que começa logo abaixo deste entalhe.

Começando com esse pino, você encontrará 20 pinos até a parte inferior daquele lado (esquerda) e outros 20 pinos do outro lado (direita), continuando de baixo para cima no lado direito.

Os primeiros 8 pinos a partir do entalhe são o PBO-7 que formam os pinos de índice do IC, uma vez que todos os programas aqui começam com o índice zero.

A série de pinagens acima é denominada PORTA B, embora existam outros conjuntos idênticos de portas atribuídas de A a D.

Essas portas podem ser atribuídas para aceitar e reconhecer dados alimentados chamados INPUT, e também para transmitir dados em alguma forma especificada chamada OUTPUT.

Dois dos pinos que vêm na categoria geral são os pinos (+) / (-), também chamados de Vdd e GND.

Um pino da PORTA D (PDO-6) pode ser visto localizado no lado esquerdo do chip na área inferior.

PD7, que é o pino nº 7 da PORTA D, pode ser rastreado sozinho e iniciando a série de pinagens do lado direito.

Agora avançando do lado direito do chip onde a PORTA D termina, a PORTA C começa sua contagem para cima na ordem.

Estes contribuem para os muitos pinos interessantes do MCU, desde os analógicos aos digitais.

Esses pinos são apresentados para se tornarem as entradas de detecção para detectar os vários parâmetros por meio de estágios de circuito analógico configurados externamente.

Os pinos acima constituem o PORTO A.

A conversão analógica para digital através dos pinos acima pode ser entendida com a ajuda de um exemplo em que um nível de temperatura analógico detectado usando um sensor comum, como um termistor, é aplicado a um dos pinos da PORTA A que é prontamente aceito e conversor pelo MCU para produzir uma leitura digital de zero a 255 graus F (um número de 8 bits que pode ser atualizado para obter uma saída de 10 bits).

Outra característica que pode ser observada em MCUs adicionalmente é o espaço de programação disponível ou a memória que determina o espaço para as variáveis ​​e programa especificado para o microcontrolador.

Além disso, os MCUs têm um relógio embutido designado para contar os parâmetros relevantes.

Os recursos de relógio permitem que o MCU aplique-se a muitos processos de contagem diferentes que podem ser rápidos na faixa de microssegundos, dependendo da especificação do dispositivo em particular, e também podem ser mais lentos em qualquer extensão desejada.

Agora você deve ter entendido o conceito de microcontrolador até certo ponto e com relação a suas portas e pinos.

Como criar um conector SPI do programador para o microcontrolador

Agora é hora de se aprofundar no assunto e investigar o mundo da programação.

Dito isso, antes de entrar em um procedimento de carregamento de programa no chip, precisamos encontrar uma maneira adequada de integrar o conector SPI (Serial Peripheral Interface) ao MCU.

No entanto, mesmo depois disso, não podemos simplesmente empurrar o SPI para as pinagens do MCU, podemos? Também não podemos permitir que os fios estendidos do SPI sejam inseridos diretamente na placa de pão. Isso também pode causar a configuração incorreta dos fios conectados aos pinos incorretos que fazem conexões ruins.

Portanto, a fim de tornar as coisas absolutamente impecáveis, fazemos os procedimentos sobre um pequeno veroboard onde obtemos os pinos de metal de conexão necessários também chamados de “header” soldados. Esses pinos de cabeçalho agora podem ser usados ​​para conexão com o conector SPI. As conexões deste cabeçalho podem ser terminadas em outros pinos de cabeçalho paralelos que podem ser usados ​​para as conexões de breadboard.

Assim, o conjunto acima agora forma uma plataforma de conexão intermediária confortável e confiável para o SPI ao MCU.

Até agora tudo parece bom e perfeito, então vamos passar a ganhar em relação ao programador que é necessário entre o seu PC e o MCU.

Pode haver uma série de empresas que fazem e vendem essas unidades de programador, portanto, adquiri-los não deve ser um problema para você, como a Adafruit Industries, USBtinyISP ou Sparkfun etc.

Alguns deles podem parecer totalmente diferentes dos tipos convencionais, mas basicamente têm tudo idêntico e seguem as regras de programação padrão e podem ser usados ​​como uma interface entre o seu PC e o microcontrolador AVR.

No entanto, certifique-se de que se você estiver usando algum outro MCU e não um AVR Atmega32, talvez seja necessário verificar se há um programador compatível para esse chip MCU específico.

Pode-se observar que alguns desses programadores empregam drivers idênticos, algo que deve ser cuidado e aprenderemos mais sobre isso em nossos capítulos subsequentes.

Conectar seu PC com o chip do microcontrolador é realmente básico e você ficaria encantado em saber como os procedimentos são simples para isso. Então, vamos apertar o botão imediatamente J

Fazer a placa de interface SPI explicada acima não é difícil, é tudo sobre como fazer o seu ferro de solda funcionar através de todas as conexões nas duas fileiras de pinos mostradas em uma pequena placa de uso geral.

A figura acima mostra os detalhes de conexão que você teria que seguir ao interconectar os fios entre os conectores.

Para tornar as coisas ainda mais simples, vamos examinar os seguintes detalhes de conexão para o mesmo, referindo-se à imagem acima:

O pino SPI começando do canto superior esquerdo vai para 'Master IN, Slave OUT' (MISO)

O pino SPI do centro à esquerda conecta-se ao pino do relógio (SCK)

O pino SPI na parte inferior esquerda se une ao Reset. (Aprenderemos detalhadamente sobre este pino nos seguintes tutoriais)

O SPI relevante para a parte inferior direita conecta-se ao pino GND do MCU, GND refere-se ao pino que forma a linha de alimentação zero ou o trilho negativo (relativo) da alimentação.

O SPI que termina do meio à direita do cabeçalho liga-se ao pino “Master Out, Slave IN” (MOSI) do MCU.

O SPI que sai do cabeçalho superior direito está conectado com o (+) do MCU que é obviamente o Vdd ou o pino de alimentação positivo do MCU.

É isso.

Conecte os dois conectores conforme explicado e sua placa de interface SPI estará pronta para as ações necessárias.

Para obter mais ajuda, você pode consultar a figura mostrada acima, sua placa de interface final deve ficar assim depois que todas as conexões de fios forem feitas apropriadamente com a ajuda da discussão acima.

Espero que você já tenha construído a interface SPI conforme explicado no tutorial anterior, e agora é hora de garantir que nosso computador aceite o programador que precisamos integrar entre o PC e o MCU.

Fazendo um código de programação simples para um MCU

Pegamos uma unidade USBTinyISP disponível na Sparkfun, para conectar o computador ao microcontrolador.

Sabemos que qualquer sistema operacional de computador como o Windows exigirá drivers sem os quais seria inútil carregar qualquer coisa no computador, portanto, nosso programador precisará de drivers para carregar em seu computador.

Vamos dar uma olhada nos procedimentos necessários para instalar os drivers no sistema operacional do seu computador. Aqui, tomamos o exemplo do sistema operacional Windows 7 com especificações de 32 ou 64 bits.

Abra sparkfun.com e clique em “pocket AVR programmer page”. O link pode ser facilmente visualizado na página.

Em seguida, encontre ”driver do Windows” em documentos e simplesmente clique nele.

Isso fornecerá o arquivo pocketprog-driver.zip em seu computador.

Vá para o seu computador, encontre o local do download e descompacte o arquivo baixado em uma pasta.

No caso do seu computador ser um sistema operacional de 64 bits, você precisa seguir mais alguns passos conforme descrito em, com um sistema operacional de 32 bits, você pode iniciar a instalação diretamente a partir do arquivo descompactado.

Para 64 bits, siga estes, para 32 bits simplesmente ignore:

Google “libusb sourceforge” e clique neste link da versão mais recente.

Você encontraria alguns arquivos adicionais, mas estaria interessado em encontrar o arquivo bib, isto é: libusb-win32-bin - #. #. #. #. Zip

Agora, vá e encontre este local de download em seu computador, descompacte-o e salve-o em uma das pastas.

Nessa pasta, navegue até a pasta bin e prossiga para a pasta amd64.

Você veria algumas pastas aqui como: ghcalled libusb0.dll e libusb0.sys.

Você pode querer renomeá-los como: libusb0_x64.dll e libusb0_x64.sys.

Agora você precisará copiar os arquivos acima para a pasta pocketprog-driver, simplesmente sobrescrever os arquivos na versão existente.

Para instalar os drivers acima, o método a seguir, que é um tanto não convencional em seu tipo, interessa a você:

É um modo de “adicionar hardware legado”.

Clique em “Menu Iniciar”

Em seguida, clique com o botão direito do mouse em “computador”

Clique em “Gerenciar” e, por fim, clique em “gerenciador de dispositivos”

Em seguida, dentro do menu, escolha “Adicionar Hardware Legado”

Continue pressionando “próximo”, até que o assistente seja inserido

Seguindo as instruções, clique em “Instalar o hardware que você precisa selecionar em uma lista Avançada”, isso fará com que o ícone do botão de rádio para essa seleção particular. Na verdade, é um botão de controle do Windows que agora pareceria um pequeno círculo com um preenchimento azul arredondado dentro.

Agora basta clicar em “Avançar”

Isso mostrará o menu “Mostrar todos os dispositivos”, no qual você precisará clicar.

Depois disso, clique no ícone “Com disco”.

Com a ajuda do ícone “Browse”, vá em frente para a localização da pasta pocketprog-driver. Se a seleção foi feita corretamente por você, você visualizaria o arquivo pocketprog.inf colocado nessa pasta específica.

Dê um clique duplo sobre este arquivo e você certamente testemunhará o driver sendo instalado em seu PC.

Fim de transmissão!! Vamos continuar com nosso próximo tutorial na próxima página.

Agora você deve ter instalado o software necessário e construído a interface SPI.

Como transferir um programa para um chip microcontrolador

A próxima etapa exigirá alguns componentes, como uma placa de ensaio, um LED e um resistor calculado para a aplicação pretendida.

Nesta seção, aprenderemos o método de teste do programador e confirmaremos a instalação dos drivers relevantes e do software.

Para verificar se os drivers e o software foram instalados corretamente, implementaremos um programa simples conhecido como avrdude.

O AVRdude é um programa associado à última instalação do WinAVR, sem a qual a transferência real do arquivo para o MCU não pode ser possível.

Este programa é um formato de arquivo .hex que se torna essencialmente compreensível para o MCU para as execuções necessárias.

Caso a verificação não seja bem-sucedida, o programador não poderá fazer a transferência do arquivo.

Vamos ver rapidamente como podemos implementar o procedimento de teste com a ajuda das seguintes instruções:

Abra o prompt do DOS (sistema operacional de disco) clicando em “menu iniciar” e digitando cmd.exe na caixa de pesquisa fornecida.

Agora, a execução do AVRdude pode ser feita simplesmente digitando avrdude –c usbtiny –p m32 no prompt do DOS. Assim que isso for implementado, o DOS reconhecerá instantaneamente se a conexão foi bem-sucedida.

No comando acima, o “-c” é um sinalizador de notificação que inclui a especificação do parâmetro do programador “usbtiny”, enquanto a tag “-p” identifica o dispositivo microcontrolador (“m32 indicando Atmega32).

Caso você tenha usado um MCU diferente, será necessário incluir os prefixos relevantes para a implementação.

Uma vez que o procedimento acima for concluído, você pode digitar “exit” no prompt do DOS, e isso o moverá para fora da janela.

Se você está se perguntando seriamente sobre os detalhes reais da programação, para isso precisaríamos primeiro soldar e construir o circuito de LED analógico externo sobre o qual o programa poderia ser implementado, porque a menos que haja um sistema para reconhecer a resposta do MCU, a programação e o funcionamento do microcontrolador não faria sentido.

Fazer a placa de LED é muito simples, é tudo sobre soldar os dois fios do LED sobre um pedaço de veroboard e conectar o resistor com um dos fios do LED. A função deste LED é apenas limitar a corrente ao LED para que não queime devido ao excesso de tensão e corrente da saída MCU.

O valor do resistor pode ser calculado usando a seguinte fórmula simples:

R = (Ub - LEDfwd) / I

Onde Ub é a tensão de alimentação, LEDfwd é a tensão operacional ideal do LED usado e I é a amperagem ideal.

Suponha que usamos um LED VERMELHO que tem um LED de tensão direta = 2,5 V e corrente I = 20 mA, a equação acima pode ser resolvida da seguinte maneira:

Uma vez que a tensão do MCU seria 5 V, pode ser expressa como:

R = (5 - 2,5) /. 02 = 125 ohms, ¼ watt, o valor mais próximo sendo 120 ohms é o suficiente.

Agora que temos o LED, um resistor de 120 ohms e um veroboard, basta interconectar os componentes acima conforme indicado no diagrama com o microcontrolador.

Uma vez feito isso, o MCU pode ser programado para a resposta pretendida na configuração de LED acima.

Em seguida, a programação do MCU.

A fim de permitir que o microcontrolador execute algumas implementações significativas, é imperativo escrever instruções adequadas no MCU.

Como instalar um ambiente de programação e investigar o WinAVR

Para isso, provavelmente poderíamos usar nosso próprio 'editor de texto' em nosso PC, embora muitos de nós apreciassem o uso de um 'ambiente de programação' mais profissional em vez de um editor de texto comum, simples porque esta abordagem permitiria que você aproveitasse alguns recursos interessantes embutidos neste pacote de “ambiente de programação”.

Ele suportaria a criação e edição de programas em diferentes linguagens e também os compilaria em um modo de entrega facilmente compreendido e aceito por um chip microcontrolador.

Em última análise, isso seria suportado pelo WinAVR e transferido para o chip MCU em questão.

O WinAVR também pode ser equipado para executar muitas outras operações, como solucionar problemas de programas e nos avisar sobre possíveis erros de sintaxe e de compilação. Discutiremos isso em nossos tutoriais posteriores.

Você faria com que o curso de instalação do WinAVR fosse extremamente rápido e ágil. Vamos mergulhar nos detalhes com os seguintes pontos:

Você precisará baixar as versões mais recentes da pasta de arquivos forge de origem do WinAVR. Você encontraria algumas informações úteis relacionadas a esse download em seu site oficial.

Você será solicitado em uma consulta de segurança, para que possa responder se deseja que o download seja feito, é perguntado se o arquivo a ser baixado é um arquivo executável.

Baixe o arquivo e inicie o processo de execução clicando nele. Deixe a instalação começar.

O processo irá guiá-lo com algumas perguntas respondíveis para que você possa agilizar a instalação de acordo com o seu conforto. Você pode querer ignorar muitos deles para suas formas padrão, caberia a você selecionar aqueles que você acha que são mais adequados para as ações.

Até agora você acharia tudo bastante normal e fácil e encontraria algumas opções no menu Iniciar sendo lançado para você. Não se preocupe, apenas alguns deles estariam realmente usando apenas um dos dez, denominado “bloco de notas do programador”.

Uma vez clicado neste ícone, iniciará a interface do usuário para que você possa aplicar a escrita dos programas (como criar e editar). Você também testemunharia o programa que consiste em comandos de menu para ajudá-lo a compilar os códigos e incorporá-los ao microcontrolador.

A tarefa fundamental do bloco de notas do programador acima é transformar um código legível por humanos que você escreveria em uma série de instruções compreensíveis apenas para o MCU.

O próximo tutorial irá cobrir o teste do programador acima para que possamos ter certeza sobre sua compatibilidade com o Windows e se ele “aperta a mão” perfeitamente com o seu microcontrolador IC.

Como programar um MCU para ligar um LED

Uma vez que isso seja confirmado, prosseguiríamos com a criação de um pequeno código “não fazer nada”, apenas para garantir que o procedimento de transferência de código não encontre erros.

Claro que agora estamos prontos para implementar nosso primeiro programa dentro do MCU, mas antes disso seria interessante resumir rapidamente o que fizemos no decorrer de nossos tutoriais anteriores:

Adquirimos o microcontrolador AVR Atmel de acordo com nossas especificações exigidas aqui, usamos o ATMega32 para as ilustrações. Em seguida, aprendemos os fundamentos do microcontrolador e a unidade de programação que é responsável por transferir um programa para o chip MCU.

Mais adiante, construímos o conector de interface SP que é essencial para que o seu computador possa ser conectado ao microcontrolador para as ações de programação.

Depois disso, confirmamos se os drivers foram instalados corretamente no computador para um sistema operacional de 32 bits e também de 64 bits.

A seguir, instalamos o ambiente de programação denominado Win AVR para facilitar a escrita e a transferência dos códigos para o microcontrolador, seguida da implementação do avrdude para verificação do programador com o seu PC e o microcontrolador interligados.

Finalmente, no capítulo anterior, concluímos a construção do circuito de LED / resistor e o conectamos às saídas MCU relevantes.

Isso é muito trabalho, no entanto, é hora de ir imediatamente para algumas coisas reais de programação!

Para começar, gostaríamos de dividir o microcontrolador em três categorias, o que simplificaria muito nosso entendimento:

Controle, detecção e comunicação

Seria interessante saber que as funções acima podem ser programadas de muitas maneiras diferentes.

Em nosso primeiro programa tentaríamos ordenar que o microcontrolador “controlasse” um parâmetro externo, sim, você tem razão, seria o LED que construímos recentemente.

Para ser preciso, diremos ao MCU para LIGAR o LED conectado, sim, eu sei que isso parece bastante primitivo, mas a fase inicial sempre precisa ser fácil.

Prosseguindo com o trabalho atual, tornar o controle de MCU do LED é realmente muito simples:

Para isso, instruímos o pino # 0 na PORTA B para produzir os 5 V necessários para o LED.

Lembre-se do tutorial anterior, conectamos o ânodo do LED ao pino mencionado acima do MCU.

Há duas coisas essenciais que devem ser endereçadas a este pino do MCU: 1) saída e 2) 5 volts

Vamos aprender uma maneira pela qual podemos instruir o pino específico para se tornar a saída do MCU.

Assim que for definido como a saída do chip, podemos instruí-lo a ser 'alto' (5 V) ou 'baixo' (0 V), conforme desejado para uma aplicação.

Uma vez que qualquer circuito lógico, como um MCU, os pinos podem murchar uma saída ou uma entrada e podem ser configurados para produzir um alto ou baixo lógico, os pinos só precisam ser atribuídos como um alto ou baixo lógico , não há nenhum estado intermediário ou indefinido além desses dois estados para microcontroladores ou para qualquer IC digital para esse assunto. Além disso, o mesmo se aplica a cada pino do MCU.

Quanto às atribuições dos pinos de entrada e saída, as entradas seriam posicionadas para aceitar sinais de estágios analógicos externos, enquanto as saídas seriam responsáveis ​​por interpretá-los nos estados lógicos especificados, ou uma frequência.

Embora as atribuições acima possam ser feitas em muitos métodos diferentes, estaríamos discutindo um deles por uma questão de simplicidade. No entanto, deve-se notar que embora aquele que seria apresentado agora pareça fácil e interessante, não é tão viável e não é um tipo recomendado para todos os aplicativos MCU, pelo mesmo motivo que você seria apresentado a métodos de programação mais populares posteriormente no curso . Esses programas permitirão que apenas os pinos desejados sejam atribuídos de acordo com as especificações, sem afetar os outros adjacentes, que possivelmente já podem estar atribuídos a algumas outras funções.

No entanto, agora não vamos nos preocupar tanto com os outros pinos e usaríamos apenas os pinos relevantes de interesse, evitando complicações até certo ponto.

Para atribuir um pino como saída, precisamos empregar o Data Direction Register (DDR). Se você está se perguntando o que significa registrar aqui, é simplesmente um espaço no MCU que permite que o microcontrolador responda de alguma maneira especificada.

Usando o DDR, podemos definir o pino para enviar dados que são como uma “saída” ou aceitar dados que estão na forma de uma “entrada”.

No entanto, você pode estar confuso a respeito da palavra, o que isso significa? Um dado adiciona uma terceira dimensão aos pinos que podem ser atribuídos para estar continuamente em zero lógico (0V) ou alto lógico (5V), mas e os sinais que podem variar rapidamente, como a frequência de pulsos. Uma frequência seria acompanhada por lógicas de alta e baixa (5V e 0V) oscilando com alguns intervalos ou períodos especificados, portanto, torna-se orientada para o tempo e pode ser ajustada com relação ao tempo, por isso identificamos como 'dados' significando um parâmetro que indica uma função em relação a outra função (estados lógicos e tempo).

Um método de atribuir pin0 como saída é escrever o seguinte código:

DDRB = 0b00000001

No programa acima, DDRB significa Registrador de Direção de Dados para PORT B ​​0b instrui o compilador sobre a seguinte expressão binária de um número enquanto o “1” no final da expressão indica a posição do pin0, ou seja, sua localização no formulário do primeiro pino do PORT B.

Se você se lembra, aprendemos que a PORTA B associa 8 pinos a ela (de 0 a pino 7), e se você notar que o código acima também contém 8 dígitos, o que significa que cada dígito significa esses 8 pinos da PORTA B.

Agora, o próximo procedimento seria atribuir 5 V a este pino (pin0). Novamente, o princípio de operação é idêntico ao DDR, conforme expresso acima por meio do seguinte código binário:

PORTB = 0b00000001

Como pode ser visto, a única diferença entre o código acima e o anterior é que neste código utilizamos o registro PORT. Este registro lida especificamente com as atribuições de pinos daquela porta específica para a qual foi posicionada dentro do MCU. Assim, permite-nos atribuir as lógicas de dados reais (0 ou 1) para essas pinagens.

Agora podemos estar interessados ​​em discutir alguns detalhes aproximados de nosso programa. Como sabemos todos os programas requerem um determinado espaço para iniciar a execução, isso pode ser comparado a um chef que conhece todos os ingredientes de uma determinada receita, mas não é instruído por onde começar.

A função “principal” aqui é o local onde cada um dos programas C / C ++ inicia a execução. Portanto, o principal pode ser criado como:

int main (vazio)
{
}

No entanto, para permitir que o programa interprete os detalhes dos registros DDR e PORT e seu funcionamento dentro do chip MCU, uma declaração adicional precisa ser incluída, que pode consistir em todos os dados relativos ao MCU AVR. Talvez queiramos adicionar essa inclusão em todos os nossos programas.

#incluir
int main (vazio)
{
}

Assim que a compilação é iniciada, a seção de pré-processador do compilador concentra-se no diretório AVR para identificar o arquivo “io.h”. A extensão “.h” aqui indica que é um arquivo de cabeçalho, e que este código dentro do arquivo seria introduzido no início (cabeçalho) do arquivo de origem que está sendo criado, daí o nome “cabeçalho”.

Aqui em diante, podemos introduzir as instruções DDR e PORT em nosso código, porque a adição do arquivo de cabeçalho io.h teria direcionado o compilador a respeito delas.

#incluir

int main (vazio)

{

DDRB = 0b00000001 // Registro de direção de dados configurando pino0 para saída e os pinos restantes como entrada

PORTB = 0b00000001 // Definir pin0 para 5 volts

}

O acima corrige a orientação do pino 0 como a saída, tendo uma magnitude de 5V. No entanto, ainda há um problema que não foi determinado para este pino, que é que este pino ainda não foi instruído para ser LIGADO indefinidamente enquanto o MCU estiver ligado. Este loop de feedback infinito garantiria que este pino do MCU não se desligue, em vez disso, continue com a saída de 5 V indefinidamente.

Embora existam muitos métodos diferentes de aplicação de uma instrução de loop para um pino, tentaríamos empregar o loop “while” aqui. Como o nome sugere, o loop “while” diz ao microcontrolador que “enquanto” a energia estiver disponível, você precisa permanecer ativado com os 5 V atribuídos para a pinagem atribuída.

#incluir

int main (vazio)

{

DDRB = 0b00000001 // Registro de direção de dados configurando pino0 para saída e os pinos restantes como entrada

PORTB = 0b00000001 // Definir pin0 para 5 volts

enquanto (1)

{

// O código estaria aqui se precisasse ser executado indefinidamente ... indefinidamente

}

}

Você pode querer notar que, aqui, usamos '1' na forma de um argumento para o loop 'while', uma vez que tudo exceto '0' pode ser considerado um 'verdadeiro' lógico.

Isso implica que a consideração do loop “while” nunca seria responsável por nada, exceto por um “verdadeiro” lógico, o que significa que o pino específico travaria com o estado especificado indefinidamente.

O LED pode ser testemunhado para estar LIGADO no pino atribuído permanentemente, desde que o MCU receba energia através de seu Vdd e Vss.

É isso, agora temos o resultado que desejávamos obter e, finalmente, podemos ver isso acontecendo depois de tanto trabalho duro, mas, no entanto, ver o doce resultado do nosso trabalho duro é tão gratificante.

Nos próximos tutoriais, aprenderemos como adicionar uma dimensão de 'tempo' ao LED acima, ou seja, como fazê-lo piscar em uma determinada taxa especificada.

Na verdade, na implementação acima, o LED está piscando, mas a taxa de loop é tão rápida que é quase como um interruptor permanente LIGADO sobre a iluminação do LED.

Veremos como este loop pode ser adicionado com um atraso conforme desejado para fazer o LED piscar nessa taxa de atraso.

Como fazer um LED piscar usando o microcontrolador AVR

Na última discussão, aprendemos como ligar um LED através de um microcontrolador, foi excelente, não foi? Pode não ser muito!

Aqui, aprenderemos como incrementar a iluminação LED acima atribuindo uma funcionalidade bidirecional, ou seja, tentaremos fazê-la piscar ou piscar em alguma frequência ou taxa especificada. Também veremos como essa taxa pode ser aumentada ou diminuída conforme desejado pelo usuário.

Vamos dar uma olhada nisso:

#incluir

#incluir

int main (vazio)

{

DDRB | = 1<< PINB0

enquanto (1)

{

PORTB ^ = 1<< PINB0

_delay_ms (100)

}

}

Se você está se sentindo perplexo com os símbolos estranhos (&, ^, | etc) usados ​​na expressão acima (& não está lá, mas poderia ser usado em outros códigos semelhantes), aqui estão as informações relacionadas que você estaria interessado em saber sobre eles :

Inclui muitos algoritmos lógicos padrão como AND, OR, NOT e XOR que são normalmente usados ​​com o código acima.

Essa funcionalidade lógica compara especificamente os dois bits “1” e “0” de acordo com suas tabelas verdade atribuídas.

Teremos uma ideia analisando o seguinte arranjo de bits:

01001011 e
10001101
é igual a
00001001

No código acima, & refere-se a AND conforme usado na programação C.

Lendo as linhas verticalmente, sugere que 0 e 1 é igual a 0, 1 e 0 também é igual a 0, 0 e 0 é igual a 0, 1 e 1 é igual a 1. Ler é tão simples quanto isso. Eles são de acordo com a tabela verdade de um operador AND.

Se avaliarmos a tabela a seguir, ela indica o símbolo “|” denotando o uso da funcionalidade “OU”, o “|” pode ser encontrado apenas à esquerda de 'backspace' no teclado do computador:

01001011 |
10001101
é igual a
11001111

De forma idêntica, esta tabela verdade de uma funcionalidade lógica OR indica que os bits 0 ou 1 são iguais a 1, 1 ou 0 também são iguais a 1, 0 ou 0 são iguais a 0, enquanto 1 ou 1 é igual a 1.

A seguinte combinação de bits é para o operador lógico XOR denotado por ^ e pode ser estudada da mesma forma que fizemos com as tabelas de verdade AND, OR:

01001011 ^
10001101
é igual a
11000110

Agora vamos continuar com o primeiro programa e aprender o que significa a seguinte linha:

#incluir

Por meio de nossos tutoriais anteriores, sabemos como a expressão funciona, então não iremos reiterá-la, no entanto, parece ser uma nova 'inclusão' expressa por #include que precisa ser investigada.

Neste “include”, o delay.h nos permite alguns métodos fáceis de implementação.

Como o nome sugere, o delay.h nos permite induzir um atraso no programa específico.

A próxima expressão int main (void) pode ser omitida da discussão em andamento, uma vez que já cobrimos isso em nossos posts anteriores.

Em seguida, vem o DDRB alterado.

O seguinte mostra a forma anterior, que não é a melhor maneira de atribuir os pinos, uma vez que todos os pinos de 0 a 7 foram trocados para formar as entradas. Mas imagine qual seria a situação se quiséssemos criar um programa mais extenso que exigisse esses pinos para alguma outra funcionalidade? Por exemplo, o pino 2 pode ser necessário para aplicar uma comutação remota de um aparelho. Nesse caso, não gostaríamos de atribuir o mesmo como uma entrada apenas por tentativa e erro. Isso pode significar resposta incorreta do transmissor remoto para o receptor do aparelho.

DDRB = 0b00000001

Preferimos influenciar apenas um bit, hat pin0 bit, olhando para a funcionalidade “OR” que pode ser executada por meio de um mascaramento binário.

DDRB = DDRB | 0b00000001

Aqui está velado com uma máscara “OR”: 0b00000001, embora pareça ser um número binário autêntico, no caso do DDRB anterior, por exemplo: 0b01001010, então aplicar um OR a ele através do mascaramento poderia resultar em: 0b01001010 | 0b00000001 = 0b01001011.

A diferença resultante, como pode ser observada, é apenas com o pin0, cujos bits mudaram!

Comprimir a instrução acima ainda mais via C ++ dá:

DDRB | = 0b00000001

No entanto, descobrimos que há ainda mais no programa fornecido. Embora possa parecer bastante legítimo e óbvio, devemos aproveitar o benefício de algumas das declarações do arquivo de cabeçalho io.h, especialmente quando ele é criado fundamentalmente para nossa conveniência.

Portanto, 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.

Então, começamos com 0b00000000 e colocamos “1” para produzir 0b0000001 e então o transferimos para as posições 0 à esquerda, o que resulta em 0b00000001 exatamente idêntico ao anterior.

Agora, se supondo que fosse PINB4, a declaração poderia ser expressa como 1<< PINB4. I this case the “1” would be pushed to the left 4 locations producing: 0b00010000.

Cuidado, estamos empregando um índice zero, o que significa que há quatro zeros após o “1”.

Agora prosseguindo para o loop “while” que observamos no “loop infinito” anteriormente. Mas talvez agora queiramos que o microcontrolador implemente algumas das execuções desejadas. Isso só pode ser viável dentro do loop fornecido. É o loop onde a sequência particular é repetida várias vezes.

Caso a execução fosse colocada antes do loop, seria implementada apenas uma vez.

No entanto, para fazer o LED piscar indefinidamente, seria necessário ligar / desligar o PINB0 alternadamente dentro do loop. Aqui também encontramos os atrasos sendo introduzidos, sem os quais o piscar do LED seria impossível. Mas isso forçaria o LED a piscar em uma taxa muito rápida, difícil de reconhecer a olho nu, precisaria diminuir um pouco a velocidade para se tornar identificável com nossos olhos.

Estamos cientes do procedimento de configuração de um determinado bit no número binário, mas não temos certeza do método de aplicação de um bit específico '0' no caso de ser um '1' ainda.

O programa a seguir pode ser visto fazendo isso, mas também descobriremos que pode não estar visível no programa.

As duas declarações iniciais mudam o bit para “1” (5 V, LED acende) e, em seguida, uma pausa é introduzida por 100 ms.

O próximo par de linhas transforma o bit PINB0 em “0” (tensão zero, LED desligado), mas desculpe a comparação E não será capaz de executar um “0” do bit, mas se usarmos NÃO “~” para a máscara binária, ele pode mudar todos os 0s para 1s e vice-versa.

Isso nos permitirá influenciar apenas o bit PINB0 e colocá-lo em “0”. O parêntese foi incluído para conter a execução do mascaramento de forma que a operação NOT pudesse ser aplicada para todas as máscaras e não simplesmente sobre o “1” antes do deslocamento para a esquerda “<<”.

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

Para criar os atrasos ON OFF ou os períodos de igual duração, podemos encurtar as quatro linhas anteriores para duas e aplicar a funcionalidade XOR em nosso benefício. Deve-se observar que uma execução XOR de um pino atribuído a 1 no caso de ser 0 e vice-versa. Esta execução influenciaria apenas o PINB0. Como muitas vezes o comando é aplicado, ele simplesmente transformaria o bit no oposto da lógica existente.

PORTB ^ = 1<< PINB0
_delay_ms (100)

FEITO! Seu LED estaria piscando agora de acordo com a taxa definida ... Simples, não é?