Os microcontroladores fazem parte de qualquer equipamento eletrônico moderno, de rádios, telefones celulares, brinquedos, equipamentos industriais, médicos, de navegação, controle, etc. Conhecer e praticar com eles é muito útil para o desenvolvimento de sistemas eletrônicos. A plataforma Arduino nos permite de forma fácil, nos apresentarmos no mundo dos microcontroladores e suas aplicações. Neste artigo, veremos os códigos mais comuns no mundo dos microcontroladores e Arduino. Os botões e os LEDs são os componentes eletrônicos mais comuns em qualquer circuito e é importante saber como programá-los.
MIC026E
Arduino é uma plataforma de desenvolvimento que usa pequenos computadores (microcontroladores) para a criação de equipamentos eletrônicos. Sendo uma plataforma aberta (aberta), está se tornando popular e cresceu nos últimos anos. A Figura 1 mostra o quadro ou placa de desenvolvimento do Arduino Uno.
Neste artigo, vamos começar no mundo dos microcontroladores de forma fácil. Para escrever o código, é necessário ter instalado o IDE de desenvolvimento Arduino (veja a Figura 2), que pode ser baixado da página da web Arduino. Para começar, usaremos os programas de exemplo que o próprio IDE de desenvolvimento da Arduino tem nos arquivos de menu-> Exemplos. Veja a Figura 3.
Nas práticas a seguir, usaremos componentes eletrônicos, como LEDs e botões de pressão (veja a Figura 4). Esses componentes serão conectados aos pinos de entrada e saída do cartão de desenvolvimento. Na Figura 5, podemos ver a localização dos pinos de entrada e saída do cartão de desenvolvimento. No total, existem 14 pinos que estão numerados de '0' a '13'. Todos operam a 5 Volts. Cada pino pode fornecer ou receber um máximo de 40 miliampères e ter um resistor de pull-up interno (desconectado por padrão) de 20-50 kohms.
Para configurar se um pino é de saída ou entrada, usaremos a função pinMode, que recebe 2 parâmetros. O primeiro é o número do pino (de 0 a 13) eo segundo parâmetro se ele deve ser saída ou entrada. Se ele for lançado, no segundo parâmetro, escreveremos OUTPUT e se ele for inserido no segundo parâmetro, escreveremos INPUT. Para escrever um nível alto ou baixo em um pino configurado como saída, usaremos a função digitalWrite e leremos o valor de um pino, configurado como uma entrada, usaremos a função digitalRead.
LIGAR E DESLIGAR (ON / OFF) UM LED.
Vá para o Menu Arquivo-> Exemplos-> 01.Basics-> Blink. O código a seguir aparecerá no IDE:
// a função de configuração é executada uma vez que você pressiona a tecla de reinicialização ou liga a placa void setup() { // inicializa o pino digital LED_BUILTIN como saída. pinMode(LED_BUILTIN, OUTPUT); } // a função de loop funciona uma e outra vez para sempre void loop() { digitalWrite(LED_BUILTIN, HIGH); // liga o LED (ALTO é o nível de tensão) delay(1000); // aguarde um segundo digitalWrite(LED_BUILTIN, LOW); // desligue o LED fazendo a tensão BAIXO delay(1000); // aguarde um segundo
}
Neste exemplo, ligamos e desligamos um LED. A placa Arduino Uno possui um LED (incorporado) conectado ao pino digital 13 que, por padrão, é chamado de LED_BUILTIN. Se você quiser conectar LEDs a outros pinos, você pode seguir o diagrama elétrico da Figura 6. Você deve declarar uma constante como:
conts int LED_APP 12
para o caso de o LED estar conectado ao pino 12. Eu mudei este número de acordo com o pino onde o LED na placa Arduino Uno está conectado.
Todos os caracteres encontrados após '//' são comentários e servem para indicar e lembrar-nos que eles fazem certas seções ou partes de código. No código anterior, existem duas funções:
setup ()
loop ()
A função setup() é onde o microcontrolador está configurado e só é executado uma vez, quando a placa é alimentada por uma fonte de tensão ou quando executamos uma reinicialização. Esta função é muito semelhante ao BIOS (Basic Input Output Setup) de computadores pessoais. Nesta função, nós programamos as entradas e saídas do microcontrolador.
A função loop(), como o nome indica, é um loop que se repete indefinidamente e é onde o programa principal está escrito. A Figura 7 mostra o diagrama de fluxo para as funções de setup() e loop(). Podemos ver que a função setup() é executada no início e a função de loop se repete indefinidamente.
A função de configuração é:
void setup () {
pinMode (LED_BUILTIN, OUTPUT);
}
Dentro da função setup (), a função pinMode é chamada (LED_BUILTIN, OUTPUT); Esta função informa o microcontrolador de que o LED será configurado como saída.
Void loop () {
digitalWrite (LED_BUILTIN, HIGH);
delay (1000);
digitalWrite (LED_BUILTIN, LOW);
delay (1000);
}
Dentro da função loop(), é chamada de função digitalWrite(LED_BUILTIN, HIGH); Esta função escreve um "1" lógico ou um nível alto no pino LED. Na eletrônica digital, os níveis elevados são representados por uma tensão de 5V. A função loop() também chama a função de delay(1000); que atrasa a operação do microcontrolador pela quantidade de milissegundos especificada nos parênteses da função.
Para o caso do exemplo anterior, estamos atrasando o microcontrolador em 1000 milissegundos ou 1 segundo. Em seguida, usamos a função digitalWrite(LED_BUILTIN, LOW); que coloca um "0" lógico ou nível sob o pino LED. Na eletrônica digital, um nível baixo é representado por 0 volts ou terra (GROUND). Então, temos um atraso de 1 segundo.
Assim, o programa se repete continuamente e podemos observar como o LED liga e desliga continuamente. Se os valores dos parâmetros da função delay() forem alterados; Você pode ver a mudança de cintilação no LED. Este programa, embora básico, é importante compreendê-lo bem, porque todos os programas seguem a mesma regra, por mais complexos que sejam. A Figura 8 mostra o fluxograma do exemplo anterior.
CONECTANDO UM BOTÃO PUSH (PUSHBUTTON) PARA O MICROCONTROLADOR.
Nesta prática, conectaremos um botão a um pino do microcontrolador configurado como uma entrada digital. O código de exemplo pode ser encontrado no IDE, no Menu: Arquivo-> Exemplo-> 02.Digital-> Botão.
// constants won't change. They're used here to set pin numbers: const int buttonPin = 2; // the number of the pushbutton pin const int ledPin = 13; // the number of the LED pin // variables will change: int buttonState = 0; // variable for reading the pushbutton status void setup() { // initialize the LED pin as an output: pinMode(ledPin, OUTPUT); // initialize the pushbutton pin as an input: pinMode(buttonPin, INPUT); } void loop() { // read the state of the pushbutton value: buttonState = digitalRead(buttonPin); // check if the pushbutton is pressed. If it is, the buttonState is HIGH: if (buttonState == HIGH) { // turn LED on: digitalWrite(ledPin, HIGH); } else { // turn LED off: digitalWrite(ledPin, LOW); } }
No início do programa, definimos 2 constantes inteiras, isto é, dizer que esses valores não serão alterados durante a execução do programa. Para isso, a palavra const é usada, conforme mostrado nas seguintes linhas de código:
const int buttonPin = 2;
const int ledPin = 13;
Na função setup(), configuramos o pino 13 como saída digital e pino 2 como entrada digital, conforme visto no código:
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT);
}
A função pinMode(ledPin, OUTPUT); informa ao microcontrolador que o pino ledPin (13) será configurado como uma saída (OUTPUT) e a função pinMode (buttonPin, INPUT); diz ao microcontrolador que o pino buttonPin(pino 2) será configurado como uma entrada digital (INPUT). O hardware para este exemplo é mostrado na Figura 9, onde podemos ver que o botão passa no pino 2. É necessário conectar um resistor de 10 kOhms a 5 volts (pull-up), para polarizar a entrada para positivo, quando o O botão não está pressionado.
Também declaramos um botão de valor variável, o que significa que seu valor ou conteúdo será modificado pelo programa. A seguinte linha de código mostra e declara a variável para o compilador:
int buttonState = 0;
O código para a função loop() neste exemplo é:
void loop() {
buttonState = digitalRead (buttonPin);
se (buttonState == HIGH) {
digitalWrite (ledPin, HIGH);
} else {
digitalWrite (ledPin, LOW);
}
}
Na função loop(), usamos a função digitalRead(buttonPin); para ler o botão do botão de entrada digitalPin e armazenar esse valor na variável buttonState. Então, o código verifica se esse valor é alto (ALTO) para o qual usamos a instrução if (buttonState == HIGH). Se o valor for alto, executaremos a função digitalWrite(ledPin, HIGH); ou o botão buttonState é baixo, a função digitalWrite será executada (ledPin, LOW); Assim, ao ler uma entrada digital, podemos controlar as saídas (atuadores) ou executar algum outro código. A Figura 10 mostra o fluxograma para ler o botão.
** PWM PARA AUMENTAR E BAIXAR A INTENSIDADE LUMINOSA DE UM LED.
Os pinos 3, 5, 6, 9, 10 e 11 da placa Arduino Uno podem ser usados como saídas analógicas PWM. No total, existem 6 pinos com PWM na placa Arduino Uno. A Figura 11 mostra esses pinos. Observe que, no painel, essas saídas são marcadas com o símbolo ~ antes do número, indicando as saídas PWM. O microcontrolador ATmega328P utilizado na placa Arduino possui 3 temporizadores. Cada temporizador possui 2 módulos de comparação de saída que normalmente são usados para gerar sinais PWM. Na Figura 12 podemos ver o Temporizador 0 do microcontrolador.
O código de exemplo para esta prática pode ser encontrado em Arquivo-> Exemplos-> 01.Basics-> Fade. A principal idéia é aumentar e diminuir a intensidade luminosa do LED usando o PWM (Modulador de largura de pulso). O código neste exemplo é:
int led = 9; // the PWM pin the LED is attached to int brightness = 0; // how bright the LED is int fadeAmount = 5; // how many points to fade the LED by // the setup routine runs once when you press reset: void setup() { // declare pin 9 to be an output: pinMode(led, OUTPUT); } // the loop routine runs over and over again forever: void loop() { // set the brightness of pin 9: analogWrite(led, brightness); // change the brightness for next time through the loop: brightness = brightness + fadeAmount; // reverse the direction of the fading at the ends of the fade: if(brightness <= 0 || brightness >= 255) { fadeAmount = -fadeAmount; } // wait for 30 milliseconds to see the dimming effect delay(30); }
PWM é uma técnica de modulação de largura de pulso que pode ser usada para controlar a corrente que flui através de um circuito muito similar aos potenciômetros em um dimmer. Para fazer isso, podemos usar a função analogWrite que recebe 2 parâmetros. O primeiro parâmetro é o pino a ser controlado eo segundo parâmetro é a quantidade de tempo que o pino permanecerá no nível alto (ON). A Figura 13 mostra como o segundo parâmetro atua no pino que está controlando. À medida que os pulsos são repetidos rapidamente (aproximadamente 500 Hz), o olho humano não percebe sua mudança, mas à medida que a largura do pulso varia, dá a sensação óptica de aumentar e diminuir a intensidade do LED. O hardware necessário para esta prática pode ser visto na Figura 14. Observe que o LED está conectado ao pino 9.
No início do programa, declaramos 3 variáveis da seguinte forma:
int led = 9;
int brightness = 0;
int fadeAmount = 5;
A variável led é o pino em que vamos conectar o LED. A variável de brilho armazena o valor do brilho do LED e a variável fadeAmount é usada para alterar o brilho.
Na função setup(), configuramos o pino LED como uma saída para a qual temos o seguinte código:
void setup() {
pinMode(led, OUTPUT);
}
No loop de função () usamos a função analogWrite(led, brilho); para colocar um valor de largura de pulso na saída PWM. Em seguida, adicionamos um fadeAmount ao brilho variável para aumentar seu valor em forma escalar. Então, detectamos se o brilho variável é maior ou igual a 255 e inverte a variável fadeAmount para reverter o efeito do brilho. Finalmente, damos um desafio de 30 milissegundos. Na Figura 15, podemos ver o fluxograma dessa prática. O código para a função loop () é o seguinte:
void loop() { analogWrite(led, brightness); brightness = brightness + fadeAmount; if (brightness <= 0 || brightness >= 255) { fadeAmount = -fadeAmount; } delay(30); }
Assim, por meio de linhas de código, podemos interagir com o mundo exterior, ou seja, podemos ler sinais (entradas, sensores) e podemos avaliar esses valores para tomar decisões sobre saídas, normalmente chamadas de atuadores. A imaginação é o indicador de que você pode usar esses recursos para criar projetos e equipamentos eletrônicos.
