Aprendendo programação básica do Arduino - Tutorial para iniciantes

Experimente Nosso Instrumento Para Eliminar Problemas





Neste tutorial, aprendemos como fazer programação básica em Arduino por meio de códigos de exemplo e programas de amostra. Este tutorial pode ser um curso extremamente valioso para todos os novatos que desejam compreender o básico por meio de uma linguagem fácil e compreensível.

Introdução

De acordo com wikipedia um microcontrolador é equivalente a um minicomputador construído dentro de um único chip IC, tendo seu próprio processador central, entradas programáveis, memória e periféricos de saída.



Um microcontrolador torna-se muito útil para um usuário, pois oferece um processador embutido, memória e portas de entrada / saída (também chamadas de GPIO ou pinos de entrada / saída de propósito geral) que podem ser controlados pelo usuário de acordo com as especificações desejadas.

Neste tutorial, trabalharemos com uma placa Arduino Uno para aprender e testar os programas. Para testar e integrar a montagem de hardware, usaremos uma placa de ensaio.



Agora vamos avançar rapidamente e aprender como começar a programar em Arduino.

1.2 Instalando o Software (Windows)

Para isso, você precisará de acesso à internet, o que obviamente você teria em seu computador. Acesse o seguinte link e baixe o software IDE:

Arquivo ZIP do Windows para instalação não administrativa

Após o download, você encontrará o ícone de configuração do Arduino na pasta de download, que se parecerá com este:

ícone de download do arduino

Depois de obter isso, você pode simplesmente clicar duas vezes nele e instalar o Arduino o Ambiente de Desenvolvimento Integrado (IDE) em seu computador. O processo completo pode ser visualizado no seguinte vídeo:

https://youtu.be/x7AMn1paCeU

1.4 Começando com nosso primeiro circuito

Antes de começarmos a aprender as técnicas de programação reais, para qualquer novato, seria útil começar com um componente básico, como um LED, e entender como conectá-lo a um Arduino.

Como sabemos, um LED é um diodo emissor de luz que tem uma polaridade e não acende se não estiver conectado aos pólos de alimentação corretos.

Outro aspecto com LEDs é que esses dispositivos funcionam com baixa corrente e podem ser danificados instantaneamente se um resistor calculado apropriadamente não for incluído em série com um de seus pinos.

Como regra geral, 330 ohm 1/4 watt é bastante ideal para cada aumento de 5 V na entrada de alimentação para limitar a corrente a um nível de segurança exigido. Portanto, para 5V pode ser 330 ohms, para 10V pode ser 680 ohms e assim por diante.

Usando a placa de ensaio para a montagem

Certifique-se de saber como usar um tábua de pão antes de tentar o tutorial explicado neste capítulo, visto que usaríamos uma placa de ensaio para todos os experimentos aqui.

A configuração básica da conexão do LED pode ser testemunhada abaixo:

LED com Arduino

Você pode ver 3 componentes básicos acima:

  1. Um LED de 5 mm, 20 mA
  2. um resistor de 330 ohm 1/4 watt
  3. A Placa Arduino

Basta montar o sistema conforme o diagrama.

Em seguida, conecte o 5V do USB do computador ao Arduino. Assim que fizer isso, o LED acenderá.

Eu sei que isso é muito básico, mas é sempre bom começar do zero. Tenha certeza de que as coisas começarão a ficar cada vez mais interessantes à medida que avançarmos.

1.5 LED de controle com Arduino

Agora aprenderemos como controlar um LED com um programa Arduino.

Para escrever um programa, devemos ter pelo menos 2 funções em cada programa.

Uma função pode ser entendida como uma série de instruções de programação que podem ser atribuídas com um nome, conforme fornecido a seguir:

  1. configurar() isso é chamado ou executado durante o início do programa.
  2. ciclo() isso é chamado ou executado repetidamente durante todo o período operacional do Arduino.

Portanto, embora possa não ter nenhuma funcionalidade prática, tecnicamente, um programa Arduino legítimo mais curto pode ser escrito como:

Programa Mais Simples

void setup()
{
}
void loop()
{
}

Você deve ter notado que em muitas das linguagens de programação, o sistema começa mostrando uma impressão simples, 'Alô, Mundo' na tela de exibição

O equivalente eletrônico para esta frase na interpretação do microcontrolador é acender e apagar um LED.

Este é o programa mais básico que se pode escrever e implementar para indicar o correto funcionamento do sistema.

Tentaremos implementar e compreender o procedimento por meio do seguinte trecho de código:

Listagem 1.2: led1 / led1.pde

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

OK, agora vamos entender o que cada linha do código significa e como funciona para executar a função:

const int kPinLed = 13

Isso funciona como uma constante que nos permite usá-la durante todo o curso de programação, sem a necessidade de usar o valor real que é definido contra ela.

De acordo com as regras padrão, tais constantes são reconhecidas com a letra inicial para . Embora não seja obrigatório, torna as coisas mais claras e facilmente compreensíveis sempre que você sentir vontade de passar pelos detalhes do código.

void setup()
{
pinMode(kPinLed, OUTPUT)
}

Este código configura o pino específico ao qual nosso LED está conectado. Em outras palavras, o código diz ao Arduino para controlar o aspecto de 'escrita' neste pino, em vez de 'lê-lo'.

void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

As linhas acima indicam a execução real do aplicativo. O código começa escrevendo e renderizando um HIGH na conexão de LED relevante, ligando o LED.

Aqui, o termo ALTO significa simplesmente obter + 5 V no pino em questão do Arduino. O termo complementar BAIXO simplesmente indica um zero ou 0 V no pino designado.

Em seguida, chamamos delay() cuja função é criar um atraso de milissegundos (1/1000 de segundo). Uma vez que a figura 500 é inserida, o atraso implementado será de 1/2 segundo.

Assim que este 1/2 segundo é decorrido, a próxima linha é executada, desligando o LED com o termo BAIXO no mesmo pino.

A linha subsequente gera novamente o retardo de 1/2 segundo, para permitir que o LED permaneça DESLIGADO por 1/2 segundos.

E o processo continua infinitamente pela execução das linhas de código, enquanto o Arduino é mantido ligado.

Antes de prosseguir para o próximo nível, eu recomendo que você programe o código acima e verifique se você é capaz de implementar a sequência LED ON / OF corretamente ou não.

Uma vez que o LED padrão no Arduino está conectado ao pino # 13, ele deve responder imediatamente ao programa acima e começar a piscar. No entanto, se você descobrir que seu LED externo não está piscando, pode haver uma falha de conexão com seu LED, você pode tentar inverter a polaridade de seu LED e esperançosamente vê-lo piscando também.

Você pode brincar com o tempo de atraso alterando o número '500' para algum outro valor e encontrar o LED 'ouvindo' os comandos e fazendo com que pisque de acordo com os valores de atraso especificados.

Mas lembre-se, se você ver o LED não piscando com uma taxa constante de 1 segundo, independente da alteração do tempo de retardo, isso pode indicar que o código não está funcionando devido a algum erro. Porque, por padrão, o Arduino será programado com uma taxa de flash de 1 segundo. Portanto, esta taxa deve ser alterada por seu código para confirmar seu funcionamento correto.

1.7 comentários

As linhas de códigos que entendemos acima foram escritas especificamente para o software de computador.

No entanto, para garantir que o usuário seja capaz de referir o significado das linhas e compreendê-las, muitas vezes pode ser útil e sensato escrever a explicação ao lado das linhas de códigos desejadas.

Estes são chamados comentários que são escritos apenas para referência humana ou do usuário e são codificados para permitir que os computadores os ignorem com segurança.

A linguagem desses comentários é escrita em alguns formatos:

  1. O estilo de bloco de comentário, em que a descrição do comentário é colocada sob o símbolo inicial / * e símbolo final * /
  2. Isso não precisa se restringir a uma linha, mas pode ser estendido para as próximas linhas subsequentes, dependendo do comprimento do comentário ou da descrição, conforme mostrado no exemplo a seguir:

/ * Este é um comentário * /

/ * Então é isso * /

/* E
* esta
* como
* Nós vamos */

Para escrever uma descrição rápida de linha única para um comentário, o símbolo de duas barras // no início torna-se suficiente. Isso informa ao computador que essa linha não tem nada a ver com o código real e deve ser ignorada. Por exemplo:

// Este é um comentário que os computadores irão ignorar.

Aqui está um exemplo para referência:

/*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/

/* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

1.8 Solução de problemas

Se você encontrar seu programa mostrando um 'erro' durante a compilação, ou algum outro problema, as dicas a seguir provavelmente o ajudarão a verificar novamente seu código para se livrar do obstáculo.

  1. A linguagem do seu programa diferencia maiúsculas de minúsculas. Por exemplo, a expressão myVar não pode ser escrito como MyVar.
  2. Todos os tipos de espaços em branco que podem ser executados por sua digitação no teclado são, em última análise, processados ​​como um único espaço e são visíveis ou compreendidos apenas por você, o computador não levará isso em consideração. Simplificando, espaços livres de qualquer tipo não terão qualquer efeito nos resultados do código.
  3. Cada bloco de código deve ser colocado entre chaves à esquerda e à direita, '{' e '}'
  4. Os dígitos numéricos não devem ser separados por vírgulas. Por exemplo, 1000 não pode ser escrito como 1.000.
  5. Cada linha de código entre as chaves deve terminar com um ponto e vírgula

Criando sequência de luz LED interessante com Arduino

Em nosso capítulo anterior, aprendemos como ligar / desligar um LED continuamente com uma taxa de atraso constante.

Agora aprenderemos como diferentes padrões de atraso podem ser executados no mesmo LED, atualizando o código do programa.

Não usaremos um LED externo, em vez disso, usaremos o LED padrão embutido na placa Arduino no pino # 13. Você pode encontrar esse minúsculo LED SMD logo atrás do conector USB.

2.2 Compreendendo as declarações de IF

Nesta seção, aprenderemos como as estruturas de controle nos permitem executar códigos individuais e, às vezes, até repetidamente, conforme necessário.

A declaração E se torna-se a 1ª estrutura de controle. A implementação a seguir mostra como ele é usado:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Tentaremos entender o código acima em etapas e aprender como isso pode ser usado para outras execuções semelhantes.

Os códigos entre a 1ª e a 7ª linha são exatamente semelhantes ao nosso programa inicial.

A primeira modificação realmente ocorre na 8ª linha.

int delayTime = 1000

Você pode achar que é semelhante ao código na primeira linha, exceto pelo fato de que está faltando o termo const.

Isso ocorre simplesmente porque esse código não é uma constante. Em vez disso, isso é definido como um variável , que possui a propriedade de um valor variável no decorrer da programação.

No exemplo acima, você pode ver que esta variável é atribuída com um valor de 1000. Lembre-se, tais variáveis ​​que estão entre chaves devem ser escritas estritamente dentro de pares de chaves apenas e são referidas como variáveis ​​'locais'.

Alternativamente, variáveis ​​que deveriam estar fora das chaves, como a que estamos discutindo agora, são reconhecidas como 'globais' e podem ser executadas em qualquer lugar dentro de um código de programa.

Seguindo em frente, você pode ver que os códigos entre as linhas 9 e 11 também são semelhantes aos do primeiro programa, mas as coisas começam a ficar interessantes depois da linha 11. Vamos ver como!

delayTime = delayTime - 100

Neste código, vemos que o valor padrão do tempo de atraso está sendo modificado subtraindo 100 dele.

O que significa que 100 é deduzido de seu valor inicial de 1000, fornecendo um novo valor de 900.

Por meio da imagem a seguir, tentaremos compreender alguns dos operadores matemáticos usados ​​na linguagem Arduino.

Símbolos do operador Arduino Math

Agora vamos avaliar os códigos entre as linhas 13 e 15.

if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}

O principal objetivo do trecho de código acima é garantir que o LED continue piscando sem nenhuma interrupção.

Devido ao fato de que 100 está sendo deduzido do original tempo de atraso , evita que o piscar do LED chegue a zero e permite que o piscar continue continuamente.

A imagem a seguir mostra alguns operadores de comparação que usaríamos em nossos códigos:

operador de comparação para códigos arduino

Em nosso código acima, poderíamos ter testado o código para ser if(delayTime == 0).

No entanto, como ser uma figura negativa pode ser igualmente ruim, não optamos por isso, e essa é uma prática recomendada.

Pense em qual poderia ter sido o resultado se tivéssemos tentado deduzir 300 em vez de 100 de delayTime?

Portanto, agora você deve ter percebido que se o delayTime for escrito como menor ou igual a zero, então o tempo de atraso seria definido de volta para a figura 1000 original.

digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)

As últimas 4 linhas do código conforme mostrado acima tornam-se responsáveis ​​por ligar / desligar o LED, ligar / desligar continuamente.

Aqui você pode notar claramente que em vez de usar um número de algarismos, usamos uma variável para atribuir o tempo de atraso para que possamos ajustá-lo como quisermos durante o período operacional do código. Isso é legal, certo?

2.3 Declarações ELSE

Aqui aprenderemos por que e como um E se termo pode ter uma cláusula outro para que decida a situação no caso E se declaração é falsa.

Lamento se isso parece muito confuso, não se preocupe, vamos tentar entender com o seguinte exemplo:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Acima você pode ver que na décima linha o código só é executado quando o delayTime é menor ou igual a 100, caso contrário, o código na 13ª linha é executado, mas os dois juntos nunca podem acontecer, o código da 10ª linha ou da 13ª linha será implementado, nunca os dois.

Você deve ter notado que, ao contrário do que fizemos na seção 2.2 anterior, aqui não comparamos com 0, e sim com 100. Isso ocorre porque, neste exemplo, comparamos ANTES de subtrairmos 100, ao contrário na seção 2.2, comparamos APÓS nós subtraído. Você pode dizer o que poderia ter acontecido se tivéssemos comparado 0 em vez de 100?

2.4 Instruções WHILE

PARA enquanto declaração é bastante semelhante a E se declaração, exceto o fato de que causa a execução repetida de um bloco de código (que pode estar entre chaves) por enquanto as condições são aplicáveis, e isso funciona sem um outro demonstração.

O exemplo a seguir ajudará você a entender isso melhor

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
}

Você consegue adivinhar o que o código acima está programado para fazer? Bem, ele foi projetado para piscar o LED mais rápido e mais devagar.

2.5 O que é verdadeiro e falso?

Em linguagem de programação, falso refere-se a zero (0). Na verdade, 'verdadeiro' não é usado; em vez disso, presume-se que, quando nada é falso, tudo o que está incluído é verdadeiro.

Parece um pouco estranho, mas faz o trabalho muito bem.

Tentaremos entender a situação por meio do exemplo a seguir.

Às vezes, você pode encontrar um código conforme abaixo:

while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}

Isso é codificado e parece que a execução do LED continuará girando para sempre, enquanto a energia estiver disponível.

No entanto, uma desvantagem desse tipo de código pode surgir quando acidentalmente o usuário aplica um = em vez de ==.

Tenho certeza de que você já sabe que = significa uma atribuição, o que significa que é usado para designar um valor selecionado para uma variável, enquanto a == é usado para forçar um teste se o valor for o mesmo.

Por exemplo, suponha que você precise que um LED pisque em um padrão de velocidade sequencial e repetitiva, mas usou incorretamente um = em vez de ==.

O código aparecerá assim:

int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}

O erro atribuirá 0 a delayTime e levará ao E se declaração para verificar se 0 era verdadeiro ou não. Visto que 0 se refere a falso, ele pensará que não é verdadeiro e interromperá a aplicação de delayTime = 1000, mas em vez da função delayTime é mantido em 0 durante o curso do loop ().

Isso parece muito indesejável !!

Portanto, sempre verifique seu programa para ter certeza de que não cometeu esses erros bobos.

2.6 Combinações

Às vezes, você pode sentir a necessidade de testar várias coisas juntos. Por exemplo, você pode querer examinar se uma variável estava entre dois números. Embora isso possa ser implementado usando a instrução if várias vezes, pode ser mais conveniente usar combinações lógicas para uma leitura melhor e mais fácil.

A implementação de combinações em termos lógicos pode ser feita com 3 métodos, conforme mostrado na tabela a seguir:

tabela mostrando os métodos de combinação do Arduino

Seria interessante saber que o operador NOT pode funcionar como um switcher para uma variável que pode ser designada para ser verdade ou falso (ou BAIXO ou ALTO).

O exemplo a seguir ilustra a condição:

int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}

Aqui, o ledState será BAIXO e, subsequentemente, assim que ledState = !ledState, ficará ALTO. O seguinte loop causará ledState para ser ALTO quando ledState = !ledState é baixo.

2.7 instruções FOR

Agora vamos tentar entender sobre outra estrutura de controle que é um pra ciclo. Isso pode ser muito útil quando você deseja implementar algo várias vezes.

Vamos entender isso com o seguinte exemplo:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}

Você pode encontrar algo único na linha com pra.

É o código i ++? . Isso é útil para programadores que são preguiçosos e desejam implementar a codificação por meio de atalhos convenientes

O termo acima é conhecido como operadores compostos, pois eles fazem o trabalho de combinar um operador de atribuição com outro operador de atribuição. O mais popular deles pode ser visualizado na seguinte tabela:

operadores compostos arduino

Você descobrirá que existem 3 sub-afirmações em uma instrução for. Está estruturado conforme mostrado abaixo:

for (statement1conditionstatement2){
// statements
}

A afirmação nº 1 ocorre logo no início e apenas uma vez. A condição é testada a cada vez durante o curso do loop. Sempre que for verdade dentro das chaves, a instrução subsequente nº 2 é aplicada. No caso de um falso, o sistema pula para o próximo bloco de código.

Conectando mais LEDs

OK, agora veremos como podemos conectar mais número de LEds para obter efeitos mais interessantes.

Conecte os LEDs e o Arduino conforme mostrado abaixo. Na verdade, o fio vermelho não é necessário, mas como é sempre uma boa ideia ter os dois trilhos de alimentação incluídos na placa de ensaio, a configuração faz sentido.

Arduino múltiplas conexões de LED

Agora vamos consertar um programa que nos permitirá verificar se nosso hardware está configurado corretamente ou não.

É sempre recomendado codificar e executar pequenos trechos de programas passo a passo para verificar se os respectivos hardwares estão conectados corretamente ou não.

Isso ajuda a solucionar um possível erro rapidamente.

O exemplo de código abaixo fornece aos LEDs 2 a 5 um padrão específico, girando-os um após o outro de maneira cíclica.

const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}

Como você pode notar, não há nada de errado com o código, exceto o fato de que parece longo e, portanto, sujeito a erros.

Claro que existem maneiras melhores de escrever o código acima, a seção a seguir irá revelá-lo.

2.9 Apresentando Arrays

Arrays podem ser um grupo de variáveis ​​que podem ser indexadas com números de índice. O exemplo a seguir nos ajudará a entendê-lo melhor.

const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}
void loop()
{
for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}

OK, agora vamos examinar cada seção e entender como eles realmente funcionam.

const int k_numLEDs = 4

O código acima define quantos elementos máximos devemos ter no array. Este código nos ajuda nas seções subsequentes para garantir que tudo seja escrito dentro de um array e nada depois que o array terminar.

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

Na próxima linha, configuramos a estrutura do array. Os números dentro do colchete indicam o número de elementos na matriz. Embora a quantidade real pudesse ter sido escrita, escrever como constantes funciona melhor. Os valores normalmente podem ser vistos dentro do colchete com vírgulas e designam os valores para a matriz.

Quando você encontra uma matriz indexada com o número 0, isso indica o primeiro elemento na matriz, conforme mostrado em code: k_LEDPins is k_LEDPins[0].

Da mesma forma, o último elemento será mostrado como k_LEDPins[3], pois a contagem de 0 a 3 é 4.

void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}

O código acima mostra o uso de loop para proceder através de cada elemento do array e para defini-los como OUTPUTS. Implementamos colchetes junto com o índice para alcançar cada um dos elementos na matriz.

se você está se perguntando se é possível usar o pino 2 ao pino 5 sem matrizes, a resposta é sim, é possível. Mas, neste exemplo, não é feito porque não o fizemos dessa forma. Nas seções a seguir, você pode eliminar a abordagem de array se os pinos de saída selecionados não estiverem alinhados.

Seguindo em frente, vamos ver o que o próximo bloco de código faz:

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}

Aqui, o código passa por cada um dos LEDs para ligá-los sequencialmente com uma lacuna ou atraso de 100 milissegundos.

for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}

Usar o código acima mostra como a aplicação de para loop pode ser usado para percorrer o loop, mesmo na ordem inversa.

Ele começa em k_numLEDs - 1 porque os arrays são indexados por zero. Não partimos de k_LEDPins[4] porque isso resultaria no cruzamento do final da matriz.

O código usa> = 0 para verificar se o primeiro elemento no índice 0 não foi perdido ou ignorado.

Capítulo 3

O que é uma entrada

Então, aprendemos como operar as coisas usando o Arduino. Neste capítulo, discutiremos como sentir o mundo real fazendo a interface de entradas de parâmetros externos.

3.1 Usando botões de pressão

Todos nós sabemos o que é um botão de pressão e como funciona. É um tipo de interruptor ou botão que conecta um sinal de um estágio do circuito a outro momentaneamente enquanto ele está na condição pressionada e interrompe o sinal quando liberado.

3.1.1 Um botão e um LED

botão de interface com Arduino

Conectaremos o Arduino com um botão de ação com o Arduino conforme os detalhes mostrados acima e aprenderemos o funcionamento básico e a implementação da configuração.

O botão de pressão indicado, também denominado botão de micro interruptor, tem 4 pinos no total (2 pares de cada lado). Quando pressionado, cada par de pinos é unido internamente e permite uma conexão ou condução através deles.

Neste exemplo, estamos usando apenas um par desses pinos ou contatos, o outro par é irrelevante e, portanto, é ignorado.

Vamos prosseguir aplicando o seguinte código e verificando se está funcionando!

const int kPinButton1 = 2
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Você pode encontrar algumas coisas que parecem incomuns aqui. Vamos descobri-los passo a passo.

void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}

A primeira coisa que fazemos é consertar o buttonPin Enquanto o ENTRADA. Bem, isso é bastante básico, eu sei.

Em seguida, atribuímos ALTO ao ENTRADA alfinete. Você uma maravilha, como pode ser possível escrever qualquer coisa na entrada? Claro, isso pode ser interessante.

Na verdade, atribuir um HIGH a uma entrada do Arduino ativa um resistor pull-up interno de 20k Ohm (um LOW neste pino o desativa).

Outra pergunta que você pode fazer é o que é um resistor pull-up. Eu cobri uma postagem abrangente sobre resistores pull-up que você aprenda aqui .

OK, continuando, agora vamos dar uma olhada no código do loop principal:

void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Quando você pressiona o botão, o pino com fio é conectado ao aterramento, o que torna um BAIXO a esse alfinete. E enquanto na condição não pressionada, o mesmo pino é mantido em ALTO ou + 5V através do resistor pull-up interno de 20K.

Aqui queremos que o Arduino acenda o LED quando o botão for pressionado (LOW), portanto, escrevemos HIGH para a saída para cada resposta de um LOW do botão, enquanto ele é pressionado.

3.1.2 Dois botões e um LED

Bem, você pode estar se perguntando que a ação mostrada acima também poderia ter sido realizada sem um Arduino. Eu entendo, no entanto, esta é uma pedra angular para aprender como o botão de pressão pode ser usado com Arduno.

Até este ponto, estudamos códigos de escrita para ligar (ALTO) ou desligar (BAIXO) um LED.

Agora vamos ver como o brilho do LED pode ser controlado com um Arduino.

Isso pode ser feito usando dois métodos:

  1. Ao restringir a quantidade de corrente ao LED
  2. Usando PWM ou modulação por largura de pulso, em que a alimentação do LED é LIGADA / DESLIGADA em alguma taxa desejada muito rapidamente, produzindo uma iluminação média cuja intensidade dependeria do PWM.

Em uma placa Arduino, o suporte PWM está disponível nos pinos marcados com um til (~), que são os pinos 3, 4,5,9,10 e 11) a 500 Hz (500 vezes por segundo). O usuário é capaz de fornecer qualquer valor entre 0 e 255, onde 0 se refere a nenhum HIGH ou nenhum + 5V, e 255 diz ao Arduino para obter um HIGH ou + 5V o tempo todo. Para iniciar estes comandos você terá que acessar o analogWrite () com o valor desejado.

Você pode assumir que PWM é x / 255, onde x é o valor desejado que você deseja enviar via analogWrite().

Controle Arduino PWM

Configure o Arduino e outros parâmetros conforme mostrado acima.

const int kPinButton1 = 2
const int kPinButton2 = 3
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
pinMode(kPinButton2, INPUT)
pinMode(kPinLed, OUTPUT)
digitalWrite(kPinButton1, HIGH) // turn on pullup resistor
digitalWrite(kPinButton2, HIGH) // turn on pullup resistor
}
int ledBrightness = 128
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness--
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++
}
ledBrightness = constrain(ledBrightness, 0, 255)
analogWrite(kPinLed, ledBrightness)
delay(20)
}

Você pode encontrar 3 linhas aqui que precisam de alguma explicação.

ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)

A linha: ledBrightness = constrain(ledBrightness, 0, 255) ilustra uma função única dentro do Arduino conhecida como constrain ().

Esta função interna compreende um código semelhante ao seguinte:

restrição interna (valor interno, mínimo interno, máximo interno)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Todos os códigos discutidos antes deste começaram com vazio , o que significava não devolver nada (vazio). Considerando que o código acima começa com int , que indica que ele retorna um número inteiro. Discutiremos mais sobre nas seções posteriores; no momento, apenas lembre-se de que um inteiro não possui nenhuma parte fracionária.

Certo, isso implica, o código: ledBrightness = constrain(ledBrightness, 0, 255) atribui o ledBrightness to be within the range of 0 and 255.

A próxima linha emprega analogWrite para comandar o Arduino para aplicar PWM no pino selecionado com o valor desejado.

A próxima linha cria um atraso de 20 milissegundos, para garantir que não ajustemos o ate mais rápido do que 50 Hz ou 50 vezes por segundo. Isso ocorre porque os humanos podem ser muito mais lentos do que um Arduino. Portanto, se o atraso não for realizado, o programa pode nos fazer sentir que pressionar o primeiro botão desligou o LED e pressionar o segundo botão o ligou (experimente você mesmo para confirmar).

3.2 Potenciômetros

Vamos seguir em frente e aprender como usar potenciômetros com Arduino.

Para saber como funciona um potenciômetro ou uma panela, você pode ler este artigo .

Usando potenciômetro com Arduino

Conecte os parâmetros mostrados ao seu Arduino conforme mostrado acima.

Um potenciômetro terá 3 terminais. O terminasl do meio se conectará com ANALOG IN 0 no Arduino. Os outros dois terminais externos podem ser conectados aos trilhos de alimentação de + 5V e 0V.

Vamos programar e verificar os resultados:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinPot, INPUT)
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int ledBrightness
int sensorValue = 0
sensorValue = analogRead(kPinPot)
ledBrightness = map(sensorValue, 0, 1023, 0, 255)
analogWrite(kPinLed, ledBrightness)
}

Você encontrará algumas coisas que podem parecer inteiramente novas e não incluídas em nenhum de nossos códigos anteriores.

  1. A constante kPinPot é atribuído como A0, em que A é o atalho para descrever um dos pinos analógicos. No entanto, A0 também se refere ao pino 14, A1 ao pino 15 e assim por diante, e eles permitem que você seja usado como entradas / saídas digitais no caso de ficar sem pinos para um experimento. Mas lembre-se de que você não pode usar pinos digitais como pinos analógicos.
  2. A linha: ledBrightness = map(sensorValue, 0, 1023, 0, 255) apresenta uma nova função interna no Arduino conhecida como mapa(). Este recurso recalibra de um determinado intervalo para outro, denominado como map (valor, fromLow, fromHigh, toLow, toHigh). Isso pode se tornar crucial, pois analogueRead fornece um valor dentro do intervalo de 0-1023, mas analogWrite é capaz de aceitar um valor de 0-255.

Você pode pensar, que uma vez que é possível controlar o brilho de um LED através de uma resistência variável, simplesmente um potenciômetro poderia ter sido suficiente para o efeito, por que o uso do Arduino. Bem, novamente é apenas a base, para mostrar como um potenciômetro pode ser configurado com um Arduino.

Sem problemas, agora faremos algo que não pode ser feito sem um Arduino.

Neste experimento, veremos como a resistência variável de um potenciômetro pode ser usada para controlar a velocidade ou taxa de piscar de um LED.

Aqui está o programa:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
digitalWrite(kPinLed, HIGH)
delay(sensorValue)
digitalWrite(kPinLed, LOW)
delay(sensorValue)
}

3.2.3 Evitando atrasos ()

O código acima parece bom, mas o LED não consegue verificar o valor do potenciômetro até que passe por cada ciclo completo. Para atrasos mais longos, esse processo fica mais longo, o usuário tem que esperar para ver a resposta do potenciômetro enquanto o move. Este atraso pode ser evitado com alguma programação inteligente, de forma que permita ao usuário verificar o valor sem atrasos mínimos. Aqui está o código.

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
long lastTime = 0
int ledValue = LOW
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
if(millis() > lastTime + sensorValue){
if(ledValue == LOW){
ledValue = HIGH
}
else{
ledValue = LOW
}
lastTime = millis()
digitalWrite(kPinLed, ledValue)
}
}

Então, o que é diferente no código acima? É a linha a seguir que faz a diferença.

long lastTime = 0

Até esta seção, discutimos sobre a variável int. No entanto, pode haver vários outros tipos de variáveis ​​que você pode acessar. A lista pode ser lida abaixo:

Tipos de variáveis ​​do Arduino

Atualmente, pode ser apenas crucial saber que, para armazenar números relativamente grandes para o int variável, você poderia usar o termo longo ou um long int.

Aqui você pode ver outra função interessante chamada millis ().

Isso produz o intervalo de tempo em milissegundos que o Arduino trabalhou em seu curso de operação desde o início (isso será redefinido para 0 a cada 50 dias). Aqui ele retorna um longo porque se retornasse int , a contagem por longos períodos pode não ser possível. Você poderia responder exatamente quanto tempo? A resposta é 32,767 segundos.

Portanto, em vez de usar delay (), verificamos os millis () e, assim que o número específico de milissegundos transcorrer, mudamos o LED. Conseqüentemente, armazenamos o tempo que alteramos pela última vez em última vez variável, de modo que nos permite verificá-la novamente sempre que desejar.

3.3 LEDs RGB

Até agora, jogamos com um LED de uma única cor. Embora a cor do LED possa ser alterada substituindo o LED por outra cor, que tal usar LEDs RGB mudar as cores do LED sem mudar os LEDs?

Um LED RGB é basicamente um LED com um LED vermelho, verde e azul embutido e mesclado em um único LED. Ele tem um condutor comum que vai para o solo ou trilho de alimentação de 0 V, enquanto os outros 3 condutores são alimentados com sinais positivos PWM diversificados para implementar o mistura de cores .

Você pode conectar a configuração conforme mostrado abaixo:

Controle RGB com Arduino

Pode parecer um pouco complexo, mas na verdade é uma réplica de nosso projeto de controle de LED anterior usando PWM.

Aqui está um código de programa de prática:

const int kPinPot1 = A0
const int kPinPot2 = A1
const int kPinPot3 = A2
const int kPinLed_R = 6
const int kPinLed_G = 10
const int kPinLed_B = 11
void setup()
{
pinMode(kPinLed_R, OUTPUT)
pinMode(kPinLed_G, OUTPUT)
pinMode(kPinLed_B, OUTPUT)
}
void loop()
{
int potValue
int ledValue
potValue = analogRead(kPinPot1)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_R, ledValue)
potValue = analogRead(kPinPot2)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_G, ledValue)
potValue = analogRead(kPinPot3)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_B, ledValue)
}

Após fazer o upload deste código, veja como os ajustes do potenciômetro criam um efeito de luz interessante no RGB, pode ser muito divertido.

Você verá que quando todos os 3 potes forem movidos para as posições máximas, em vez da cor branca, você verá o vermelho. Isso ocorre porque a cor vermelha é a mais proeminente entre as 3 cores e, portanto, domina nesta situação. No entanto, você pode experimentar com a função mapa() , antes de executá-lo na parte vermelha do LED, a fim de criar um equilíbrio mais sensível.

Áudio com Arduino

Nesta seção, aprenderemos como adicionar som e música básicos a uma configuração do Arduino.

Veremos como mudar um sinal para um alto-falante conectado com uma frequência desejada.

Para ser mais preciso, uma nota média A será tentada, que é uma nota de frequência de 440 Hz.

Para fazer isso, simplesmente tocaremos uma nota A central e otimizaremos o sinal da onda senoidal com a onda quadrada.

Além disso, calcularemos a quantidade de tempo que um alto-falante pode permanecer LIGADO processando a fórmula:

timeDelay = 1 segundo / 2 x toneFrequency.

timeDelay = 1 segundo / 2 x 440

timeDelay = 1136 microssegundos

4.1 Vamos conectar a placa Arduino

Usando efeito de som no Arduino

4.2 Adicionando uma nota simples

Já discutimos sobre a função atraso() onde a unidade está em milissegundos (segundo / 1000), no entanto, você encontrará outra função delayMicroseconds() onde a unidade está em microssegundos, (milissegundos / 1000).

Para a configuração atual, programamos um código para ligar / desligar + 5V no pino selecionado vinculado ao alto-falante, a uma taxa de 440 pulsos por segundo.

Lembre-se, na última discussão, determinamos o valor 1136 microssegundos para a nota de áudio pretendida.

Então aqui está o programa para isso, que permitirá a você ouvir uma nota de áudio de 440 Hz assim que programar o arduino com um alto-falante conectado.

const int kPinSpeaker = 9
const int k_timeDelay = 1136
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
digitalWrite(kPinSpeaker, HIGH)
delayMicroseconds(k_timeDelay)
digitalWrite(kPinSpeaker, LOW)
delayMicroseconds(k_timeDelay)
}

Com a aplicação acima é possível fazer uma nota de áudio, o que também significa que podemos criar uma música de acordo com nossa escolha.

A partir do código, compreendemos que o Arduino inclui algumas funções integradas que contribuem adicionalmente para a criação de música.

O primeiro é tom() que funciona com 2 elementos junto com um terceiro elemento opcional, designado como tom (pino, frequência, duração). ou tom (pin, frequência)

Ambos são designados para executar o respectivo período de tempo designado por você.

Na ausência de um período de tempo, a música continuará tocando até a chamada tom() é executado novamente, ou até que você execute nenhum ().

Isso precisará ser feito usando uma função de retardo, caso a reprodução de música seja a única coisa fundamental que você está implementando.

O tempo de duração pode ser crucial, pois permite fornecer um tempo durante quanto tempo a música é tocada, então você pode ficar livre para fazer outras coisas. Assim que a duração termina, a música para.

A próxima função nenhum () lida com um único parâmetro e interrompe o som selecionado em um determinado pino atribuído.

Um aviso peculiar: a qualquer momento, quando tom() a função for implementada, a função PWM nos pinos 3 e 11 irá parar de funcionar.

Portanto, sempre que um anexo de alto-falante for usado no programa, certifique-se de não usar o pino mencionado para os alto-falantes; em vez disso, tente alguns outros pinos para o anexo de alto-falante.

OK, então aqui está um programa para implementar música em um alto-falante, embora não seja uma música real, em vez de uma nota C de escala básica.

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}

No código acima, você pode ter notado algo novo e isso é #definir .

Este termo funciona como um comando de pesquisa e substituição para o computador enquanto a compilação está sendo feita.

Sempre que encontrar a primeira coisa antes de um espaço, ele a substitui pelo restante da linha (chamadas macros).

Portanto, neste exemplo, quando o computador vê NOTE_E4 ele rapidamente o substitui pela quantidade 330.

Para mais notas e personalização, você pode consultar um arquivo em seu stick USB chamado pitches.h , onde a maioria das frequências podem ser encontradas para sua preferência.

4.4 Música com funções

O código acima parece bom, mas parece ter muitas repetições, deve haver algum método para encurtar essas repetições, certo?

Até agora, trabalhamos com duas funções essenciais incluídas no Arduino. Agora pode ser a hora de criarmos nossas próprias funções.

Cada função deve começar com o tipo de variável à qual pode estar associada. Por exemplo, a função vazio refere-se ao tipo que não retorna nada, daí o nome void. Observe que já discutimos uma lista de variáveis ​​em nossas seções anteriores, você pode querer consultá-las.

Consequentemente, o nome da função em particular fica com um parêntese aberto '(' seguido por uma lista de parâmetros separados por vírgulas.

Cada um dos parâmetros adquire seu tipo junto com um nome e, finalmente, um ')' parêntese.

Esses parâmetros podem ser aplicados dentro da função na forma de variáveis.

Vamos ver um exemplo abaixo, onde desenvolvemos uma função chamada ourTone () projetado para fundir o tom() com atraso() linhas, de forma que a função pare de retornar até que a nota termine de tocar o tom.

Implementamos essas funções em nosso código anterior e obtemos o programa abaixo, consulte as últimas linhas:

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

As funções podem ser extremamente úteis para tornar um programa mais fácil de entender.

A seguir está um exemplo onde podemos especificar a escolha do tom que queremos tocar usando duas matrizes. Uma matriz para reter as notas, a outra para reter as batidas.

#include 'pitches.h'
int kPinSpeaker = 9
#define NUM_NOTES 15
const int notes[NUM_NOTES] = // a 0 represents a rest
{
NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4,
NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
}
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }
const int beat_length = 300
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
for (int i = 0 i if (notes[i] == 0) {
delay(beats[i] * beat_length) // rest
}
else {
ourTone(notes[i], beats[i] * beat_length)
}
// pause between notes
noTone(kPinSpeaker)
delay(beat_length / 2)
}
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Você pode ver claramente na primeira linha a introdução de #incluir demonstração. O trabalho desta declaração é pegar todo o arquivo entre as aspas e colocá-lo na posição do #incluir demonstração. De acordo com as regras padrão, elas são colocadas estritamente no início do programa.

capítulo 5

Temperatura de medição

Só para lembrar, lembre-se, em vez de escrever programas grandes, é sempre bom escrever e analisar pequenas partes dos códigos, o que ajuda a rastrear erros rapidamente.

5.1 Monitor Serial

Até agora, os códigos que discutimos não parecem tão mais fáceis para permitir uma solução de problemas rápida. Aqui, tentaremos facilitar o monitoramento e a solução de um possível problema.

O Arduino possui um recurso que permite 'falar' com o computador. Você pode observar que pin0 e pin1 são marcados como RX e TX lado a lado. Na verdade, esses pinos são rastreados por um IC separado dentro do Arduino, que os atualiza para ler através do cabo USB enquanto ele está conectado ao PC.

A seção abaixo mostra um programa completo, por favor, vá embora, nós aprenderemos sobre as novas entradas no código depois disso. Este código é igual ao expresso na seção 2.2, exceto pelo fato de incluir alguns dados extras para nos permitir identificar para que foi codificado.

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
Serial.begin(9600)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If it would have been zero or less, reset it.
delayTime = 1000
}
Serial.print('delayTime = ')
Serial.println(delayTime)
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Você pode identificar duas coisas novas aqui, uma nova linha no configurar() função.

Serial.begin(9600)

Esta linha simplesmente expressa a necessidade de usar o Serial1 código para aplicá-lo com 9600 baud. (aqui serial se refere a bits enviado um após o outro, e baud significa a taxa em que é enviado). Este valor de baud e aquele dentro do monitor serial (vamos aprender isso mais tarde) devem ser iguais, ou então os dados no monitor serial mostrarão lixo. 9600 sendo o padrão torna-se mais conveniente de usar.

A segunda nova entrada é a seguinte

Serial.print('delayTime = ')
Serial.println(delayTime)

Aqui, a segunda linha sugere que o item subsequente que sai da porta serial começará na próxima linha. É assim que a segunda linha é diferente da primeira linha.

Mais uma coisa que você pode ver são aspas ('). Isso é conhecido como string, que será usado apenas como constantes aqui, porque uma discussão mais aprofundada sobre este tópico pode ser muito elaborada e além do escopo.

OK, agora podemos carregar o código acima no Arduino e ver o que acontece.

O que, opa, nada parece ter acontecido, o LED do pino 13 do Arduino piscou e parou, enquanto o LED Tx continuou piscando.

Bem, isso é porque a janela Serial Monitor ainda não foi corrigida.

Você precisa clicar na caixa Serial Monitor em seu IDE como mostrado acima. Não se esqueça de verificar a taxa de transmissão localizada no canto inferior direito, por padrão deve ser 9600 e corresponderá ao código. Se não estiver, selecione 9600.

O videoclipe a seguir explica como isso é feito.

https://youtu.be/ENg8CUyXm10

Agora vamos seguir em frente e aprender como o recurso Monitor Serial acima pode auxiliar no processamento do medição de temperatura usando Arduino

Usaremos o IC TMP36 como sensor de temperatura, com faixa de -40 a 150 graus Celsius.

A configuração pode ser vista abaixo:

TMP36 com Arduino para medição de temperatura

O código a seguir iniciará a medição de temperatura lendo a saída do sensor TMP36 e enviando para o monitor serial do ID.

const int kPinTemp = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
float temperatureC = getTemperatureC()
Serial.print(temperatureC)
Serial.println(' degrees C')
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
Serial.print(temperatureF)
Serial.println(' degrees F')
delay(500)
}
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Vamos entender o código desde o início.

float temperatureC = getTemperatureC()

Aqui você pode ver que incluímos o tipo de variável flutuador.

Este é o único tipo de variável que permite armazenar tudo, exceto números inteiros (números sem partes decimais ou fracionárias).

A precisão de uma variável flutuante pode ser de até 6 a 7 dígitos.

O código adjacente getTemperatureC() é nossa própria função que calcula matematicamente e converte a diferença de tensão detectada do sensor TMP36 em graus Celsius.

float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}

Na próxima seção dos códigos, uma vez que o termo analogIn() é designado para retornar um valor entre 1 e 1023, torna-se possível para nós avaliarmos a tensão do sensor multiplicando nossa leitura por 5 e, em seguida, dividindo-a por 1024.

O sensor TMP36 é especificado para gerar 0,5 V a 0 graus Celsius e, subsequentemente, gerar 10 mV para cada aumento em graus Celsius.

Esta é a aproximação que podemos gerar por meio dos cálculos:

Calibração de temperatura Arduino

Você pode considerar ser a sua primeira função que retorna algum valor (note que todas as funções restantes até agora não retornaram nenhum valor, uma vez que foram do tipo vazio )

Você pode entender que, para obter um valor de uma função, você simplesmente precisa adicionar Retorna seguido pelo número desejado que você deseja retornar.

Quando dizemos Retorna significa que a função retorna uma resposta ou uma resposta sempre que é chamada, que pode ser aplicada a uma variável.

Quando isso é enviado ao Monitor Serial, a leitura é convertida para Fahrenheit por meio convertToF ().

float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Esta função pega a faixa Celsius e a converte para Fahrenheit.

Para converter Fahrenheit em Celsius, implementamos a fórmula Fahrenheit = 9 / 5 (Celsius) + 32.

5.3 Interface com um LCD

Agora vamos estudar como fazer a interface ou conectar um tela de LCD com Arduino para obter uma exibição visual das saídas necessárias.

Em nossa aplicação, vamos empregar um LCD gráfico de 84x48, com 84 pixels ou pontos horizontalmente e 48 pixels de resolução vertical. Uma vez que um controlador dedicado torna-se obrigatório para todos os LCDs, o presente dispositivo também incorpora um na forma de controlador PCD8544.

Neste tutorial, conectaremos o módulo LCD especificado acima ao Arduino e aplicaremos certas rotinas para criar mensagens de texto no display.

Na figura a seguir, você pode encontrar detalhes sobre a interface do LCD, junto com um pequeno Regulador de tensão de 3,3 V . Este regulador é necessário, pois o LCD é especificado para funcionar com uma alimentação de 3,3V.

Você também pode ver 8 pinagens do módulo LCD, as especificações da pinagem podem ser estudadas a partir da seguinte tabela:

Detalhes de pinagem de LCD

Agora vamos ver como podemos conectar o LCD e os parâmetros relevantes com nosso Arduino. Os detalhes podem ser visualizados na ilustração mostrada abaixo:

Aprendizagem básica do Arduino

5.4 Comunicação com o LCD

Embora seja possível escrever coeds elaborados para interagir com LCD do Arduino, vamos aprender como fazer o mesmo usando bibliotecas.

As bibliotecas compreendem uma variedade de códigos que podem ser rapidamente aplicados a um programa Arduino selecionado.

Isso permite que o usuário chame uma função sem esforço, sem ter que passar por um trabalho complexo de codificação.

5.4.1 Como instalar a biblioteca

Para isso você terá que criar um diretório chamado libraries no seu computador Arduino IDE, conforme explicado Aqui

5.4.2 Implementando as operações de LCD

Assim como nossa abordagem anterior, primeiro verificaremos todo o código e, em seguida, tentaremos entender os detalhes das linhas individuais.

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

A linha inclui o código #include

O código #include instrui o PC a pegar o arquivo mencionado e substituir o elemento #include com o conteúdo do arquivo durante o curso de compilação do programa.

O elemento #include pode possuir colchetes angulares que indicam a busca no diretório da biblioteca, alternativamente, também pode conter aspas que indicam a busca no mesmo diretório em que o programa está localizado.

As linhas de código subsequentes expressam as pinagens do LCD e, em seguida, escrevemos uma nova forma de variável:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Aqui estamos expressando uma variável com o nome lcd tendo o tipo PCD8544 e instruindo o PC a reclassificar sua pinagem associada ao Arduino.

Neste processo, descrevemos a variável para o PC, instruindo como o pin clk, din, dc e reset são conectados ao Arduino.

void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}

A linha lcd.init() inicializa a operação do LCD. Depois de executado, a próxima linha impõe um cursor no canto superior esquerdo da tela. E a próxima linha subsequente faz um esforço para imprimir a mensagem 'Alô, Mundo'.

Isso parece bastante idêntico à técnica em que enviamos mensagens pelo monitor serial. A única diferença é o uso do código lcd.print em vez de serial.print.

O próximo bloco de código é chamado repetidamente.

void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

Usando esta linha lcd.setCursor(0,1) fixamos o cursor na 0ª coluna na extrema esquerda da 1ª linha, sobre o display LCD.

A próxima linha utiliza um atalho: lcd.print(millis())

Se você se lembra, trabalhamos com millis() em nossos códigos anteriores, poderíamos ter aplicado o mesmo aqui também por meio dos códigos:

long numMillis = millis()
lcd.print(numMillis)

No entanto, devido ao fato de que aqui nenhum período de tempo em milissegundos está envolvido, nós o realizamos simplesmente enviando millis() função diretamente para lcd.print() .

5.5 Combinando Tudo

OK, agora vamos combinar todos os códigos que aprendemos acima para fazer o circuito de temperatura do LCD e vamos ver como fica:

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
const int kPin_Temp = A0
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(10,0)
lcd.print('Temperature:')
}
void loop()
{
float temperatureC = getTemperatureC()
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
lcd.setCursor(21,1)
lcd.print(temperatureC)
lcd.print(' C')
lcd.setCursor(21,2)
lcd.print(temperatureF)
lcd.print(' F')
delay(100)
}
float getTemperatureC()
{
int reading = analogRead(kPin_Temp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Tudo parece padrão no programa acima, exceto o uso da função setCursor () . Isso é usado para alinhar o texto o máximo possível em torno do centro da tela.

Excelente! E parabéns, você acabou de programar seu próprio pequeno indicador de temperatura no LCD usando o Arduino.

Aplicações práticas do Arduino

Visto que, neste ponto, cobrimos de maneira abrangente as várias técnicas de programação em detalhes, é hora de defini-las aplicando-as em algumas implementações práticas úteis.

Começaremos com sensores e veremos como os dispositivos sensores podem ser usados ​​com o Arduino, executando alguns códigos de amostra.

7.1 Introdução aos Sensores

Neste tutorial, aprenderemos sobre a ampla variedade de sensores que podem ser usados ​​com o Arduino. Estes podem incluir dispositivos como sensor de luz LDR, sensor de efeito Hall magnético, sensores de inclinação, sensor de vibração, sensor de pressão, etc.

Começaremos com a interface de sensor de luz LDR com Arduino, conforme mostrado no seguinte diagrama:

usar LDR com Arduino

Como todos sabemos, o LDR é um dispositivo resistor dependente da luz, cuja resistência depende da intensidade do incidente ambiental em sua superfície.

A intensidade da luz é inversamente proporcional à leitura da resistência do LDR.

Aqui, aprenderemos como essa propriedade pode ser integrada ao Arduino para executar um aplicativo útil:

O código completo do programa pode ser visualizado conforme abaixo:

const int kPin_Photocell = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
int value = analogRead(kPin_Photocell)
Serial.print('Analog Reading = ')
Serial.print(value)
if(value <200){
Serial.println(' - Dark')
}else if(value <400){
Serial.println(' - Dim')
}
else if(value <600){
Serial.println(' - Light')
}
else if(value <800){
Serial.println(' - Bright')
}
else{
Serial.println(' - Very Bright')
}
delay(1000)
}

Todos os parâmetros usados ​​no código já foram discutidos em nosso curso que aprendemos até agora. Você pode verificar as linhas consultando as seções relevantes.

Os valores foram escolhidos aleatoriamente, você pode alterar facilmente de acordo com suas preferências.

Sensor de inclinação

Um sensor de inclinação é um dispositivo simples que pode ser usado para detectar uma ação de inclinação em qualquer objeto onde esteja instalado. O dispositivo basicamente tem uma bola metálica em seu interior, que ao se inclinar rola sobre um par de contatos causando uma condução através desses contatos. Esses contatos sendo terminados como condutores do interruptor de inclinação, são usados ​​com um circuito externo para detectar a condução devido a uma ação de inclinação e ativar a aplicação de saída desejada.

Agora vamos ver como um sensor de inclinação dispositivo pode ser conectado. A imagem abaixo nos dá uma ideia da configuração completa:

integração do sensor de inclinação com Arduino

const int kPin_Tilt = 3
const int kPin_LED = 13
void setup()
{
pinMode(kPin_Tilt, INPUT)
digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor
pinMode(kPin_LED, OUTPUT)
}
void loop()
{
if(digitalRead(kPin_Tilt) == HIGH){
digitalWrite(kPin_LED, LOW)
}
else{
digitalWrite(kPin_LED, HIGH)
}
}

Neste exemplo, o LED padrão do pino nº 13 é usado como indicador de inclinação.

Você pode ver claramente a inclusão do resistor pull-up aqui, bastante semelhante ao que fizemos na seção 3.1. Portanto, o termo BAIXO indica que a função de inclinação não é acionada.

7.4 Relé da chave de palheta (relé ativado por ímã miniatura)

Agora vamos ver como conectar uma chave de relé ou um sensor de campo magnético ao Arduino. Um relé de palheta é um tipo de interruptor que é ativado ou conduzido quando um campo magnético ou um ímã é aproximado. Basicamente, ele tem um par de contatos ferromagnéticos dentro de uma caixa de vidro em miniatura que se unem ou fazem contato devido à atração magnética sempre que um magnético está próximo a ele. Quando isso ocorre os terminais dos contatos apresentam condução devido ao fechamento dos contatos.

Aqui também usamos o LED do pino 13 para indicar a resposta. Você pode conectar um LED externo a partir deste pino, se necessário, de acordo com nossas explicações anteriores.

const int kPinReedSwitch = 2
const int kPinLed = 13
void setup()
pinMode(kPinReedSwitch, INPUT)
digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinReedSwitch) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Os termos do código devem ser familiares e autoexplicativos.

7.5 Sensor de vibração usando transdutor piezoelétrico

No próximo programa de amostra, veremos como um piezo transdutor pode ser usado como um sensor de vibração para iluminar um LED através do Arduino.

Um elemento piezoelétrico é, na verdade, um dispositivo que gera vibração ou oscilação quando uma frequência é aplicada em seus terminais. No entanto, o mesmo piezo pode ser usado no processo inverso para gerando pulsos elétricos em resposta à vibração aplicada em seu corpo. Essa vibração pode ser na forma de uma batida ou batida na superfície do piezo.

Configure o Arduino e um elemento piezo conforme mostrado na figura a seguir

usando piezo como sensor de vibração com Arduino

const int kPinSensor = A5
const int kPinLed = 13
const int k_threshold = 100
int ledState = LOW // variable used to store the last LED status, to toggle the light
void setup()
{
pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT
}
void loop()
{
int val = analogRead(kPinSensor)
if (val >= k_threshold) {
ledState = !ledState // toggle the value of ledState
digitalWrite(kPinLed, ledState)
delay(20) // for debouncing
}
}

O limite 100 é introduzido apenas para garantir que o Arduino responda apenas às vibrações genuínas por meio de batidas, e não a outras vibrações menores, como sons altos ou buzinas.

A seleção do pino A5 não é obrigatória, você pode selecionar qualquer outra entrada analógica de acordo com sua preferência e combinando-a no código do programa.

Usando servo motor com Arduino

Um servo motor é um tipo de motor DC que pode ser girado em ângulos precisos de acordo com a demanda de uma aplicação particular. Isso pode ser feito aplicando um comando calculado às entradas relevantes do motor para produzir um ângulo de rotação ou rotação preciso dentro da faixa de 180 graus do motor.

Normalmente, um servo motor tem 3 fios ou entradas. Os fios positivos são normalmente da cor vermelha, o negativo ou fio terra é preto, e o fio de comando ou o fio de sinalização é normalmente branco ou amarelo.

O Arduino facilita o controle do servo motor por meio de uma linguagem de suporte integrada, o que torna o controle muito conveniente e ideal para servo motores.

O exemplo a seguir nos mostrará o programa de configuração básica para implementar o controle do servo motor através do Arduino:

Controle do servo motor Arduino

O código é fornecido abaixo:

#include
Servo servo1
const int kPinPot = A0
const int kPinServo1 = 9
void setup()
{
servo1.attach(kPinServo1)
}
void loop()
{
int val = analogRead(kPinPot)
val = map(val, 0, 1023, 0, 180)
servo1.write(val)
delay(15)
}

Podemos ver algumas novas entradas aqui. Um que informa ao fio conectado do servo a qual pino ele está atribuído. O outro é o código que fornece ao pino um valor entre 0 e 180, para determinar o ângulo de rotação do servo.

Conclusão

O assunto Arduino pode ser infinitamente longo e, portanto, além do escopo deste artigo. No entanto, espero que o tutorial acima certamente tenha ajudado você a aprender o básico do Arduino e entender parâmetros importantes por meio dos vários códigos de aplicativo de exemplo.

Esperamos que mais informações possam ser atualizadas de vez em quando aqui, sempre que estiverem disponíveis.

Enquanto isso, aproveite seu curso de programação. Feliz Arduinoing para você !!




Anterior: Circuito Medidor Detector de Álcool usando Módulo Sensor MQ-3 Próximo: Circuito de comedouro para cães controlado por celular