Aula 41a — De C para Arduino: a transição

▶ Assista antes de começar: Desmistificando o Arduino

Este vídeo apresenta o Arduino de forma visual e prática. Assista primeiro — o conteúdo escrito a seguir aprofunda e complementa o que você vai ver aqui.

Por que estudar Arduino depois de C?

Você chegou até aqui sabendo declarar structs, alocar memória com malloc, montar listas encadeadas e persistir dados em arquivos. A maioria dos cursos de Arduino começa do zero com "o que é uma variável". Você não precisa disso.

O que muda agora é o destino do código: em vez de rodar num computador e imprimir no terminal, seu programa vai rodar num microcontrolador e controlar o mundo físico — acender LEDs, mover motores, ler sensores, detectar movimento.

O que é Arduino e onde instalar

Arduino é uma plataforma de hardware + software open-source criada em 2005 na Itália para facilitar a prototipagem eletrônica. Ela tem quatro partes que você precisa conhecer:

Os diferentes tipos de Arduino — qual usar?

A família Arduino tem dezenas de modelos. Cada um foi projetado para um contexto específico. Conhecer as diferenças evita comprar o modelo errado ou se surpreender com limitações no meio do projeto:

Arduino Nano — o que muda na prática

O Nano usa o mesmo chip ATmega328P do Uno e roda o mesmo código sem nenhuma modificação. As diferenças são físicas e de conveniência:

A estrutura de um sketch: setup() e loop()

Todo sketch Arduino tem exatamente duas funcoes obrigatorias. Se voce trabalhou com main() em C, vai reconhecer o padrao imediatamente:

// Sketch Arduino minimo — equivalente ao main() em C

void setup() {
    // Executada UMA VEZ quando a placa liga ou é resetada
    // Aqui: configurar pinos, inicializar bibliotecas, abrir Serial
}

void loop() {
    // Executada REPETIDAMENTE para sempre, enquanto houver energia
    // Aqui: lógica principal do programa
}

int main() {
    /* inicialização */

    while (1) {
        /* lógica */
    }
    return 0;
}

void setup() {
    /* inicialização */
}

void loop() {
    /* lógica */
}

Bibliotecas: o #include do Arduino

Em C voce ja usava #include <stdio.h> para ter acesso ao printf() e #include <string.h> para funcoes de string. No Arduino o mecanismo e identico — mas as bibliotecas dao acesso a componentes de hardware especificos como displays LCD, sensores I2C, servos e modulos de comunicacao.

// Exemplos de bibliotecas comuns — mesma sintaxe #include do C

#include <Servo.h>             // controle de servomotores
#include <Wire.h>              // comunicação I2C (sensores, displays)
#include <LiquidCrystal_I2C.h> // display LCD via I2C
#include <DHT.h>               // sensor de temperatura DHT11/DHT22

Tipos e constantes especificos do Arduino

O Arduino herda todos os tipos do C — int, float, char, long — mas adiciona tipos proprios e uma convencao diferente para constantes:

Tipos adicionais do Arduino

// String (classe Arduino) — prática, mas use com cautela em projetos grandes
String mensagem = "Sensor: ";
String completa = mensagem + 42;     // "Sensor: 42"
Serial.println(completa);
Serial.println(completa.length());   // 10

// char[] (C puro) — preferível em código de produção
char buf[20];
snprintf(buf, sizeof(buf), "Sensor: %d", 42);
Serial.println(buf);

const int vs #define — qual usar no Arduino?

Em C voce aprendeu a usar #define para constantes. No Arduino, a convencao da comunidade e preferir const int:

// Estilo recomendado no Arduino para constantes de pino e tempo:
const int PINO_LED   = 9;
const int PINO_BOTAO = 7;
const int TEMPO_ON   = 1000;

// #define ainda é válido e comum em código Arduino legado:
#define PINO_LED 9  // funciona, mas sem verificação de tipo

Arduino e C++ — uma nota sobre Orientacao a Objetos

Ao contrario do que estudamos ate aqui (C puro), o Arduino e tecnicamente C++. Na pratica, tudo que voce aprendeu em C funciona — mas o C++ adiciona um recurso importante que voce ja usa sem perceber: classes e objetos.

Quando voce escreve Serial.begin(9600) ou, mais a frente, servo.write(90), voce esta chamando um metodo de um objeto. Serial e um objeto da classe HardwareSerial. servo sera um objeto da classe Servo.

// Você já usa objetos agora — Serial é uma instância de HardwareSerial:
Serial.begin(9600);      // método begin() do objeto Serial
Serial.println("Ola");  // método println() do objeto Serial

// Nas aulas de servo você vai criar seus próprios objetos:
#include <Servo.h>
Servo motoPata;          // cria um objeto da classe Servo
motoPata.attach(9);      // associa ao pino 9
motoPata.write(90);      // posiciona no ângulo 90°

C vs Arduino — mapa completo das diferencas

A tabela abaixo consolida tudo que voce vai encontrar de diferente nas proximas aulas. Nada aqui e uma ruptura — e sempre uma adaptacao do que voce ja sabe:

Primeiro sketch: boas praticas desde o inicio

O "Hello, World!" do Arduino e o Blink — LED piscando. O pino 13 do Uno ja tem um LED soldado na placa. Veja como escrever esse sketch com as praticas que este curso vai adotar:

/*
 * Blink com boas práticas
 * LED_BUILTIN = pino 13 (LED da própria placa)
 */

// const int é preferível a #define para pinos no Arduino
const int PINO_LED  = LED_BUILTIN;  // LED_BUILTIN = 13 no Uno
const int TEMPO_ON  = 1000;
const int TEMPO_OFF =  500;         // pisca assimétrico

int contadorPiscadas = 0;

void setup() {
    pinMode(PINO_LED, OUTPUT);
    Serial.begin(9600);              // abre Monitor Serial para debug
    Serial.println("Blink iniciado!");
}

void loop() {
    digitalWrite(PINO_LED, HIGH);
    contadorPiscadas++;
    Serial.print("Piscada #");
    Serial.println(contadorPiscadas);
    delay(TEMPO_ON);

    digitalWrite(PINO_LED, LOW);
    delay(TEMPO_OFF);
}