Arduino 8: Monitor serial

O monitor serial é uma tela que aparece no computador quando o Arduino está conectado via USB e que permite imprimir texto enviado pelo programa. Ele pode ser usado para depurar programas, ou exibir dados lidos por sensores.

Para usar o monitor serial, é preciso declarar dentro do bloco setup() a taxa de leitura. Para depuração simples use o comando:

Serial.begin(9600);

Dentro de loop(), quando quiser imprimir algo no terminal use Serial.print() (que imprime texto ou valor de uma variável) ou Serial.println() (que imprime uma nova linha no final). Para imprimir texto, ele deve ser informado entre aspas. Por exemplo, considere o trecho abaixo:

void loop() {
    int estado = digitalRead(9);
    Serial.print("Estado do botão: ");
    Serial.println(estado);
}

O monitor serial pode ser aberto através do menu Ferramentas (ou Tools) do IDE Arduino, ou. Rodando o programa acima, ele irá imprimir “Estado do botão: 0” se o botão estiver no estado LOW, ou “Estado do botão: 1” se ele estiver no estado HIGH.

É mais interessante usar o monitor serial para ler dados gerados por dispositivos analógicos. Faremos isto no experimento a seguir.

Experimento 29 – Termômetro

Material necessário:

  • Arduino Nano + cabo USB + computador
  • Circuito termômetro LM35DZ (veja referência no final da apostila)
  • Protoboard, fios e jumpers

Neste experimento conectamos um componente LM35 ao Arduino para obter a temperatura do ambiente e imprimir o seu valor no monitor serial.

O LM35 é um termômetro de precisão. Ele tem a mesma embalagem (TO-92) que um transistor BC549. Uma vez alimentado com uma tensão entre 5 e 15 V nos seus terminais externos, o terminal central apresentará uma tensão relativa ao terminal negativo proporcional à temperatura ambiente. Aos 25 graus Celsius essa tensão medirá 0,25V, e varia 0,01 volts para cada grau acima ou abaixo com margem de erro de 0,5 graus dentro da faixa 2 a 100 graus Celsius.

Veja a pinagem do LM35 na referência ao final da apostila. Ligue o seu pino VCC no pino 5V do Arduino, e o GND do LM35 em qualquer um dos dois GND do Arduino. O pino central OUT fornecerá a medida da tensão e deve ser ligado a qualquer uma das entradas analógicas (A0 a A7) do Arduino.

No programa abaixo ligamos terminal OUT do LM35 na entrada analógica A1.

#define TERMOMETRO A1

void setup() {
    Serial.begin(9600);
}

void loop() {
    int leitura = analogRead(TERMOMETRO);
    float volts = (leitura / 1024.0) * 5.0;
    float celsius = (volts) * 100.0;
    Serial.print("Temperatura: ");
    Serial.println(celsius);
    delay(2000);
}

A leitura analógica do Arduino varia de 0 (0 volts) a 1024 (5 volts). Portanto é preciso dividir por 1024 e multiplicar por 5 para obter o valor real em volts que está no terminal OUT do LM35. A leitura em graus Célsius será este valor multiplicado por 100.

Neste programa a temperatura é impressa a cada 2 segundos no monitor serial. O circuito funciona apenas conectado ao computador. Para tornar o termômetro independente do computador teríamos que elaborar um circuito de saída capaz de indicar a temperatura. Poderia ser um par de displays de 7 segmentos, um display de cristal líquido, uma série de leds, etc.

O próximo experimento combinará o uso de entradas e saídas analógicas para controlar a velocidade de um motor.

Arduino 7: Entrada analógica

As entradas analógicas podem ser usadas para ler valores produzidos por sensores e potenciômetros. A instrução é analogRead(Número-do-pino). O valor lido é de 0 a 1023 (correspondente a valores intermediários de tensão entre 0 e 5V). Os pinos de entrada analógica são A0 – A7. Eles podem ser identificados no programa com ou sem prefixo A (ex: pode-se usar A0 ou simplesmente 0):

int valor = analogRead(3); // lê do pino A3

É uma boa prática usar sempre o prefixo A ao declarar pinos analógicos, já que deixa o código mais legível e fácil de entender, evitando confusão com pinos digitais.

Os pinos de entrada analógica não podem ser usados para saída analógica. Eles não suportam PWM. Mas os seis primeiros (A0 a A5) podem ser usados para saída digital (digitalWrite), se necessário. Neste caso eles podem ser identificados com o nome analógico prefixado (A0, A1, etc.) ou com os números 14 a 19 (que correspondem aos pinos A0 a A5, respectivamente). Ou seja,

digitalWrite(A5, HIGH);

é o mesmo que

digitalWrite(19, HIGH);

Experimento 28 – “Theremin” com LDR e potenciômetro

Material necessário:

  • Arduino Nano + cabo USB + computador
  • Potenciômetro de qualquer valor (ex: 10k, 100k)
  • Resistor de 1k ohms
  • LDR
  • Alto-falante
  • Protoboard, fios e jumpers

O circuito abaixo usa duas entradas analógicas. Uma para obter a leitura de luz, e a outra para obter a posição do potenciômetro que será usada para especificar um intervalo de tempo. A quantidade de luz no LDR irá variar a tensão sobre o resistor de 1k (e consequentemente no pino A0). O mesmo ocorre no pino A1, que obtém seu valor do divisor de tensão formado pelo potenciômetro.

A saída PWM varia de 0 a 255, portanto em um circuito perfeitamente calibrado, dividiríamos o valor lido em qualquer uma das entradas analógica por 4 (1024/4 = 256) para usá-lo diretamente na saída. 

No programa abaixo dividimos por 4 o valor lido no potenciômetro. Mas a tensão no pino A1 que varia com a luz aplicada ao LDR tem valor indefinido (que provavelmente nunca será zero ou 1023).

#define FTE 12
#define LDR A0
#define POT A1

void setup() {} // pinMode é opcional com analogRead

void loop() {
    int luz   = analogRead(LDR);
    int pausa = analogRead(POT);
    delay(pausa * .25);
    int tom = luz * luz * luz / 16; // experimente outros valores
    tone(FTE, tom);
}

O comando tone() gera uma onda quadrada em frequência especificada como parâmetro. As frequências suportadas (até 65kHz) incluem frequências audíveis (20Hz a 20kHz). O valor proporcional ao cubo do valor lido pelo LDR permite que a frequência varie bastante alternando entre sons agudos e graves.

Arduino 6: PWM

O Arduino Nano não produz sinal analógico verdadeiro, mas apenas os simula através de PWM (Pulse Width Modulation – veja capítulo anterior) através dos pinos digitais 3, 5, 6, 9, 10 e 11. PWM permite simular valores médios de tensão que variam entre os níveis lógicos LOW e HIGH. Esses valores são representados por número entre 0 a 255 retornado pela instrução analogWrite().

analogWrite(5, 64); // envia 5V 25% do tempo 5V para a saída digital 5

Experimento 27 – Piscando suavemente

Material necessário:

  • Arduino Nano + cabo USB + computador
  • LED
  • Resistor de 220 ohms
  • Protoboard, fios e jumpers

Este é uma variação do primeiro experimento que pisca um LED. O circuito é praticamente o mesmo, mas como o pino 8 usado no programa anterior não suporta PWM, transferimos o LED para o pino digital 3 (que é um dos seis pinos que suporta saída analógica).

O programa também mudou. Em vez de piscar em dois estados digitais, este pisca suavemente, variando entre o totalmente aceso e totalmente apagado.

int LED = 3;
int brilho = 255; // inicia com brilho máximo
int direcao = -1; // 1 = aumentando, -1 = diminuindo

void setup() {
    pinMode(LED, OUTPUT); // opcional com analogWrite (mas é boa prática)
}
void loop() {
    analogWrite(LED, brilho);
    delay(2);
    brilho = brilho + direcao;
    if(brilho <= 0 || brilho >= 255) {
        direcao = -direcao;
    }
}

O programa define duas variáveis (além do pino): brilho, que guarda o valor do brilho do LED (entre 0 e 255) e direcao, que contém o número 1 ou -1, que será somado ao brilho cada vez que loop() for executado, fazendo com que o brilho aumente ou diminua lentamente.

Assim que loop() inicia, o pino onde está o LED recebe o valor analógico 255 (correspondente a 5V). Depois espera 10 milissegundos e executa a instrução

brilho = brilho + direcao;

Uma expressão de atribuição primeiro executa a expressão do lado direito do “=”, substituindo as variáveis por seus valores. Portanto, a expressão executada será calculada da seguinte forma:

brilho = 255 + (-1)

que irá gravar o valor 254 na variável brilho.

No bloco seguinte temos uma expressão condicional if que testa se brilho é maior ou igual a zero OU se é maior ou igual a 255. O símbolo || conecta duas expressões através de uma proposição lógica OU. Isto significa que a condição do if será verdadeira se uma ou ambas as expressões forem verdadeiras. A condição é testada para os valores limite 0 e 255. Quando o valor de brilho chegar a um desses valores, o sinal da variável direcao é trocado (se era 1, passa a ser -1; se era -1 passa a ser 1). Assim o brilho que estava diminuindo, passa a gradualmente aumentar, e vice-versa.

Arduino 5: Resistores de pull-up

Há situações em que um programa precisa saber o estado da chave também quando ela não estiver sendo apertada. Nesses casos, é preciso conectar um resistor de pull-up ou pull-down entre o pino e o estado desejado (oposto ao estado quando a chave estiver acionada) para que o estado inicial seja definido. Este resistor liga o pino a um estado inicial. Se o pino for depois ligado diretamente ou através de uma resistência menor, a 5V ou GND, haverá um caminho mais curto para a corrente e seu estado será invertido.

Ligar o pino a 5V ou GND é irrelevante, pois o programa poderá escolher o que fazer em cada caso. Por exemplo, se escolhermos ligar uma chave a 5V, o valor no pino será HIGH quando a chave for pressionada, mas indefinido quando ela estiver aberta (veja ilustração abaixo). Usando um resistor de pull-down (tipicamente de 10k) ligando o pino inicialmente a GND, garantirá ao pino um estado inicial LOW que mudará para HIGH quando a chave for pressionada.

Se usarmos a lógica oposta (conectar com GND/LOW em vez de 5V/HIGH) não precisaremos dos resistores, pois o Arduino possui internamente resistores de pull-up (ligados em 5V) para cada pino. Esta opção pode ser ativado configurando o pinMode() com INPUT_PULLUP:

pinMode(CHAVE, INPUT_PULLUP);

Nessa configuração, o pino terá sempre como estado inicial o nível lógico HIGH. No fechamento da chave, o estado mudará para o nível lógico oposto (LOW). O diagrama abaixo ilustra as duas formas de configurar entradas digitais em Arduino:

Experimento 26 – Entrada com resistores pull-up

Material necessário:

  • Arduino Nano + cabo USB + computador
  • Um LED de qualquer cor
  • Resistor de 220 Ω
  • 2 chaves tácteis de pressão
  • Protoboard, fios e jumpers

 

Construa o circuito abaixo. Ele apenas acrescenta mais uma chave ao circuito anterior.

Usaremos um programa que depende dos dois estados (ligado e desligado) de cada chave para decidir quando acender o LED.

#define PINO_LIGAR   3
#define PINO_DESLIGAR 4
#define LED 8

void setup() {
    pinMode(LED, OUTPUT);
    pinMode(PINO_LIGAR, INPUT_PULLUP);
    pinMode(PINO_DESLIGAR, INPUT_PULLUP);
}

void loop() {
    int acender = digitalRead(PINO_LIGAR);
    int apagar = digitalRead(PINO_DESLIGAR);

    if(acender == LOW) {
        digitalWrite(LED, HIGH);
    }
    if(apagar == LOW) {
        digitalWrite(LED, LOW);
    }
}

O loop() é executado repetidas vezes e cada vez: 1) o estado de cada pino é lido, e 2) dois blocos condicionais if são executados. Se a condição testada for verdadeira, o conteúdo é executado. Se não for, o conteúdo é ignorado.

Os blocos condicionais apenas testam se cada botão está em estado LOW, se não estiver, eles são ignorados. Mas os botões raramente estão no estado LOW. Isto acontece apenas quando forem apertados. O estado normal de cada botão é HIGH, já que estão conectados via pull-up. Se por uma fração de segundo você apertar qualquer um dos botões, seu estado será momentaneamente LOW e o bloco será executado. O primeiro if acende o LED, o segundo if apaga. Enquanto nenhum botão está pressionado, o estado anterior é mantido.

O circuito, portanto, tem uma memória que representa o estado do último botão apertado no acendimento ou apagamento do LED. Funciona como um alternador de estado (faz o mesmo que o 555 bi-estável do capítulo anterior, mas sem precisar calcular capacitores nem resistores). Se você trocar a chave por um sensor que baixe a tensão no pino 3 a um nível abaixo de 3V, você pode fazer o LED acender com um evento externo, por exemplo, apagar ou acender uma luz, ou bater palmas. O botão em D4 seria usado apenas para apagar o LED. Isto é proposto nas alterações abaixo.

Alteração 26.1 – Substituindo uma chave por um sensor de luz

Material adicional:

  • Um fototransistor (TIL 78) ou LDR

Troque a chave em D3 por um LDR ou um fototransistor (esquema abaixo), que se comporta como uma chave fechada quando recebe luz. Um pulso curto de luz é suficiente para acender o LED.

Alteração 26.2 – Substituindo uma chave por um sensor de som

Material adicional:

  • 1 microfone de eletreto
  • 1 transistor BC549 ou equivalente
  • 1 capacitor de 1µF
  • 1 resistor de 2k2 Ω

O circuito sensor de som abaixo irá gerar pulsos altos e baixos. Um pulso que faça o transistor conduzir por um instante fará o LED acender. O microfone pode ser alimentado através da saída 5V.

Arduino 4: entrada digital

Em um circuito Arduino, chaves não são usadas para ligar ou desligar um componente diretamente (como em circuitos eletrônicos tradicionais) mas para fornecer um dado de entrada para o programa, que poderá usá-lo para tomar decisões (a decisão pode ser inclusive para ligar ou desligar o componente.) Portanto, uma chave deve ser ligada diretamente a um pino digital de entrada.

Não é preciso chamar a instrução pinMode() no setup para configurar entradas (se for usada, deve declarar a funcionalidade do pino como INPUT.) Nesse modo, quando a chave estiver fechada ela deverá fornecer ou 5V ou 0V para o pino. Quando aberta, o estado do pino é indefinido.

Experimento 25 – Reagindo ao acionamento de chaves liga-desliga

Material necessário:

  • Arduino Nano + cabo USB + computador
  • Um LED de qualquer cor
  • Resistor de 220 Ω
  • 1 chave táctil de pressão
  • Protoboard, fios e jumpers

Monte o circuito abaixo (é o mesmo circuito do experimento anterior, acrescentando a chave):

Ligamos uma chave de pressão (normalmente aberta) entre o pino 3 e GND. Quando ela não estiver pressionada, não haverá sinal algum no pino 3 (estado indefinido), mas quando ela estiver apertada, ela fará a conexão entre o pino D3 e GND e seu estado será LOW. Usamos uma expressão condicional para testar o estado do pino, com a seguinte regra: se o estado do pino 3 for LOW, o LED será aceso, caso controário (se for qualquer outro estado – indefinido ou HIGH), o LED será apagado:

#define CHAVE 3
#define LED   8

void setup() {
    pinMode(LED, OUTPUT);
}

void loop() {
    int estado = digitalRead(CHAVE);
    delay(10); // espera 10 milissegundos antes de testar
    if(estado == LOW) {
        digitalWrite(LED, HIGH);
    } else {
        digitalWrite(LED, LOW);
    }
}

O loop repete continuamente lendo o estado da chave e usando o estado lido para comparar com o valor LOW (0V).

Se a chave estiver aberta, o estado não é LOW. É indefinido, portanto, o conteúdo do bloco if é ignorado, mas o bloco else é executado. A instrução dentro do else mantém o LED apagado, já que fornece 0V (LOW) para a saída 8.

Se a chave estiver apertada, ela faz uma ligação direta entre o pino 3 e GND, fazendo-o ter o estado LOW. Neste caso, a instrução executada muda o estado do pino 8 para HIGH, e o LED acende. Soltando o botão, ele volta ao estado indefinido, e em pouco mais de 10 milissegundos, o estado do pino 3 será testado de novo, desta vez apagando o LED. Portanto, o LED só acende enquanto o botão estiver apertado.

Entrada digital

A instrução digitalRead(número-do-pino) serve para ler o nível lógico de um pino de entrada. O valor pode ser ALTO (HIGH) ou BAIXO (LOW). Normalmente HIGH corresponde a 5V e LOW corresponde a 0V (mas na prática o Arduino irá considerar como HIGH qualquer valor de tensão de 3 volts ou mais. Valores abaixo de 3V serão considerados nível lógico LOW.

HIGH e LOW são variáveis que guardam valores inteiros (respectivamente 1 e 0), portanto o valor lido por digitalRead() deve ser armazenado em uma variável declarada como int:

int valor = digitalRead(3);

Os pinos digitais são inicialmente configurados como entradas, portanto não é necessário usar pinMode() para declará-los como tal. Se for usada deve conter a opção INPUT:

pinMode(3, INPUT);     // pino 3 é uma entrada

Lógica condicional e bloco if-else

If” significa “se”. O bloco condicional if(condição) {} recebe entre parênteses uma expressão lógica booleana, e entre as chaves uma lista de instruções que devem ser executadas somente se a expressão for verdadeira.

Expressões lógicas podem ser igualdade (operador ==), diferença (operador !=) e desigualdade (operadores >, <, >= e <=).

Observe que para testar a igualdade usa-se um duplo igual ==, já que o sinal de igual isolado é usado como operador de atribuição.

Blocos if() devem ser usados dentro de blocos loop() ou setup(), portanto é uma boa prática, ao escrever programas, endentar o conteúdo do bloco para facilitar a leitura do código (ex: digitar quatro espaços antes, para cada novo nível de chaves {…}).

Por exemplo, as instruções que começam com “int” e “if” abaixo estão dentro de loop() e endentadas 4 espaços. A instrução “digitalWrite” está dentro de if, que está dentro de loop, e endentada 8 espaços:

void loop() {
    int estado = digitalRead(3);
    if (estado == HIGH) {         // testa se estado é 5V
        digitalWrite(8, HIGH);   // “acende” componente que está no pino 8
    }
}

Um bloco if() pode ser seguido por um bloco else {}, que significa “caso contrário” e executa quando a condição não for verdadeira:

if (estado == HIGH) {         // somente se o valor de estado for 5V
    digitalWrite(8, HIGH);     // “acende” componente que está no pino 8
} else {                     // caso contrário
    digitalWrite(10, HIGH);   // acende o componente do pino 10
}

Alteração 25.1 – Invertendo o estado de acionamento

Altere o programa do último experimento para que ele acione o LED quando:

  • O estado do pino não for LOW (requer apenas alteração no código).
  • O estado do pino for HIGH (que alteração precisará ser feita no circuito?)

Arduino 3: Introdução à programação

Para fazer qualquer circuito com o Arduino, é preciso primeiro programá-lo. Este é o objetivo desta seção onde introduziremos, de forma prática, sua linguagem de programação.

Para que esta introdução seja curta, objetiva e mais simples possível, omitiremos detalhes e abordaremos conceitos de maneira incompleta e às vezes até imprecisa, para focar apenas no essencial necessário para entender os programas que serão construídos.

Estrutura básica de um sketch

Um programa Arduino é chamado de Sketch. Ele consiste de uma sequência de instruções escritas em uma linguagem chamada Processing. Para ser usado o programa depois precisa ser compilado (traduzido para linguagem de máquina) e transferido para o Arduino. Um sketch é também um arquivo de texto que pode ser gravado no computador, e possui a extensão .ino. O menor sketch contém no mínimo a seguinte estrutura (que não faz nada):

void setup() {

}

void loop() {

}

Se você está usando um Arduino pela primeira vez, e não sabe que programa está em sua memória, é uma boa prática transferir o programa acima para ele. Isto garante que ele não executará nenhuma tarefa que possa danificá-lo.

A estrutura acima possui dois blocos, que podemos chamar de bloco setup() e bloco loop(). A instrução void setup() define o bloco setup(), e a instrução void loop() define o bloco loop(). Essas instruções são chamadas automaticamente quando o Arduino estiver executando, e todas as instruções que forem digitadas entre as chaves { } serão executadas.

No programa acima, as chaves estão vazias, portanto quando o Arduino chamar setup() e loop(), ele não vai fazer nada.

Os blocos setup() e loop() funcionam de forma distinta. O bloco setup() é chamado uma vez só, portanto ele deve conter instruções que serão executadas uma única vez. Já o bloco loop() é chamado eternamente, e deve conter instruções que repetem para sempre (até que o Arduino seja desligado ou reiniciado).

Normalmente dentro de setup() serão colocadas instruções de configuração (por exemplo, especificar a função que um determinado pino irá assumir – se entrada ou saída). Em loop() ficam as instruções que efetivamente programam o Arduino, por exemplo, mandar nível lógico alto (5V) para pino 4, esperar meio segundo, e depois mandar nível lógico baixo (0V), e repetir isto sem parar.

Antes de programar qualquer coisa, vamos testar a transferência de programas para o Arduino.

Digite o programa acima. Para transferir para o Arduino, clique no ícone   (ou selecione o menu Sketch/Upload). Se houver erro, ele aparecerá na caixinha de status na parte inferior do programa, e a transferência não acontecerá. Um erro comum é esquecer de selecionar o modelo de Arduino e sua porta de comunicação (veja a seção 5.5.3). Verifique também se não esqueceu de fechar alguma chave, ou se digitou algo diferente do que foi listado. Os comandos precisam ser escritos exatamente como acima (letras maiúsculas e minúsculas são consideradas diferentes na linguagem do Arduino (ex: escrever LOOP() ou Loop() é um erro).

Sintaxe das instruções

As instruções usadas dentro dos blocos setup() e loop() têm uma sintaxe bem definida. Existem vários tipos. Usaremos principalmente instruções de uma linha. Essas instruções sempre terminam em ponto-e-vírgula e podem ser classificadas como comandos (que mandam o Arduino fazer alguma coisa) ou expressões (que calculam valores, guardam dados, etc.).

Comandos

Comandos são formalmente chamados de funções ou métodos. Eles fazem parte de uma biblioteca que define seus nomes e parâmetros. Os parâmetros são valores passados entre parênteses, às vezes entre aspas, e separados por vírgulas depois do nome da função. Há comandos que não têm parâmetros (apenas os parênteses vazios). Por exemplo, o comando:

delay(500);

manda o Arduino esperar meio segundo (500 milissegundos). Há apenas um parâmetro que é o número de milissegundos a esperar. Este outro comando:

analogWrite(9, 128);

manda o Arduino produzir no seu pino digital 9 um sinal analógico de nível 128 (o nível varia de 0 a 255, e corresponde a valores médios (simulados) de 0 a 5V produzidos com PWM). A instrução, portanto, produz um pulso ligado 50% do tempo que resulta em um valor médio de 2,5V no pino 9.

Observe que as instruções terminam sempre em ponto-e-vírgula. Observe também que o “W” em analogWrite é maiúsculo (e assim deve ser escrito).

Expressões e variáveis

Pode-se escrever um programa apenas com comandos, mas alguns comandos retornam resultados que precisam ser processados. O processamento é feito através de expressões. Existem vários tipos de expressões: aritméticas, lógicas, etc. Expressões frequentemente são formadas por operações. Por exemplo, esta é uma expressão contendo uma operação de soma e uma operação de atribuição:

numero = 3 + 4;

O Arduino irá somar 3 com 4 e guardar o resultado na variável numero. O sinal de = é usado para fazer uma operação de atribuição, isto é, copiar um valor (o resultado da expressão) para uma área da memória associada à variável. Variáveis são palavras usadas para identificar, guardar e referenciar dados. Elas só guardam dados de um tipo de dados específico. A variável acima precisa declarar o tipo de dados que pode armazenar, antes que seja usada. A declaração é também uma expressão. Então algum lugar antes da linha acima, deve haver algo como:

int numero;

declarando que a variável numero é do tipo int. A palavra int significa inteiro, e é usada para declarar variáveis que só aceitam valores inteiros. Não seria possível, por exemplo, guardar um 3.14 na variável numero. Para isto ela teria que ser declarada como float, que é o nome usado para variáveis com parte decimal. Observe que a declaração da variável também termina em ponto-e-vírgula.

Nos programas em Arduino que faremos nesta introdução, declararemos apenas variáveis do tipo int e float. Muitas vezes, a declaração e a atribuição ocorrem na mesma linha, por exemplo:

int pino = 6;
float valor = 3.14;

Depois de declarada uma variável, provavelmente vamos querer usá-la depois. O uso de uma variável pode ser, por exemplo, a inclusão do valor que ela contém em alguma outra expressão ou comando:

float raio = 9.5;
float area = valor * raio * raio;
int tempo = 1000;
delay( tempo );

A última linha acima é um comando que está usando a variável tempo, que contém o valor inteiro 1000, que é passado como parâmetro da função delay().

Alguns comandos produzem um valor, que geralmente é resultado do processamento executado por eles. Esse valor geralmente é guardado em uma variável. Por exemplo:

int duracao = analogRead(2);

O comando analogRead(2) é executado, e seu resultado é copiado (via operação de atribuição) para a variável duracao. Depois, este valor pode ser usado em outro comando, por exemplo:

delay(duracao);

A instrução analogRead(2) produz um valor (entre 0 e 1023) resultante da leitura do nível da tensão no pino A2. Por exemplo, se houver um potenciômetro com os pinos externos ligados entre 0 e 5V, e o pino do meio estiver ligado no A2 do Arduino, e este potenciômetro estiver com o seletor posicionado exatamente no meio, o valor recebido por analogRead(2) será 1024/2 ou 512.

Nomes de variáveis

Variáveis não podem ter qualquer nome. Não crie nomes com acentos, hífens, pontos. O ideal é usar nomes curtos e explicativos. Se você quer criar uma variável com mais de uma palavra, você pode distinguir as palavras usando maiúsculas, por exemplo:

int numeroDoPino = 6;

ou sublinhados:

int NUMERO_DO_PINO = 6;

Variáveis também não podem usar certas palavras, que são reservadas. Exemplos são as palavras int e float, que têm significado especial para o Arduino. É fácil saber quando uma palavra é reservada, pois ela aparece com uma cor diferente (azulada) no IDE.

Comentários

Nem tudo o que está escrito em um sketch é enviado para o Arduino. Para que os programas sejam mais fáceis de entender pelos humanos que irão lê-lo, é comum que tenham comentários. Os comentários são texto ignorado pelo compilador (mecanismo da IDE que traduz o programa para linguagem de máquina) e devem ser usados para explicar trechos do programa, ou incluir instruções de como usá-los. Há dois tipos: comentários de linha e comentários de bloco.

Comentários de linha geralmente aparecem antes de instruções, ou logo depois do ponto-e-vírgula, na mesma linha que a instrução. Tudo o que aparece depois do // é considerado um comentário. Por exemplo:

int PINO_DO_LED = 13;   // este é o pino do LED interno

Outra forma de escrever comentários no programa é usar comentários de bloco, que consiste em incluir o texto de uma ou mais linhas entre /* e */. Use esse tipo de comentário se o que você pretende escrever tem muitas linhas:

/*
Este programa faz um LED piscar.
Ligue o Anodo do LED no pino 6.
Ligue o Catodo em um resistor de 470 ohms, ligado a GND.
*/
void setup() { ... }

Comentários também são usados para temporariamente ignorar um trecho de código (que você não quer que execute, mas não quer apagar do sketch):

void loop() {
    // delay(500);
    delay(1000);   // a linha anterior será ignorada
}

Isto é suficiente como uma introdução à linguagem do Arduino. Com o que vimos até aqui já é possível fazer um primeiro programa para piscar um LED.

Experimento 24 – Piscando um LED

Material necessário:

  • Arduino Nano + cabo USB + computador
  • Um LED de qualquer cor
  • Resistor de 220 Ω
  • Protoboard, fios e jumpers

Para piscar um LED, é preciso liga-lo em uma saída que alterne entre dois níveis lógicos: alto e baixo, com um intervalo entre eles. Como precisamos de apenas dois estados, podemos usar um pino de saída digital. Há 14 deles. Podemos usar qualquer um. Vamos escolher o pino digital 8, identificado na placa do Arduino Nano com a indicação D8.

O nível lógico ALTO no Arduino é sempre 5 volts. Precisamos de um resistor para limitar a corrente do LED e temos informações suficientes para calcular seu valor. Se for um LED vermelho, com 2V de queda de tensão:

R = (5V – 2V) / 0,02 A = 150 ohms.

Não temos 150 ohms no kit, mas podemos usar 220 ohms que consome um pouco menos corrente, ou até mesmo arriscar um valor menor (100 ohms) já que ele não vai ficar ligado muito tempo. Podemos também usar um resistor de 100 ohms e trocar o LED vermelho por um de 3V (azul, rosa ou branco).

Antes de montar qualquer circuito, sempre desligue o Arduino do computador (desconecte o cabo USB). Monte o circuito abaixo, verifique as conexões, e depois ligue novamente o Arduino ao computador.

A porta USB é quem irá fornecer corrente para o circuito. Se houver um problema no seu circuito e ele tentar puxar corrente demais da porta USB, o computador desligará o acesso e desligará o Arduino (você terá que remover o cabo e reinserir novamente, depois de corrigir o problema).

O resistor ligado ao catodo do LED pode ser conectado a qualquer um dos dois pinos GND disponíveis no Arduino Nano (há um de cada lado). Internamente eles estão ligados entre si.

Agora vamos escrever um programa para piscar o LED. Abra um novo sketch (ícone ou Menu File/New) e preencha os blocos setup() e loop() com as seguintes instruções:

void setup()
    pinMode(8, OUTPUT);     // declara pino 8 como uma saída
}
void loop() {
    digitalWrite(8, HIGH);
    delay(500);
    digitalWrite(8, LOW);
    delay(500);
}

Clique no ícone para transferir o programa para o Arduino. Em alguns segundos o LED deverá começar a piscar ficando meio segundo aceso e meio segundo apagado. Experimente mudar o valor de delay() para que ele pisque mais rápido, ou que fique mais tempo aceso que apagado.

Explicaremos os comandos usados no programa nas seções a seguir.

Pinos digitais e estados HIGH e LOW

Um pino digital permite a entrada e saída de valores digitais correspondentes aos níveis lógicos ligado (5V), ou ALTO, e desligado (0V), ou BAIXO. Esses dois estados são representados na linguagem do Arduino pelas palavras reservadas HIGH (sempre em maiúsculas) e LOW (idem). No contexto do circuito, correspondem aos valores de tensão 5V e GND (0V).

(Na verdade HIGH e LOW são variáveis pré-definidas que, no contexto do programa, contém os números inteiros 1 e 0, respectivamente.)

Um componente de dois terminais ligado a um pino de saída deve ter o seu outro terminal ligado a uma referência de tensão: o pino GND (negativo) ou o pino 5V (positivo). Haverá corrente se houver diferença de potencial entre o pino de saída e a referência. Isto significa que, para que haja corrente fluindo por um componente, se ele estiver conectado a um pino que é acionado pelo valor HIGH, o outro terminal deve estar conectado a GND (é assim que o LED está configurado no nosso exemplo). Se o componente for acionado pelo valor LOW, o outro terminal deve estar conectado a 5V.

É importante observar a polaridade do componente e posicioná-lo de acordo, e também limitar a corrente. Um pino e saída do Arduino não suporta mais que 40 mA. Ligar um pino de saída diretamente a 5V ou GND sem resistor limitador gera uma corrente muito alta que poderá queimá-lo quando houver uma diferença de potencial no pino.

A instrução pinMode()

Normalmente os pinos operam como entrada. Para usar um pino como saída digital é preciso executar uma instrução para declará-lo explicitamente. Isto normalmente é feito dentro do bloco setup() através da instrução pinMode(número-do-pino, função) (observe o “M” maiúsculo da instrução). Os dois parâmetros informam respectivamente o número do pino e o tipo de função que ele vai exercer (OUTPUT, para a função saída):

void setup()
    pinMode(8, OUTPUT);     // pino 8* é uma saída
}

* Na placa do Arduino Nano os pinos digitais são identificados pelo prefixo D (D0, D1, D2, D3, etc.) e os analógicos pelo prefixo A (A0, A1, A2, A3, etc.) No programa, apenas os números dos pinos digitais são usados (ex: 0, 1, 2, 3, etc.) Os pinos analógicos podem ser identificados com ou sem prefixo nos comandos que aceitam entradas analógicas.

Saída digital

Para produzir uma saída digital em níveis lógicos (HIGH/5V ou LOW/0V, sem valores intermediários) usa-se a instrução digitalWrite(número-do-pino, nível-lógico), dentro de setup() (para rodar apenas uma vez) ou loop() (para rodar repetidas vezes). O número do pino precisa ter sido previamente declarado como OUTPUT através da instrução pinMode().

Por exemplo:

digitalWrite(8, HIGH); // aplica o valor HIGH (5 volts) no pino 8

O comando acima transfere 5V (HIGH) para a saída digital D8. Se no pino D8 houver um LED (alimentado entre o pino 8 e GND), ele irá receber 5V, e acender.

Para o LED piscar é preciso fazer o pino 8 ter valor HIGH, depois esperar algum tempo (mantendo o pino neste estado) e em seguida fazer o pino 8 ter valor LOW, esperar mais algum tempo (em que o LED ficará apagado) e repetir a sequência. A repetição acontece automaticamente para instruções digitadas dentro do bloco loop(), portanto para piscar o LED serão necessárias apenas quatro instruções:

void loop() {
    digitalWrite(8, HIGH);        // aplica 5V no LED+resistor
    delay(500);           // mantém em 5V por 0,5 segundos
    digitalWrite(8, LOW);   // aplica 0V no LED+resistor
    delay(500);             // mantém em 0V por 0,5 segundos
}
// repete tudo ad infinitum

Variáveis globais e #define

Quando se tem um programa que usa apenas um ou dois pinos, é fácil lembrar o que está conectado a cada um, mas se muitos pinos estiverem sendo usados o programa pode tornar-se difícil de ler e entender. E se for necessário mudar um componente para outro pino? O número teria que ser alterado em todos os lugares onde foi digitado. Uma solução para este problema é declarar uma variável para identificar o pino:

void loop() {
    int PINO_DO_LED = 8;    // Declarando variável PINO_DO_LED contendo 8
    digitalWrite(PINO_DO_LED, HIGH); // o primeiro parâmetro recebe 8
    delay(500);
    digitalWrite(PINO_DO_LED, LOW);
    delay(500);
}

Variáveis globais

Uma variável declarada dentro das chaves { … } de um bloco (ex: setup() ou loop()) é acessível apenas dentro daquele mesmo bloco. Quando o bloco terminar, ela não poderá mais ser usada (causará erro no programa). Mas às vezes criamos uma variável exatamente para poder usá-la em blocos diferentes. Por isto é comum que a declaração de algumas variáveis ocorra fora dos blocos loop() e setup(). Variáveis declaradas fora dos blocos são chamadas de variáveis globais, porque elas podem ser usadas em qualquer um dos dois blocos.

No exemplo abaixo, criamos uma variável global para guardar o pino do LED:.

int LED = 8; // declarada fora de setup() ou loop() – é global

void setup()
    pinMode(LED, OUTPUT);    // reconhecida dentro de setup() – recebe 8
}

void loop() {
    digitalWrite(LED, HIGH); // reconhecida dentro de loop() – recebe 8
    delay(500);
    digitalWrite(LED, LOW);
    delay(500);
}

Outra forma de declarar uma variável global para um pino

Você encontrará alguns programas que declaram variáveis usando o comando #define antes dos blocos setup() e loop(). Por exemplo:

#define LED 8

A sintaxe é diferente de uma declaração de variável comum. Não existe o sinal de igual (=) e nem ponto-e-vírgula (não pode ter ponto-e-vírgula). Na prática o resultado é o mesmo. Usar esta forma ou a outra é uma questão de estilo. Não vai alterar o funcionamento do programa. Mesmo que você escolha usar apenas a outra forma, é importante reconhecer essa sintaxe, pois muitos programadores preferem usar #define em vez de declarar variáveis globais.

As declarações #define geralmente aparecem no início do programa. Elas não podem aparecer dentro dos blocos setup() ou loop().

Alteração 24.1 – Usando variáveis

Altere o programa do último experimento substituindo o número do pino por uma variável, e faça o upload novamente. Veja que o funcionamento não muda. Agora mude a posição do LED para o pino 7 no protoboard. Ele não pisca mais, mas você pode abrir o programa, fazer apenas uma alteração (mudando a variável LED para 7) e transferi-lo novamente, que ele voltará a funcionar.

Arduino 2: Configuração do Arduino Nano

O Arduino que usaremos na oficina é um Arduino Nano. Tem dimensões de 43 x 15 mm. Ele possui uma entrada USB que permite a ligação direta a um computador (não precisa de adaptador), e que também fornece alimentação de 5V enquanto estiver conectado. Depois de programado e desconectado do computador, ele pode ser alimentado de forma independente por 7 a 12V aplicados nos pinos VIN (ligado ao positivo da bateria ou fonte) e GND (ligado ao negativo).

O Arduino Nano também possui saídas de tensão reguladas em 3,3 V (Pino 3V3) e 5V (Pino 5V). Os pinos A0 a A7 são de entrada analógica (recebem valores entre 0 e 5V), e D0 a D13 suportam entrada digital (reconhecem dois valores: 0V – nível lógico BAIXO ou 5V – nível lógico ALTO). A saída analógica é simulada via PWM apenas através dos pinos digitais D3, D5, D6, D9, D10 e D11. Os outros pinos digitais, e também os pinos A0 a A5, podem operar como saída digital. O diagrama abaixo ilustra a pinagem do Arduino Nano:

As especificações de corrente e tensão referem-se ao clone chinês CH340 do Arduino Nano que está incluído no kit, e não ao Arduino Nano original italiano (que são um pouco diferentes).

Algumas observações e cuidados importantes:

  • Os pinos do Arduino suportam no máximo 40mA (ligar em um circuito que deixa passar mais corrente pode queimar o pino). É necessário calcular resistores para limitar a corrente.
  • O Arduino inteiro fornece no máximo 200mA. Mas é possível controlar circuitos que consomem bem mais corrente, desde os sinais enviados e recebidos pelos pinos sejam intermediados por circuitos que reduzam as correntes e tensões a níveis suportados. Isto pode ser feito com resistores, capacitores, transistores, relés e outros dispositivos.
  • Também é necessário ter cuidado para não curto-circuitar as saídas (5V ou 3V3 ligadas diretamente em GND). Os pinos analógicos e digitais podem ser ligados diretamente em 5V ou 0V somente se forem usados como entradas. Esses valores são tratados como informação (nível lógico ALTO e BAIXO) pelo Arduino. Para usá-los como saídas, é necessário configurar essa funcionalidade na programação, e ter o mesmo cuidado que as saídas 5V e 3V3 (não ligar diretamente em GND), além de usar resistores para manter o fluxo de corrente dentro do limite.
  • O pino AREF é usado para ajustar a tensão de referência usada para os pinos analógicos. Ela está internamente conectada ao pino 5V, mas pode ser desligada via programação. Ligar uma tensão qualquer neste pino sem primeiro fazer essa alteração via código irá queimar o regulador de tensão (e provavelmente a entrada USB).

Um programa escrito para um tipo de Arduino pode ser usado em outro tipo de Arduino. Pode-se aproveitar programas prontos e fazer pequenas adaptações sem que seja necessário entender todo o código. Portanto, sabendo o mínimo da programação do Arduino, você pode baixar programas da Internet e adaptar para seus circuitos. É preciso garantir que os números de pinos, declarados no código dos programas, e os pinos reais, usados no circuito estejam de acordo. Em geral qualquer pino digital ou analógico pode ser usado. Eles podem até ser reprogramados. Alguns pinos têm capacidades especiais. Por exemplo, os pinos digitais 3, 5, 6, 9, 10 e 11, no Arduino Nano, permitem gerar saída analógica usando PWM.

Não se preocupe se você não entendeu tudo. São muitos conceitos e é sempre mais fácil entender com um ou mais exemplos. Nas próximas seções mostraremos como instalar e configurar o Arduino, e depois como usá-lo através de vários experimentos. Depois que você fizer os experimentos, releia esta seção. Vários conceitos irão ficar mais claros.

Preparação e teste do Arduino

Como vamos construir circuitos, e o Arduino Nano não possui soquetes onde podemos inserir terminais de componentes, precisamos usar o protoboard. Encaixe o Arduino com cuidado ocupando a parte central, de forma que possamos ter acesso a todos os seus pinos através dos pinos laterais. Da forma mostrada abaixo, cada pino terá dois a três furos.

O protoboard deve estar livre de outros circuitos (principalmente, não deve haver nenhuma fonte de energia conectado a ele).

Depois de encaixado o Arduino, encaixe uma das pontas do cabo USB no Arduino, e a outra em alguma saída USB do seu computador. O LED PWR do Arduino deverá acender, indicando que ele está sendo alimentado pela porta USB. Para haver comunicação, no entanto, é preciso instalar o driver.

Instalação do ambiente de desenvolvimento

Para habilitar um computador para programar o Arduino Nano do kit são necessárias duas etapas:

  1. Instalar o driver (programa que permite a comunicação com o Arduino via porta USB do computador) do adaptador USB-Serial (embutido no Arduino).
  2. Instalar o programa com o ambiente de programação (Arduino IDE).

A IDE (aplicação com ambiente gráfico para programação) é distribuída pelo site oficial do Arduino (arduino.cc) e existe para Mac, Windows e Linux. Roda de maneira praticamente idêntica nas três plataformas.

O driver é mais complicado de instalar, e pode variar dependendo do Arduino usado, se é um clone ou se é um autêntico italiano. O Arduino original (italiano) não requer a instalação de drivers no Mac, mas a instalação ainda pode ser necessária em algumas versões de Windows.

Instalação do driver

O Arduino Nano incluído no kit é um clone e usa um adaptador USB-Serial chinês (chip CH341). Para que ele seja reconhecido pelo computador, seja Mac, PC ou Linux, ele precisa ter o driver instalado antes. O driver é um programa de instalação que deve ser baixado do site do fabricante e executado. Ele não faz nada além disso. A instalação termina depois que o computador for reiniciado. Veja as instruções abaixo. Elas podem ser diferentes dependendo do sistema que você estiver usando.

Windows

Se você usa Windows 10 baixe o arquivo EXE disponível em

http://www.wch.cn/download/CH341SER_EXE.html

(clique no botão de Download), execute-o. Você deve ter as permissões para executar este programa no computador, pois ele vai gravar arquivos do sistema. Siga o passo-a-passo (em inglês). Depois é necessário reiniciar o computador para completar a instalação. Quando terminar e reiniciar, pule para a seção seguinte (IDE) para instalar o ambiente de programação.

Mac

Se usa Mac OS Sierra (10.12), baixe o arquivo ZIP em

http://www.wch.cn/download/CH341SER_MAC_ZIP.html

(clique no botão de Download) e abra o ZIP. Dentro dele há um arquivo CH34x_Install_V1.4.pkg. Execute esse arquivo e siga as instruções (em inglês). Depois é necessário reiniciar o computador para completar a instalação. Quando reiniciar, pule para a seção seguinte (IDE) para instalar o ambiente de programação.

Linux

E se você usa Linux baixe o arquivo localizado em

http://www.wch.cn/download/CH341SER_LINUX_ZIP.html

(clique no botão de Download). Abra o ZIP em uma pasta. Abra uma janela do terminal e execute as linhas abaixo:

sudo make
sudo make load

Instalação do ambiente de programação (IDE)

A programação do Arduino é feito na linguagem Processing, que é baseada na linguagem C e similar a linguagens de programação populares como C# e Java. Embora possam ser escritos programas bastante complexos usando essa linguagem, é possível fazer muita coisa escrevendo programas bem simples e fáceis de entender mesmo para quem é leigo em programação. Aprendendo o mínimo, você conseguirá baixar programas disponíveis na Internet e adaptar para rodar com seus circuitos. Para isto, precisamos instalar o ambiente de desenvolvimento integrado (IDE – Integrated Development Environment) do Arduino. Baixe o programa de instalação para o seu sistema operacional (Windows, Mac ou Linux) na página

https://www.arduino.cc/en/Main/Software

Execute o instalador e siga o passo-a-passo. Depois rode o programa. Ele deverá abrir a janela abaixo:

Comunicação do Arduino com o computador

Depois de instalados o driver e o IDE, é preciso ainda selecionar a placa usada e a identificar a porta de comunicação onde ela está conectada. Isto só precisa ser feito uma vez para cada placa diferente que você usar, mas requer que o Arduino esteja conectado. Portanto, se você ainda não conectou o Arduino a uma porta USB do seu computador, faça isto agora.

Selecione no menu Ferramentas (Tools), na opção Placa (Board). Na lista há várias placas. Selecione Arduino Nano.

Depois selecione a porta de comunicação. No Windows deve ser algo como COM4. No Linux e Mac, um caminho que inicia com /dev/cu.wchusbserial (ex: /dev/cu.wchusbserial123456).

Se você usar outro tipo de Arduino posteriormente, terá que modificar esses parâmetros ou a transferência do programa não será possível (o programa apresentará mensagens de erro informando isto). Alguns clones de Arduino são identificados diferentemente (ex: alguns clones chineses de LilyPad são identificados como Arduino Uno) e outros requerem a instalação de bibliotecas externas (que podem ser baixadas) para funcionar.

No próximo post iniciaremos a programação do Arduino e faremos um primeiro circuito.

Arduino 1: Introdução

Arduino é o nome de um projeto que consiste na especificação de uma linguagem de programação e de um circuito baseados em um microcontrolador, como uma plataforma eletrônica para facilitar a construção de dispositivos interativos que detectam e controlam objetos no mundo físico. É um projeto de fonte aberta: a especificação do hardware e software são livres, permitindo que qualquer um fabrique e venda placas Arduino sem pagar royalties a ninguém. A plataforma original foi criada em Ivrea, na Itália, por estudantes italianos e colombianos, com a intenção de facilitar o uso da eletrônica por artistas e designers.

Projetos artísticos com Arduino

Arduino é ideal para projetos artísticos, pois facilita muito o projeto e construção de circuitos eletrônicos, eliminando grande parte da sua complexidade. Muitos projetos que normalmente requerem o cálculo de circuitos elaborados com resistores, capacitores e transistores para usar um sensor, podem ser construídos usando apenas este sensor e um Arduino. É necessário, no entanto, programar o comportamento desejado em uma linguagem de computador.

Arduinos são usados em inúmeros projetos, dos mais simples aos mais complexos. Luzes que piscam ao ritmo da música, alarmes que disparam quando percebem movimento, robôs que interagem com o ambiente e controlam máquinas pela Internet, roupas, óculos e bolsas multimídia, instalações visuais, sensoriais, cinéticas e sonoras, sistemas de automação residencial, sistemas de irrigação, sistemas de realidade virtual, próteses controladas por voz, jogos, drones, controladores MIDI, impressoras 3D são alguns exemplos de projetos já criados com Arduino.

Nesta seção faremos uma breve introdução ao Arduino através de alguns circuitos e programas simples que você pode usar como base para projetos mais sofisticados. No final da apostila estão listados alguns sites com tutoriais mais detalhados sobre a linguagem de programação e a construção de circuitos com Arduino.

Arquitetura do Arduino

O circuito do Arduino é composto de um microcontrolador programável montado em uma placa, onde é configurado para operar e oferecer acesso seguro aos seus pinos de entrada e saída. Um microcontrolador é como um mini-computador. Ele tem memória, uma unidade central de processamento (CPU), entradas e saídas. Os programas gravados na memória de um microcontrolador controlam os sinais (correntes e tensões) enviadas e recebidas em seus pinos de entrada e saída, permitindo receber sinais de sensores externos e controlar dispositivos.

As entradas do Arduino recebem dados, que podem ser pulsos, tensões e outros sinais elétricos que ele interpreta como dados digitais (dois estados lógicos: ligado/ALTO ou desligado/BAIXO) ou analógicos (valores que variam). Os geradores desses sinais podem ser chaves, potenciômetros, sensores de luz, som e temperatura, outros circuitos, dispositivos conectados a redes, etc.

As saídas também produzem pulsos, tensões e sinais analógicos ou digitais, que podem ser usadas para diversas tarefas, como acender um LED, controlar um motor, ligar ou desligar um circuito, controlar um dispositivo externo, enviar um email.

O microcontrolador processa os dados de entrada para gerar os dados de saída. Todo o processamento é feito via software, ou seja, através de uma linguagem de programação.

Um programa usa instruções para ler o estado (nível de tensão, nível lógico alto ou baixo) em pinos de entrada, e produzir saídas (tensão, nível lógico alto ou baixo) nos pinos de saída, que poderão ligar, desligar ou controlar componentes e dispositivos. O programa é um arquivo de texto digitado em um computador, em seguida traduzido para linguagem de máquina e depois transferido para o microcontrolador (através de um circuito de comunicação que controla o acesso a pinos de comunicação serial), onde será gravado na memória do chip.

Uma vez gravado o programa, o microcontrolador pode ser desconectado do computador e usado em outro circuito para usar seus pinos de entrada/saída, ser alimentado por baterias, e funcionar de forma independente.

O microcontrolador usado pelo Arduino é um circuito integrado pertencente à família AVR. Microcontroladores AVR são populares em drones e impressoras 3D. Existem vários diferentes tipos, com diferentes capacidades de processamento e memória. Nos Arduinos, os mais populares são os ATMega e ATTiny. Eles têm diferentes formatos e tamanhos. A ilustração abaixo contém três circuitos integrados AVR usados em Arduinos (ATMega328 SMD, ATMega168, ATTiny85):

Um circuito mínimo do Arduino é simples e pode ser montado com um ATMega e meio-protoboard. Basicamente é um circuito que serve para alimentar o circuito integrado (pinos 7 e 8) e gerar os pulsos de relógio que o microprocessador precisa para operar. O ATMega328 do esquema abaixo usa um oscilador de cristal de quartzo nos pinos 9 e 10 para gerar 16 milhões de pulsos por segundo (16 mega Hertz). Este microcontrolador possui 14 pinos digitais (0 a 13) e seis analógicos (A0 a A6) que podem ser usados tanto como entrada ou saída (a finalidade é determinada via software).

O ATMega precisa ser alimentado por 5V. O circuito acima usa um regulador de tensão L7805 que permite alimentar o circuito com 7 a 35V, garantindo que apenas 5V seja enviado ao ATMega. O desenho abaixo ilustra um Arduino montado em protoboard. É igual ao esquema acima, mas acrescenta um LED entre 5V e GND que acende quando o Arduino estiver sendo alimentado.

O circuito acima é apenas uma plataforma básica para operar o Arduino. Ele não faz nada. Para isto é preciso que tenha na memória um programa contendo instruções dizendo o que deve fazer, e sejam conectados sensores e/ou dispositivos a serem controlados aos seus pinos de entrada e saída.

A transferência do programa para a memória do ATMega é feita através dos pinos RX0 (entrada) e TX1 (saída). Para realizar essa transferência a partir de um computador é preciso conectar esses (e alguns outros) pinos a um circuito adaptador USB-Serial. Este circuito pode ser comprado separadamente como uma pequena placa, e às vezes já vem embutido em alguns cabos adaptadores. O diagrama abaixo mostra um circuito de Arduino mínimo conectado a uma pequena placa adaptadora USB-Serial. Através da placa ele poderá ser conectado a um computador, que também fornecerá a alimentação de 5V):

Construir um Arduino desta forma é bom como exercício didático para entender como funciona, mas normalmente usamos placas prontas, que já contém um adaptador USB embutido e regulação de tensão (com saídas fixas de 3,3V e 5V), permitindo alimentar o Arduino com tensões variáveis (de 1,8 até 20V, dependendo do modelo). Essas placas vêm em vários tamanhos, são mais práticas, fáceis de usar, e às vezes até mais baratas que montar um circuito Arduino como mostrado acima.

Placas Arduino

Existem dezenas de diferentes tipos de placas que podem ser chamadas de “Arduino”. Todas, sejam as originais italianas ou clones, são baseadas nas famílias de chips AVR ATMega/ATTiny ou similar, e rodam programas escritos para a plataforma Arduino.

O Arduino Uno é um dos mais populares, e ideal para fazer protótipos, experimentar e programar. O Arduino Mega possui mais pinos, maior capacidade de processamento e memória e é indicado para projetos maiores (ex: impressoras 3D). Existem várias placas minúsculas como o Arduino Pro Mini, o DigiSpark ATTiny, ou o Arduino Nano (incluído no kit). Algumas não tem entrada USB (para economizar espaço e energia) e precisam de um adaptador USB-Serial para que sejam programadas.

O Arduino LilyPad é a principal placa usada em eletrônica para vestir (wearables). Nessa linha existem várias placas, a maioria em formato circular com pinos em forma de ilhas que podem ser amarradas com linha de costura condutiva, e costuradas em tecido. Exemplos incluem Arduino Gemma, AdaFruit Flora, Digispark LilyTiny.

No próximo post mostraremos como configurar o Arduino para permitir a sua programação através de um computador.

Circuitos integrados 10: usando um display de 7 segmentos

Um decodificador é um circuito que adapta dados de entrada codificados para uma saída esperada por um dispositivo. A codificação pode ser uma sequência de pulsos. Assim como o 4017, o 4026 também sabe contar pulsos, mas em vez de ligar uma dentre 10 saídas, ele liga duas a sete saídas de uma vez. Essas sete saídas correspondem aos LEDs de um display de sete segmentos, que pode ser usado para representar dígitos.

Experimento 23 (extra) – Contador de 0 até 9 com display de 7 segmentos e 4026

Este circuito é ainda mais simples que o anterior (basicamente ligar fios a terminais), e aproveita o gerador de pulsos automático criado acima.

Material necessário

  • Circuito temporizador 555 (construído na alteração do experimento anterior)
  • 1 capacitor de 1µF (substituindo o de 100nF, para que a contagem seja mais lenta)
  • 1 resistor de 10k Ω
  • 1 resistor de 470 Ω
  • Chave táctil de pressão
  • Display de 7-segmentos
  • Circuito integrado 4026
  • Protoboard, fios e jumpers
  • Fonte ou bateria de 9V

Monte o circuito a seguir. Observe que a parte do 555 é idêntica ao do circuito do experimento anterior com exceção do capacitor de 100nF que foi trocado por um de 1µF, para que a contagem seja mais lenta.

Veja detalhes sobre a pinagem do display e do 4026 na referência no final da apostila. Esta é uma possível implementação em protoboard.

Circuitos integrados 9: Contador de década com 4017

O circuito integrado 4017 é um contador de década. Basicamente ele sabe contar até 10 e dentre os seus 16 pinos possui 10 pinos que produzem uma saída em nível lógico ALTO ou BAIXO, dependendo dos controles que disparam sua contagem. Essas saídas podem ser usadas para ligar circuitos, acender LEDs, disparar cigarras, etc. A contagem é produzida por um pino de entrada que avança a contagem através do recebimento de um pulso (que pode ser produzido por uma chave, um sensor, um oscilador de cristal de quartzo ou gerado através de um temporizador como o 555).

Como o 555, o 4017 também é um circuito integrado muito antigo (tem quase meio-século de existência).

O experimento a seguir usa o 4017 para acender uma série de LEDs em sequência a cada pulso recebido. Uma alteração do experimento inclui o 555 para que os pulsos sejam gerados periodicamente.

Experimento 22 (extra): sequenciador de LEDs com o 4017

Este experimento parece complexo apenas porque tem muitos fios, mas na verdade é muito mais simples que os outros experimentos montados anteriormente. A principal complexidade é verificar com cuidado as polaridades e o posicionamento dos fios e componentes.

Material necessário:

  • 1 circuito integrado 4017
  • 10 resistores de 470 Ω
  • 10 LEDs
  • 1 resistor de 10k
  • 1 chave táctil de pressão
  • Fonte ou bateria de 9V
  • Fios e jumpers

Monte o circuito abaixo. Lembre-se que os pinos são contados em sentido anti-horário a partir do chanfro em um dos lados, ou do ponto, que indica o pino 1.

Esta é uma possível implementação com protoboard.

Você também pode posicionar os LEDs formando um círculo, assim a contagem não acaba nunca e o LED fica girando para sempre. Isto pode ser feito em uma placa ou superfície qualquer, soldando (ou amarrando) os terminais dos LEDs.

Alteração 22.1 – Sequenciador de LEDs automático com 555 e 4017

Este circuito adiciona um gerador de pulsos automático com 555, para o circuito anterior.

Material adicional necessário

  • Circuito integrado 555
  • Resistor de 680k Ω
  • Capacitor de 10nF
  • Capacitor de 100nF (104)

A função do 555 é apenas de produzir pulsos para a entrada do 4017. Você pode alterar os valores do capacitor (de 100nF) e do resistor (de 680k) para variar a frequência e fazer o LED se mover mais ou menos rapidamente.

Alguns protoboards têm uma interrupção no meio dos condutores laterais. O circuito abaixo assume essa possibilidade e faz a ligação entre as duas metades com um fio (na faixa positiva e negativa).