Aprendendo Programar para ARDUINO

Aqui está uma sequência estruturada para aprender a programação básica de Arduino. Esse roteiro foi pensado para ser progressivo, indo dos conceitos mais básicos até projetos mais avançados, incluindo introdução ao hardware e ao software.

• Introdução ao Arduino e ao Ambiente de Desenvolvimento
• O que é Arduino?
• Modelos de Arduino
• Instalação da IDE Arduino
• Estrutura Básica de um Programa Arduino
• Primeiro Projeto: Piscar um LED (Blink)
• Problemas Comuns e Soluções
• Conclusão
• Trabalhando com Entradas e Saídas Digitais
• Conceito de Entradas e Saídas Digitais
• Configurando Entradas e Saídas
• Pull-up e Pull-down Resistors
• Aplicações Práticas
• Projeto 1: Controlar um LED com um botão
• Projeto 2: Luz Automática com Sensor de Movimento (PIR)
• Desafios
• Conclusão
• Trabalhando com Saídas e Entradas Analógicas
• Conceito de Sinais Analógicos
• Leitura de Entradas Analógicas com analogRead()
• Função analogWrite() e PWM (Modulação por Largura de Pulso)
• Sensores Analógicos
• Aplicações Práticas
• Projeto 1: Controle de Velocidade de um Motor DC com Potenciômetro
• Projeto 2: CONTROLANDO SERVO MOTOR COM POTENCIÔMETRO
• Nova PáginaProjeto Avançado: Dimmer de LED com Controle de Brilho Suave
• Desafios
• Conclusão

Introdução ao Arduino e ao Ambiente de Desenvolvimento

Familiarizar-se com a plataforma Arduino e a IDE (Integrated Development Environment).

O que é Arduino?

O que é Arduino?

O Arduino é uma plataforma de prototipagem eletrônica open-source, baseada em hardware e software fáceis de usar. Ela é amplamente utilizada para criar projetos de eletrônica interativa, como automação, robótica e dispositivos inteligentes. O Arduino consiste em uma placa física (hardware) e uma linguagem de programação (software) que permite controlar essa placa.

• Principais componentes do Arduino:
  • Microcontrolador: O "cérebro" do Arduino, que executa o código.
  • Pinos de entrada/saída: Portas digitais e analógicas para conectar sensores, atuadores e outros componentes eletrônicos.
  • Porta USB: Usada para carregar código no Arduino e para alimentar a placa.
  • Alimentação: Conector para fontes de energia externas.

 

Modelos de Arduino

Modelos de Arduino

Existem várias versões da placa Arduino, cada uma com diferentes especificações e características. Alguns modelos populares incluem:

• Arduino Uno: O modelo mais comum, ideal para iniciantes.
• Arduino Mega: Oferece mais pinos e memória, usado em projetos maiores.
• Arduino Nano: Versão compacta do Uno, ideal para protótipos pequenos.
• Arduino Leonardo: Permite emulação de teclado e mouse, útil para projetos que envolvem interação com computadores.

Instalação da IDE Arduino

Instalação da IDE Arduino

Para programar o Arduino, você precisa usar o software chamado IDE Arduino (Integrated Development Environment). É um ambiente de desenvolvimento simples e intuitivo, onde você escreve, compila e carrega códigos para a placa.

Passos para instalar a IDE Arduino:

1. Download da IDE: Acesse o site oficial (https://www.arduino.cc) e faça o download da versão adequada para seu sistema operacional (Windows, macOS ou Linux).
2. Instalação: Siga as instruções de instalação para o seu sistema.
3. Configuração inicial:
   • Conecte sua placa Arduino ao computador via cabo USB.
   • Abra a IDE e vá em Ferramentas > Placa > Arduino Uno (ou escolha a placa correspondente que está usando).
   • Em Ferramentas > Porta, selecione a porta COM correspondente ao seu Arduino.

Estrutura Básica de um Programa Arduino

Estrutura Básica de um Programa Arduino

Todo código no Arduino segue uma estrutura padrão com duas funções principais: setup() e loop().

• Função setup(): Executa uma única vez quando o Arduino é ligado ou reiniciado. Aqui você define as configurações iniciais, como os pinos de entrada e saída.

Exemplo:

void setup() {
  pinMode(13, OUTPUT); // Define o pino 13 como saída
}

• Função loop(): Executa repetidamente após a conclusão do setup(). É onde você coloca o código que será repetido continuamente, como a lógica de leitura de sensores e controle de dispositivos.

Exemplo:

void loop() {
  digitalWrite(13, HIGH); // Liga o LED no pino 13
  delay(1000);            // Aguarda por 1 segundo
  digitalWrite(13, LOW);  // Desliga o LED
  delay(1000);            // Aguarda por mais 1 segundo
}

 

 

Primeiro Projeto: Piscar um LED (Blink)

Primeiro Projeto: Piscar um LED (Blink)

O projeto mais simples para começar no Arduino é fazer um LED piscar. O LED embutido no Arduino Uno está conectado ao pino 13, mas você também pode conectar um LED externo.

Passo a passo:

1. Abra a IDE do Arduino.
2. Escreva ou carregue o código "Blink" (piscar LED).
3. Carregue o código para o Arduino pressionando o botão "Upload".
4. O LED no pino 13 começará a piscar com um intervalo de 1 segundo.

Código:

void setup() {
  pinMode(13, OUTPUT); // Configura o pino 13 como saída
}

void loop() {
  digitalWrite(13, HIGH); // Liga o LED
  delay(1000);            // Espera 1 segundo
  digitalWrite(13, LOW);  // Desliga o LED
  delay(1000);            // Espera 1 segundo
}

 

Problemas Comuns e Soluções

Problemas Comuns e Soluções

Ao começar a programar o Arduino, você pode encontrar alguns problemas. Aqui estão algumas dicas para solucionar problemas básicos:

• Problema: O Arduino não está respondendo.
  • Solução: Verifique se o cabo USB está corretamente conectado e se a porta correta foi selecionada na IDE (em Ferramentas > Porta).
• Problema: O código não está sendo carregado.
  • Solução: Certifique-se de que a placa correta está selecionada (em Ferramentas > Placa).

Conclusão

Conclusão

Neste primeiro capítulo, aprendemos os conceitos básicos do Arduino, desde a instalação do ambiente de desenvolvimento até a criação do seu primeiro programa. Agora que você está familiarizado com a plataforma e com a estrutura básica de um código Arduino, está preparado para continuar com entradas e saídas digitais no próximo capítulo.

Trabalhando com Entradas e Saídas Digitais

No Arduino, os pinos podem ser configurados como entradas ou saídas para interagir com o mundo físico, seja para receber dados (como a leitura de um botão) ou enviar sinais (como acender um LED).

Conceito de Entradas e Saídas Digitais

Conceito de Entradas e Saídas Digitais

No Arduino, os pinos podem ser configurados como entradas ou saídas para interagir com o mundo físico, seja para receber dados (como a leitura de um botão) ou enviar sinais (como acender um LED).

• Entrada Digital: Recebe um sinal de dispositivos como botões, sensores de presença ou interruptores. O valor lido será HIGH (5V) ou LOW (0V).
• Saída Digital: Envia sinais digitais para controlar dispositivos como LEDs, relés ou motores. O valor enviado será HIGH (5V) ou LOW (0V).

 

Configurando Entradas e Saídas

Configurando Entradas e Saídas

No Arduino, usamos a função pinMode() para definir o modo de um pino como entrada ou saída. O código é geralmente colocado na função setup().

void setup() {
  pinMode(13, OUTPUT);  // Define o pino 13 como saída
  pinMode(7, INPUT);    // Define o pino 7 como entrada
}

Controlando Saídas Digitais com digitalWrite()

A função digitalWrite() é usada para enviar sinais digitais a um pino de saída. Ela pode ser configurada para HIGH (ligado) ou LOW (desligado).

Exemplo: Ligar e desligar um LED no pino 13.

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

void loop() {
  digitalWrite(13, HIGH);  // Liga o LED
  delay(1000);             // Aguarda 1 segundo
  digitalWrite(13, LOW);   // Desliga o LED
  delay(1000);             // Aguarda 1 segundo
}

Leitura de Entradas Digitais com digitalRead()

A função digitalRead() permite ler o estado de um pino configurado como entrada. Ele retornará HIGH se o pino estiver recebendo 5V, ou LOW se estiver recebendo 0V.

Exemplo: Ler o estado de um botão conectado ao pino 7.

int buttonPin = 7;
int buttonState = 0;

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(13, OUTPUT);
}

void loop() {
  buttonState = digitalRead(buttonPin);  // Lê o estado do botão
  if (buttonState == HIGH) {
    digitalWrite(13, HIGH);  // Liga o LED se o botão estiver pressionado
  } else {
    digitalWrite(13, LOW);   // Desliga o LED se o botão estiver solto
  }
}

 

Pull-up e Pull-down Resistors

Pull-up e Pull-down Resistors

Para garantir uma leitura precisa das entradas digitais, é importante usar resistores pull-up ou pull-down. Esses resistores "puxam" o valor da entrada para HIGH ou LOW quando o botão não está sendo pressionado, evitando leituras incorretas causadas por ruído elétrico.

• Resistor Pull-down: Mantém o valor LOW até que o botão seja pressionado (quando o valor passa para HIGH).
• Resistor Pull-up: Mantém o valor HIGH até que o botão seja pressionado, o que faz com que o valor caia para LOW. O Arduino tem resistores pull-up internos, que podem ser ativados com pinMode(pino, INPUT_PULLUP).

Exemplo: Usar o resistor pull-up interno.

int buttonPin = 7;

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);  // Ativa o resistor pull-up interno
  pinMode(13, OUTPUT);
}

void loop() {
  int buttonState = digitalRead(buttonPin);
  if (buttonState == LOW) {  // O botão está pressionado (LOW por causa do pull-up)
    digitalWrite(13, HIGH);  // Liga o LED
  } else {
    digitalWrite(13, LOW);   // Desliga o LED
  }
}

 

Aplicações Práticas

Agora que entendemos os conceitos de entradas e saídas digitais, vamos aplicá-los em alguns projetos simples.

Projeto 1: Controlar um LED com um botão

Projeto 1: Controlar um LED com um botão

Objetivo: Acender um LED quando um botão for pressionado, e apagá-lo quando o botão for solto.

Circuito:

• Conecte um botão ao pino 7 do Arduino e ao GND. Conforme o Desenho
• Conecte um LED ao pino 13 e ao GND (com um resistor de 220Ω para proteger o LED).

Código:

int buttonPin = 7;
int ledPin = 13;
int buttonState = 0;

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  buttonState = digitalRead(buttonPin);
  if (buttonState == HIGH) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
}

Projeto 2: Luz Automática com Sensor de Movimento (PIR)

Projeto 2: Luz Automática com Sensor de Movimento (PIR)

Objetivo: Ligar uma lâmpada ou LED automaticamente quando detectar movimento com um sensor PIR (Passive Infrared).

Componentes:

• Sensor PIR conectado ao pino 2.
• LED ou lâmpada conectada ao pino 13.

Circuito:

• Conecte o pino de saída do sensor PIR ao pino 2 do Arduino.
• Conecte o LED ao pino 13 e ao GND.

Código:

int pirPin = 2;  // Pino onde o sensor PIR está conectado
int ledPin = 13;

void setup() {
  pinMode(pirPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int pirState = digitalRead(pirPin);  // Lê o estado do sensor PIR
  if (pirState == HIGH) {
    digitalWrite(ledPin, HIGH);  // Liga o LED se houver movimento
  } else {
    digitalWrite(ledPin, LOW);   // Desliga o LED se não houver movimento
  }
}

Desafios

Agora que você aprendeu o básico de entradas e saídas digitais, tente os seguintes desafios:

1. Desafio 1: Crie um código que acenda um LED apenas quando o botão for pressionado três vezes consecutivas.
2. Desafio 2: Adicione um buzzer ao circuito com o sensor PIR e faça-o emitir um som quando o sensor detectar movimento.

 

Conclusão

Conclusão 

Neste capítulo, você aprendeu a configurar e usar as entradas e saídas digitais no Arduino. Usamos as funções pinMode(), digitalWrite() e digitalRead() para controlar LEDs e ler botões e sensores. Esses são conceitos fundamentais para praticamente todos os projetos com Arduino. No próximo capítulo, vamos explorar as entradas e saídas analógicas, permitindo o controle mais preciso de componentes como LEDs e motores.

Trabalhando com Saídas e Entradas Analógicas

No capítulo anterior, aprendemos a usar as entradas e saídas digitais. Agora, neste capítulo, vamos nos aprofundar nas entradas e saídas analógicas, que permitem um controle mais preciso de sensores e atuadores.

Conceito de Sinais Analógicos

Conceito de Sinais Analógicos

Os sinais digitais possuem apenas dois estados: HIGH (5V) ou LOW (0V). Já os sinais analógicos variam continuamente em uma faixa de valores. O Arduino pode:

• Ler valores analógicos de sensores, como potenciômetros e sensores de luz.
• Gerar sinais que simulam saídas analógicas, usando a técnica de modulação por largura de pulso (PWM).

Leitura de Entradas Analógicas com analogRead()

Leitura de Entradas Analógicas com analogRead()

Os pinos analógicos do Arduino permitem a leitura de valores que variam de 0 a 1023, o que representa uma faixa de 0V a 5V (em placas como o Arduino Uno).

Exemplo: Conectar um potenciômetro (ou outro sensor) a um pino analógico e ler seu valor.

• O potenciômetro é um resistor variável, que ajusta a tensão em seu terminal de saída.

Código:

int potPin = A0;  // Pino analógico A0
int sensorValue = 0;

void setup() {
  Serial.begin(9600);  // Inicia a comunicação serial
}

void loop() {
  sensorValue = analogRead(potPin);  // Lê o valor do potenciômetro
  Serial.println(sensorValue);  // Exibe o valor lido no monitor serial
  delay(100);  // Atraso de 100 ms
}

No código acima, o valor lido do potenciômetro será exibido no Monitor Serial, variando de 0 a 1023 conforme o ajuste do potenciômetro.

Função analogWrite() e PWM (Modulação por Largura de Pulso)

Função analogWrite() e PWM (Modulação por Largura de Pulso)

O Arduino não gera sinais analógicos verdadeiros, mas pode simular uma saída analógica usando PWM. Essa técnica gera um sinal digital que alterna rapidamente entre HIGH e LOW, variando a largura dos pulsos. O valor médio resultante pode ser percebido como um valor analógico pelos dispositivos controlados.

A função analogWrite() é usada para gerar uma saída PWM nos pinos marcados com o símbolo “~”. Os valores PWM variam de 0 a 255:

• 0: Sinal equivalente a 0V.
• 255: Sinal equivalente a 5V.

Exemplo: Controlar o brilho de um LED usando a função analogWrite() e um potenciômetro para ajustar a intensidade.

int potPin = A0;  // Pino do potenciômetro
int ledPin = 9;   // Pino PWM do LED
int val = 0;      // Armazenar o valor lido

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

void loop() {
  val = analogRead(potPin);  // Lê o valor do potenciômetro (0 a 1023)
  val = map(val, 0, 1023, 0, 255);  // Converte o valor para a faixa de 0 a 255
  analogWrite(ledPin, val);  // Ajusta o brilho do LED com base no valor do potenciômetro
}

Função map(): Converte valores de uma faixa para outra. No exemplo, converte o valor lido do potenciômetro (0-1023) para a faixa PWM (0-255).

Sensores Analógicos

Sensores Analógicos

Os sensores analógicos fornecem valores variáveis que podem ser lidos diretamente pelos pinos analógicos do Arduino. Alguns exemplos de sensores analógicos comuns incluem:

• Sensor de temperatura LM35: Fornece uma leitura analógica proporcional à temperatura.
• Sensor de luz LDR: Um resistor dependente de luz que altera sua resistência com base na intensidade luminosa.

Exemplo: Ler a temperatura com o sensor LM35

int tempPin = A0;  // Pino do sensor LM35
float temperature = 0.0;

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

void loop() {
  int val = analogRead(tempPin);  // Lê o valor analógico do LM35
  temperature = (val * (5.0 / 1023.0)) * 100;  // Converte o valor para °C
  Serial.print("Temperatura: ");
  Serial.print(temperature);
  Serial.println(" C");
  delay(1000);  // Aguarda 1 segundo
}

 

No exemplo acima, o valor lido do sensor LM35 é convertido para graus Celsius e exibido no Monitor Serial.

 

Aplicações Práticas

Projeto 1: Controle de Velocidade de um Motor DC com Potenciômetro

Projeto 1: Controle de Velocidade de um Motor DC com Potenciômetro

Objetivo: Controlar a velocidade de um motor DC usando PWM e um potenciômetro.

Componentes:

• Motor DC conectado ao pino PWM (com driver de motor ou transistor para proteção).
• Potenciômetro conectado ao pino A0.

Código:

int motorPin = 9;
int potPin = A0;
int speed = 0;

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

void loop() {
  speed = analogRead(potPin);  // Lê o valor do potenciômetro
  speed = map(speed, 0, 1023, 0, 255);  // Converte o valor para 0-255
  analogWrite(motorPin, speed);  // Ajusta a velocidade do motor
}

Com esse projeto, ao girar o potenciômetro, o motor aumentará ou diminuirá a sua velocidade.

Projeto 2: CONTROLANDO SERVO MOTOR COM POTENCIÔMETRO

Projeto 2: CONTROLANDO SERVO MOTOR COM POTENCIÔMETRO

 

DESCRIÇÃO DO PROJETO: O projeto permitirá girar o servo motor em toda sua extensão permitida de meia volta, o soquete de trÊs pinos possui o GND tensão e sinal de pulso. A precisão do giro é verificada por meio do decodificador do servo motor, a qual efetua cálculos precisos.

Componentes:

• Servo Motor conectado ao pino 9 (ou outro pino PWM).
• Potenciômetro conectado ao pino A0.

#include <Servo.h> 
Servo servo1; //cria um novo objeto servo
int potenciometroPino0 = 0; //conecta potenciometro na porta analogica 0
int valorDoPotenciometro = 0; //valor lido no pino 0

void setup (){
 
  servo1.attach(9); //conecta o objeto servo1 ao pino 9

}

void loop(){
  
  valorDoPotenciometro = analogRead(potenciometroPino0); // lê um valor analógico do potenciometro de  0 a 255
  valorDoPotenciometro = map(valorDoPotenciometro, 0, 1023, 0, 179);//mapeia o valor lido entre 0 a 1023 para uma valor ente 0 e 180
  servo1.write(valorDoPotenciometro); // envia sinal para o servo posicionar
  delay(15); //aguarda movimento do servo
   
}

Nova PáginaProjeto Avançado: Dimmer de LED com Controle de Brilho Suave

Projeto Avançado: Dimmer de LED com Controle de Brilho Suave

Objetivo: Criar um efeito de fade suave em um LED, onde o brilho aumenta e diminui continuamente.

Código:

int ledPin = 9;
int brightness = 0;
int fadeAmount = 5;

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

void loop() {
  analogWrite(ledPin, brightness);  // Ajusta o brilho do LED
  brightness = brightness + fadeAmount;  // Altera o brilho
  
  // Inverte a direção do fade quando atingir os extremos
  if (brightness <= 0 || brightness >= 255) {
    fadeAmount = -fadeAmount;
  }
  
  delay(30);  // Atraso para criar o efeito de fade suave
}

Nesse projeto, o brilho do LED aumenta e diminui suavemente, criando um efeito de "respiração" no LED.

Desafios

Desafios

Agora que você aprendeu a trabalhar com entradas e saídas analógicas, aqui estão alguns desafios para praticar:

1. Desafio 1: Crie um dimmer de LED controlado por um sensor de luz (LDR). O brilho do LED deve aumentar conforme a luminosidade diminui e vice-versa.
2. Desafio 2: Use um sensor de temperatura LM35 para controlar a velocidade de um motor. O motor deve girar mais rápido conforme a temperatura aumenta.

Conclusão

Conclusão 

Neste capítulo, você aprendeu a trabalhar com sinais analógicos no Arduino, tanto para ler entradas analógicas de sensores quanto para gerar saídas analógicas simuladas com PWM. Você também aprendeu a usar a função analogRead() para ler valores de sensores e analogWrite() para controlar dispositivos com precisão, como motores e LEDs. Essas técnicas são fundamentais para o controle mais fino de projetos de eletrônica interativa, permitindo trabalhar com variações contínuas, em vez de apenas liga/desliga.

No próximo capítulo, exploraremos o controle de motores e servomotores, ampliando as possibilidades de automação e robótica em seus projetos Arduino.