Robótica

Robô Seguidor de Linha

Robô autônomo que segue uma linha preta utilizando sensores infravermelhos TCRT5000. Possui lógica inteligente para detectar encruzilhadas e linha de chegada. Quando ambos os sensores detectam preto por mais de 500ms, o robô para automaticamente.

Código Arduino

// ===========================
// Sensores TCRT5000
// ===========================
#define sensorE 4   // DIREITA (fisicamente invertido)
#define sensorD 5   // ESQUERDA

// ===========================
// Motores - Ponte H (ESP32 PINOS SEGUROS)
// ===========================
#define ENA 25
#define IN1 13
#define IN2 12

#define ENB 26
#define IN3 27
#define IN4 14

// ===========================
// Ultrassônico
// ===========================
#define TRIG 18
#define ECHO 19
int DIST_SEGURANCA = 15;

// ===========================
// PWM ESP32
// ===========================
int canalA = 0;
int canalB = 1;

void setup() {
  // Sensores de linha
  pinMode(sensorE, INPUT);
  pinMode(sensorD, INPUT);

  // Ponte H
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);

  // Ultrassônico
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);

  // PWM ESP32
  ledcAttachPin(ENA, canalA);
  ledcAttachPin(ENB, canalB);

  ledcSetup(canalA, 5000, 8); // 5kHz, resolução 8 bits
  ledcSetup(canalB, 5000, 8);

  // Velocidades
  ledcWrite(canalA, 97);
  ledcWrite(canalB, 117);
}

// ===========================
// Movimentos
// ===========================
void frente() {
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);

  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);
}

void esquerda() {
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);

  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);
}

void direita() {
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);

  digitalWrite(IN3, LOW);
  digitalWrite(IN4, LOW);
}

void parar() {
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);

  digitalWrite(IN3, LOW);
  digitalWrite(IN4, LOW);
}

// ===========================
// Ultrassônico
// ===========================
long medirDistancia() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);

  long duracao = pulseIn(ECHO, HIGH, 30000);
  if (duracao == 0) return 999;

  return duracao / 58;
}

// ===========================
// Loop principal
// ===========================
void loop() {
  long dist = medirDistancia();

  // Segurança
  if (dist < DIST_SEGURANCA) {
    parar();
    delay(80);
    return;
  }

  bool E = (digitalRead(sensorD) == LOW); // sensor ESQUERDO
  bool D = (digitalRead(sensorE) == LOW); // sensor DIREITO

  if (!E && !D) {
    frente();
  }
  else if (!E && D) {
    direita();
  }
  else if (E && !D) {
    esquerda();
  }
  else if (E && D) {
    frente();
  }
}

Copie este código e cole no seu IDE Arduino para usar

Sistema de Semáforo

Simulação de semáforo com LEDs vermelho, amarelo e verde que alternam em sequência automática. O ciclo completo dura 15 segundos: verde (7s), amarelo (3s) e vermelho (5s).

Código Arduino

const int vermelho = 10;
const int verde = 9;
const int amarelo = 8;

void setup(){
pinMode(vermelho, OUTPUT);
pinMode(verde, OUTPUT);
pinMode(amarelo, OUTPUT);
}
void loop(){
digitalWrite(verde, HIGH);
delay(5000);
digitalWrite(verde, LOW);
digitalWrite(amarelo, HIGH);
delay(3000);
digitalWrite(amarelo, LOW);
digitalWrite(vermelho, HIGH);
delay(5000);
digitalWrite(vermelho, LOW);
}

Copie este código e cole no seu IDE Arduino para usar

cronometro

Cronômetro por Arduino é um sistema que mede tempo com precisão usando funções internas como `millis()`.

Código Arduino

// Pinos dos segmentos
int A = 8;
int B = 7;
int C = 6;
int D = 5;
int E = 4;
int F = 3;
int G = 2;
int DP = 9; // ponto decimal

void setup() {
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(E, OUTPUT);
  pinMode(F, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(DP, OUTPUT);
}

// Função para acender segmentos
void display(bool a, bool b, bool c, bool d, bool e, bool f, bool g) {
  digitalWrite(A, a);
  digitalWrite(B, b);
  digitalWrite(C, c);
  digitalWrite(D, d);
  digitalWrite(E, e);
  digitalWrite(F, f);
  digitalWrite(G, g);
}

// ---------------------------
//   LOOP PRINCIPAL
// ---------------------------
void loop() {

  // 0
  display(1,1,1,1,1,1,0);
  delay(1000);

  // 1
  display(0,1,1,0,0,0,0);
  delay(1000);

  // 2
  display(1,1,0,1,1,0,1);
  delay(1000);

  // 3
  display(1,1,1,1,0,0,1);
  delay(1000);

  // 4
  display(0,1,1,0,0,1,1);
  delay(1000);

  // 5
  display(1,0,1,1,0,1,1);
  delay(1000);

  // 6
  display(1,0,1,1,1,1,1);
  delay(1000);

  // 7
  display(1,1,1,0,0,0,0);
  delay(1000);

  // 8
  display(1,1,1,1,1,1,1);
  delay(1000);

  // 9
  display(1,1,1,1,0,1,1);
  delay(1000);

  // A
  display(1,1,1,0,1,1,1);
  delay(1000);

  // b
  display(0,0,1,1,1,1,1);
  delay(1000);

  // C
  display(1,0,0,1,1,1,0);
  delay(1000);

  // d
  display(0,1,1,1,1,0,1);
  delay(1000);

  // E
  display(1,0,0,1,1,1,1);
  delay(1000);

  // F
  display(1,0,0,0,1,1,1);
  delay(1000);

  // H
  display(0,1,1,0,1,1,1);
  delay(1000);

  // L
  display(0,0,0,1,1,1,0);
  delay(1000);

  // P
  display(1,1,0,0,1,1,1);
  delay(1000);

  // U
  display(0,1,1,1,1,1,0);
  delay(1000);
}

Copie este código e cole no seu IDE Arduino para usar

carrinho arduino

Um carrinho Arduino seguidor de linha é um robô que usa sensores para detectar uma linha no chão e ajustar os motores automaticamente para segui-la.

Código Arduino

// Sensores TCRT5000 (D0)
// ===========================
#define sensorE 4     // ligado no sensor da DIREITA (invertido fisicamente)
#define sensorD 5     // ligado no sensor da ESQUERDA

// ===========================
// Motores - Ponte H
// ===========================
#define ENA 3
#define IN1 13
#define IN2 8

#define ENB 6
#define IN3 11
#define IN4 10

void setup() {
  pinMode(sensorE, INPUT);
  pinMode(sensorD, INPUT);

  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);

  pinMode(ENA, OUTPUT);
  pinMode(ENB, OUTPUT);

  // velocidades que você já estava usando
  analogWrite(ENA, 97);
  analogWrite(ENB, 117);

  Serial.begin(9600);
}

// ==========================
// MOVIMENTOS
// ==========================

void frente() {
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);

  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);

  Serial.println("FRENTE");
}

void parar() {
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, LOW);

  Serial.println("PARAR");
}

void direita() {
  // >>> AJUSTE: vira DIREITA sem dar ré
  // ESQUERDA pra frente, DIREITA parada
  digitalWrite(IN1, HIGH);  // ESQ frente
  digitalWrite(IN2, LOW);

  digitalWrite(IN3, LOW);   // DIR parado
  digitalWrite(IN4, LOW);

  Serial.println("VIRAR DIREITA");
}

void esquerda() {
  // >>> AJUSTE: vira ESQUERDA sem dar ré
  // DIREITA pra frente, ESQUERDA parada
  digitalWrite(IN1, LOW);   // ESQ parada
  digitalWrite(IN2, LOW);

  digitalWrite(IN3, HIGH);  // DIR frente
  digitalWrite(IN4, LOW);

  Serial.println("VIRAR ESQUERDA");
}

void loop() {
  // IMPORTANTE: sensores invertidos fisicamente
  bool E = (digitalRead(sensorD) == LOW);  // verdadeiro sensor ESQUERDO
  bool D = (digitalRead(sensorE) == LOW);  // verdadeiro sensor DIREITO

  Serial.print("E: ");
  Serial.print(E);
  Serial.print(" | D: ");
  Serial.println(D);

  // LOW = em cima da linha (na maioria dos TCRT D0)
  // !E && !D  -> nenhum sensor na linha   -> frente
  // E && !D   -> linha mais do lado ESQ   -> vira ESQ
  // !E && D   -> linha mais do lado DIR   -> vira DIR
  // E && D    -> os dois na linha         -> frente

  if (!E && !D) {
    frente();
  }
  else if (E && !D) {
    esquerda();
  }
  else if (!E && D) {
    direita();
  }
  else if (E && D) {
    frente();
  }

  delay(50); // um pouco mais rápido que 70, responde melhor
}

Copie este código e cole no seu IDE Arduino para usar

LED com Potenciômetro

Sistema que controla o brilho de um LED usando um potenciômetro. O valor analógico do potenciômetro (0-1023) é convertido para PWM (0-255) e aplicado ao LED, criando um efeito de dimmer.

Código Arduino

const int pinoPOT = A0; //pino analógico utilizado pelo potenciômetro
const int pinoLED = 11; //pino digital utilizado pelo led
float luminosidadeLED = 0; //variável que armazena o valor da luminosidade do led
void setup(){
pinMode(pinoPOT, INPUT); //define o pino do potenciômetro como entrada
pinMode(pinoLED, OUTPUT); //define o pino do led como saída
}
void loop(){
//executa a função "map" de acordo com os parâmetros passados
luminosidadeLED = map(analogRead(pinoPOT), 0, 1023, 0, 255);
//aplica ao led o valor de luminosidade gerado pela função "map"
analogWrite(pinoLED, luminosidadeLED);
}

Copie este código e cole no seu IDE Arduino para usar

Servo Motor

Controle de servo motor que realiza movimento de varredura entre 0 e 180 graus. O servo se move suavemente em ambas as direções, demonstrando o controle preciso de posição angular.

Código Arduino

// Programa: Controlando um servo motor com Arduino (servo motor arduino code) 

#include  // Inclui a biblioteca Servo para controlar servos

Servo meuServo; // Cria um objeto Servo para controlar o servo motor
int pos; // Declara uma variável para controlar a posição do servo motor 

void setup() {
    meuServo.attach(6); // Associa o servo motor ao pino digital 6 do Arduino
    meuServo.write(0); // Define a posição inicial do servo motor para 0 graus
}

void loop() {
    // Movimento do servo de 0 a 90 graus
    for (pos = 0; pos < 90; pos++) {
        meuServo.write(pos); // Define a posição atual do servo
        delay(15); // Aguarda 15 milissegundos antes de mover para a próxima posição
    }
    delay(1000); // Aguarda 1 segundo antes de iniciar o próximo movimento

    // Movimento do servo de 90 a 0 graus
    for (pos = 90; pos >= 0; pos--) {
        meuServo.write(pos); // Define a posição atual do servo
        delay(15); // Aguarda 15 milissegundos antes de mover para a próxima posição
    }
    delay(1000); // Aguarda 1 segundo antes de iniciar o próximo ciclo
}

Copie este código e cole no seu IDE Arduino para usar

Botão com LED

Projeto básico onde um LED é acionado por um botão. Ao pressionar o botão, o LED acende e permanece ligado enquanto o botão estiver pressionado. É o projeto ideal para iniciantes aprenderem sobre entradas digitais (botão) e saídas digitais (LED), demonstrando o controle direto de componentes.

Código Arduino

const int buttonPin = 2;  
const int ledPin = 8;    

// variables will change:
int buttonState = 0;  
void setup() {
 
  pinMode(ledPin, OUTPUT);
 
  pinMode(buttonPin, INPUT);
}

void loop() {
 
  buttonState = digitalRead(buttonPin);

 
  if (buttonState == HIGH) {
   
    digitalWrite(ledPin, HIGH);
  } else {
    
    digitalWrite(ledPin, LOW);
  }
}

Copie este código e cole no seu IDE Arduino para usar. O LED acenderá enquanto o botão estiver pressionado.

Display LCD 16x2 com I2C

Controle de display LCD 16x2 com módulo I2C. Exibe mensagens personalizadas, contadores e informações em tempo real. O módulo I2C simplifica a conexão usando apenas 2 fios (SDA e SCL) para comunicação.

Código Arduino

#include 

LiquidCrystal lcd(7, 8, 9, 10, 11 , 12);

void setup() { 
  lcd.begin(16, 2);
  pinMode(5,OUTPUT);
  analogWrite(5,96);  
  lcd.setCursor(0,0);
  lcd.write("0, 1, 2, 3, 4,");
   lcd.setCursor(0,1);
  lcd.write("5, 6, 7, 8, 9");
}

void loop() { 
}

#include 

LiquidCrystal lcd(7, 8, 9, 10, 11 , 12);

void setup() { 
  lcd.begin(16, 2);
  pinMode(5,OUTPUT);
  analogWrite(5,96);  
  lcd.setCursor(0,0);
  lcd.write("0, 1, 2, 3, 4,");
   lcd.setCursor(0,1);
  lcd.write("5, 6, 7, 8, 9");
}

void loop() { 
}

Copie este código e cole no seu IDE Arduino para usar

Buzzer com Botão

Sistema simples onde um buzzer emite som quando um botão é pressionado. Ao apertar o botão, o buzzer toca em uma frequência específica (1000Hz), criando um apito. Ideal para projetos de alarmes simples, sistemas de notificação ou controles sonoros básicos.

Código Arduino

int chavePin = 7;       // Pino do botão
int buzzerPin = 10;     // Pino do buzzer
int estadochave = 0;    // Variável que guarda o estado do botão

void setup() {
  pinMode(buzzerPin, OUTPUT);        // buzzer como saída
  pinMode(chavePin, INPUT_PULLUP);   // botão usando resistor interno
}

void loop() {
  estadochave = digitalRead(chavePin);   // Lê o botão

  if (estadochave == LOW) {   // LOW = botão pressionado
    digitalWrite(buzzerPin, HIGH);   // Liga o buzzer
  } else {
    digitalWrite(buzzerPin, LOW);    // Desliga o buzzer
  }

  delay(20);   // estabilidade da leitura
}

Copie este código e cole no seu IDE Arduino para usar. O buzzer tocará sempre que o botão for pressionado.

Robótica

Projetos de Robótica