Raspberry Pi ou Arduino: principais diferenças e qual escolher

A diferença entre Raspberry Pi e Arduino cabe em uma frase: o Raspberry Pi é um computador do tamanho de um cartão de crédito que roda um sistema operacional Linux, enquanto o Arduino é uma placa microcontroladora que executa sem parar um único programa que você carrega nela. Em um Pi você pode ligar teclado, mouse e monitor, navegar na internet, processar imagens de câmera com Python ou montar um pequeno servidor em casa. Já o Arduino começa a funcionar no instante em que recebe alimentação, lê sensores com precisão de microssegundos, aciona motores e LEDs sem nunca travar e pode funcionar com pilhas por dias.

Resumindo: o Raspberry Pi é a melhor escolha para projetos que precisam de câmera, processamento de imagem, interface gráfica ou serviços de rede, enquanto o Arduino vence quando você precisa de sensores, motores, temporização precisa e baixo consumo. Neste guia comparamos as duas plataformas com números reais: tempo de inicialização, consumo de energia, GPIO e entrada analógica, linguagem de programação, comportamento em tempo real e preço. Depois mostramos em uma tabela qual escolher para cada projeto, damos um código de exemplo que faz as duas trabalharem juntas por um cabo USB e explicamos onde entra o Raspberry Pi Pico, que, apesar do nome, é muito mais parecido com um Arduino.

O que é um Raspberry Pi e o que é um Arduino?

O Raspberry Pi é um computador de placa única (SBC) desenvolvido pela Raspberry Pi Foundation, no Reino Unido. O Raspberry Pi 5 tem um processador Arm Cortex-A76 de quatro núcleos a 2,4 GHz, de 1 a 16 GB de RAM, duas saídas HDMI 4K, USB 3.0, Gigabit Ethernet, Wi-Fi e Bluetooth. Em vez de um disco rígido, ele usa um cartão microSD (ou um SSD NVMe em uma placa adicional) e roda o Raspberry Pi OS, baseado em Debian. Ou seja, é um irmão pequeno e barato do seu computador de mesa; a única diferença é a barra de GPIO de 40 pinos na borda, que permite ligar LEDs, botões e sensores diretamente.

O Arduino, por outro lado, é uma plataforma de microcontroladores de código aberto nascida na Itália. Sua placa mais comum, o Arduino Uno R3, é construída em torno de um ATmega328P de 8 bits a 16 MHz: o processador, 2 KB de RAM, 32 KB de memória de programa e o conversor analógico-digital ficam todos dentro de um pequeno chip. Não há sistema operacional, sistema de arquivos nem saída de vídeo. O código que você escreve na Arduino IDE no computador é compilado e gravado na memória flash da placa; toda vez que a placa liga, setup() roda uma vez e depois loop() roda para sempre. Para conhecer melhor a plataforma, leia O que é Arduino?.

Resposta rápida: qual usar em cada situação?

Tabela comparativa: Raspberry Pi 5, Arduino Uno e Raspberry Pi Pico

Uma observação rápida sobre os preços: como o custo dos chips de memória LPDDR4 usados no Raspberry Pi 4 e 5 disparou com a demanda dos data centers de IA, a Raspberry Pi aumentou os preços várias vezes desde dezembro de 2025; em outubro de 2026, o Pi 5 de 2 GB custa US$ 77,50 na tabela. O Pi Zero 2 W, que usa uma memória mais antiga, continuou em US$ 15. Além disso, um Pi precisa de um cartão microSD, de uma fonte USB-C de 27 W e, de preferência, de um cooler, o que soma mais US$ 20–30 ao total. Um Arduino Uno ou um Pico só precisa de um cabo USB.

A diferença fundamental entre um computador Linux e um microcontrolador

Em um Raspberry Pi, o programa em Python que você escreve é só um entre centenas de processos que o Linux gerencia ao mesmo tempo. O kernel entrega o processador, em revezamento, à conexão de rede, à tela, aos dispositivos USB, aos serviços em segundo plano e ao seu programa. É uma estrutura muito poderosa: você pode gravar logs em arquivos, rodar ao mesmo tempo um servidor web e uma transmissão de câmera e editar o código via SSH de outro cômodo. No Arduino, a única coisa rodando no processador é o seu código. Sem um sistema operacional no meio, uma chamada digitalWrite muda o estado do pino em poucos microssegundos, e leva o mesmo tempo todas as vezes. Na prática, essa diferença significa:

• Multitarefa: um Pi roda um navegador, um script Python e um banco de dados ao mesmo tempo; o Arduino roda um único loop(), e você mesmo organiza várias tarefas com millis().
• Armazenamento: em um Pi você pode guardar gigabytes de fotos, logs e bancos de dados; no Uno, o programa precisa caber em 32 KB e as variáveis em 2 KB de RAM.
• Rede: o Pi se conecta à internet por Wi-Fi e Ethernet logo ao sair da caixa; o Uno não tem conexão de rede, então você precisa de um ESP32 ou de um módulo extra.
• Manutenção: como o Pi é um computador, ele precisa de atualizações, senha de usuário e alguns cuidados de segurança; no Arduino, você carrega o código uma vez e ele continua funcionando do mesmo jeito por anos.
• Quando algo dá errado: se um programa trava no Pi, o sistema continua de pé e você consegue ler a mensagem de erro; se o código trava no Arduino, a placa simplesmente para em silêncio, mas um watchdog timer (temporizador de vigilância) pode reiniciá-la automaticamente.

Tempo de inicialização e queda repentina de energia

Quando você liga um Arduino, o programa começa a rodar em menos de um segundo; mesmo quando você aperta o botão de reset, o bootloader espera só um instante. O Raspberry Pi primeiro carrega o bootloader, depois o kernel do Linux e os serviços; dependendo do modelo e da velocidade do cartão SD, ele leva de 15 a 40 segundos para chegar à área de trabalho. Isso importa em aparelhos que precisam funcionar logo depois de uma queda de energia, como uma campainha, um alarme ou um sistema de irrigação. O desligamento é ainda mais crítico: o Linux grava no cartão SD o tempo todo e, se a energia cair no meio de uma gravação, o sistema de arquivos pode corromper e o Pi pode não ligar mais. Como o programa do Arduino fica fixo na memória flash, você pode tirar o cabo da tomada quando quiser.

Consumo de energia e funcionamento com bateria

No consumo, a diferença é de 10 a 30 vezes. Um Raspberry Pi 5 gasta cerca de 3 W ocioso e 7–8 W com a CPU em carga total, e ainda mais quando você adiciona um disco USB e uma câmera. Um Arduino Uno puxa cerca de 50 mA, ou seja, 0,25 W em 5 V, e um Pico fica perto de 0,1 W. A tabela abaixo mostra tempos de funcionamento aproximados com um power bank de 10.000 mAh. A conta é esta: os 10.000 mAh da etiqueta se referem a células de 3,7 V, o que dá cerca de 37 Wh; depois das perdas da conversão para 5 V, sobram uns 30 Wh utilizáveis. Divida esse valor pelo consumo da placa em watts. Para o seu próprio circuito, use a calculadora de autonomia da bateria.

Pinos GPIO e entrada analógica

A barra de 40 pinos do Raspberry Pi tem 28 GPIOs; os GPIO 0 e 1 são reservados para a EEPROM de identificação das placas HAT e normalmente ficam livres. Esses pinos funcionam com 3,3 V, não toleram 5 V e fornecem só alguns miliampères por pino (no máximo cerca de 16 mA); dá para acender um LED com um resistor em série, mas você não deve acionar diretamente a bobina de um relé ou um motor. A maior lacuna é a falta de entradas analógicas: não existe equivalente ao analogRead no Pi, então ler um sensor analógico como um potenciômetro, um LDR ou um sensor de umidade do solo exige um chip ADC externo. O Arduino Uno tem 6 entradas analógicas, e quase todo sensor de 5 V se liga a ele diretamente.

Há duas formas de ligar um sensor analógico a um Pi. A primeira é usar um módulo ADC, como o MCP3008 de 8 canais e 10 bits via SPI ou o ADS1115 de 4 canais e 16 bits via I2C; a biblioteca gpiozero já suporta o MCP3008 de fábrica. A segunda é ligar os sensores a um Arduino ou a um Pico e enviar as leituras ao Pi pelo USB; mais abaixo damos o código para isso. Você encontra como funciona a leitura analógica em O que é ADC? e os mapas de pinos das placas na ferramenta Pinagem.

Linguagem de programação e ambiente de desenvolvimento

O Arduino é programado na linguagem Arduino, baseada em C/C++: você escreve o código na Arduino IDE no computador, e ele é compilado e carregado na placa pelo USB. No Raspberry Pi, o código é escrito e executado no próprio Pi, sem uma etapa separada de carregamento. A linguagem mais popular é o Python, e o Raspberry Pi OS já vem com o editor Thonny e a biblioteca gpiozero instalados. Você também pode usar qualquer linguagem que rode no Linux, como C, C++, Node.js, Go ou Java. Veja como fica no Pi, em Python, um programa de “acender o LED enquanto o botão estiver pressionado”:

1from gpiozero import LED, Button
2from signal import pause
3
4led = LED(17)       # GPIO17 = fiziksel pin 11 / GPIO17 = physical pin 11
5buton = Button(27)  # GPIO27 = fiziksel pin 13, dahili pull-up açık / physical pin 13, internal pull-up on
6
7buton.when_pressed = led.on    # Basınca LED yanar / LED on when pressed
8buton.when_released = led.off  # Bırakınca söner / LED off when released
9
10pause()  # Programı açık tut, olayları bekle / keep running and wait for events

Ligue o botão entre o GPIO27 e o GND e o LED ao GPIO17 através de um resistor de 220 Ω; a classe Button ativa sozinha o resistor de pull-up interno. Salve o arquivo como buton_led.py e rode-o digitando python3 buton_led.py no terminal. Atenção: no Raspberry Pi 5, os GPIOs são controlados pelo novo chip RP1, então a antiga biblioteca RPi.GPIO não funciona e falha com “RuntimeError: Cannot determine SOC peripheral base address”; use gpiozero em projetos novos. Se o pip install falhar com “externally-managed-environment” no Raspberry Pi OS atual, instale o pacote com sudo apt install python3-... ou crie um ambiente virtual (venv). No Raspberry Pi Pico, você usa o mesmo conhecimento de Python com o MicroPython.

Tempo real: por que Arduino para motores e sensores?

Como o Linux divide o processador entre os programas, o seu código Python pode ficar pausado de vez em quando por alguns milissegundos, e não dá para prever quando isso vai acontecer. Para uma página web isso é irrelevante, mas para um hardware que depende de temporização é um problema sério. Alguns exemplos concretos:

• Sensor de distância HC-SR04: o som leva cerca de 58 µs de ida e volta para cada 1 cm de distância. Se um atraso de 100 µs aparecer enquanto você mede o tempo do eco, a leitura erra em 1,7 cm; no Pi, desvios assim são comuns.
• Servo motor: o servo se posiciona por um pulso de 1–2 ms em um sinal de 50 Hz, e 1 grau corresponde a cerca de 5,5 µs. Um servo acionado por PWM por software no Pi treme; no Arduino, fica parado.
• Fita de LED WS2812B: cada bit dura 1,25 µs e a temporização precisa de 0,15 µs de precisão; o Pi só consegue isso com o hardware de SPI ou PWM mais DMA, enquanto um Arduino ou um Pico aciona a fita diretamente.
• Motores de passo e encoders: milhares de pulsos de passo por segundo ou sinais rápidos de encoder são capturados sem perdas no Arduino usando interrupções.

Qual usar em cada projeto?

Câmera e processamento de imagem são o ponto mais forte do Raspberry Pi. A Camera Module 3, de 12 MP e com foco automático, se liga ao conector de câmera da placa por um cabo flat; você pode tirar uma foto com rpicam-still -o photo.jpg e fazer detecção de movimento, rastreamento de cor, leitura de QR code ou reconhecimento facial em Python com as bibliotecas Picamera2 e OpenCV. Para modelos de IA mais pesados, dá para adicionar uma placa aceleradora como a AI HAT+ ou usar a AI Camera, que processa a imagem dentro da própria câmera. Os conectores de câmera do Raspberry Pi 5 são menores (22 pinos) que os dos modelos antigos, então câmeras mais antigas precisam de um cabo adaptador adequado. Os 2 KB de RAM do Arduino Uno não guardam nem uma foto pequena; se você só quer tirar fotos e enviá-las ao Telegram, o barato ESP32-CAM é um bom meio-termo.

Já quando o assunto é sensores e motores, o Arduino praticamente não tem rival. Como funciona com 5 V, a maioria dos módulos do mercado, como o HC-SR04, os módulos de relé, o driver de motor L298N e os LCDs de caracteres, se liga sem nenhum circuito extra, e shields de driver de motor, relé e sensores encaixam direto em cima da placa. Em um carrinho robô, o Arduino lê o sensor de distância dezenas de vezes por segundo e para os motores no instante em que vê um obstáculo; esse tempo de reação nunca depende de quão ocupado está um sistema operacional. Os servo motores e os motores de passo funcionam suavemente no Arduino pelo mesmo motivo.

Usando os dois juntos: Raspberry Pi + Arduino

Na maioria dos projetos avançados, a melhor solução é usar os dois. Pense no corpo humano: o Raspberry Pi é o cérebro; ele processa a câmera, se conecta à internet, guarda registros e toma decisões. O Arduino é a medula espinhal e os músculos; ele lê os sensores, aciona os motores e, em uma emergência, reage por reflexo sem perguntar ao Pi. Em um carrinho robô com câmera, por exemplo, o Pi encontra a linha na imagem e envia o comando “virar à esquerda”; o Arduino traduz isso em velocidades dos motores e para sozinho se aparecer um obstáculo. As formas comuns de ligar as duas placas são:

1. Carregue o código Arduino abaixo na placa a partir do seu computador (você também pode carregá-lo pelo Pi com o arduino-cli).
2. Ligue o Arduino ao Pi com um cabo USB e descubra o nome da porta digitando ls /dev/ttyACM* /dev/ttyUSB* no terminal. Um Uno original costuma aparecer como /dev/ttyACM0, e os clones com chip CH340 como /dev/ttyUSB0.
3. Se a biblioteca pyserial não estiver instalada, instale-a com sudo apt install python3-serial.
4. Se o seu usuário não consegue acessar a porta serial, digite sudo usermod -a -G dialout $USER, depois saia da sessão e entre de novo.
5. Salve o código Python como pi_arduino.py e rode-o com python3 pi_arduino.py; se o Monitor Serial da Arduino IDE estiver aberto, feche-o antes.

1// Arduino Uno: A0 değerini Pi'ye gönderir, Pi'den gelen komutla LED'i yönetir
2// Arduino Uno: sends the A0 reading to the Pi and drives the LED on the Pi's command
3const int SENSOR_PIN = A0;      // LDR ya da potansiyometre / LDR or potentiometer
4const int LED_PIN = 13;         // Dahili LED / built-in LED
5unsigned long sonGonderim = 0;  // Son gönderim zamanı / time of the last send
6
7void setup() {
8  Serial.begin(115200);         // Pi tarafıyla aynı hız / same baud rate as the Pi
9  pinMode(LED_PIN, OUTPUT);
10}
11
12void loop() {
13  // Pi'den komut geldi mi? / has a command arrived from the Pi?
14  if (Serial.available()) {
15    String komut = Serial.readStringUntil('\n');  // Satır sonuna kadar oku / read up to the newline
16    komut.trim();                                  // Boşluk ve \r karakterlerini sil / strip spaces and \r
17    if (komut == "LED1") digitalWrite(LED_PIN, HIGH);
18    else if (komut == "LED0") digitalWrite(LED_PIN, LOW);
19  }
20
21  // 500 ms'de bir ölçüm gönder, loop'u bekletmeden / send a reading every 500 ms without blocking
22  if (millis() - sonGonderim >= 500) {
23    sonGonderim = millis();
24    int deger = analogRead(SENSOR_PIN);  // 0-1023
25    Serial.print("A0:");
26    Serial.println(deger);               // Örnek: A0:512 / example: A0:512
27  }
28}

1import time
2import serial  # sudo apt install python3-serial
3
4# Orijinal Uno: /dev/ttyACM0, CH340'lı klon: /dev/ttyUSB0 / genuine Uno: /dev/ttyACM0, CH340 clone: /dev/ttyUSB0
5ser = serial.Serial("/dev/ttyACM0", 115200, timeout=1)
6time.sleep(2)             # Port açılınca Arduino yeniden başlar / opening the port resets the Arduino
7ser.reset_input_buffer()  # Eski verileri temizle / drop stale data
8
9ESIK = 300                # Karanlık eşiği, sensörüne göre ayarla / darkness threshold, tune it for your sensor
10led_durum = None
11
12while True:
13    satir = ser.readline().decode("utf-8", errors="ignore").strip()
14    if not satir.startswith("A0:") or not satir[3:].isdigit():
15        continue          # Boş ya da yarım satırı atla / skip empty or partial lines
16    deger = int(satir[3:])
17    print("Sensor:", deger)
18
19    yeni = "LED1" if deger < ESIK else "LED0"  # Karanlıkta LED'i yak / LED on in the dark
20    if yeni != led_durum:                      # Yalnız değişince gönder / send only on change
21        ser.write((yeni + "\n").encode())
22        led_durum = yeni

A cada 500 ms o Arduino envia uma linha como “A0:512” e escuta os comandos “LED1” ou “LED0” terminados com uma quebra de linha; como usa millis(), a espera por comandos nunca atrasa as medições. No lado do Python, a linha time.sleep(2) é importante: quando o Pi abre a porta serial, o Arduino reinicia automaticamente, e o que for enviado nos dois primeiros segundos se perde. Ajuste o limite de 300 ao seu sensor; dependendo de como você ligou o LDR, o valor pode subir ou descer no escuro. Para saber mais sobre comunicação serial, veja Comunicação serial entre Arduino e Python e O que é UART?.

Onde entra o Raspberry Pi Pico: Raspberry Pi no nome, microcontrolador por natureza

Esta é a confusão mais comum. Embora seja fabricado pela Raspberry Pi, o Raspberry Pi Pico não é um computador, e sim uma placa microcontroladora como o Arduino: não tem sistema operacional, liga instantaneamente, consome cerca de 0,1 W e funciona em tempo real. No seu coração está o chip RP2040 de dois núcleos, projetado pela própria Raspberry Pi (o Pico 2 usa o RP2350 de 150 MHz). Em comparação com o Arduino Uno, ele tem muito mais RAM (264 KB), um ADC de 12 bits e blocos PIO para tarefas críticas de temporização, e é programado em MicroPython, C/C++ ou na Arduino IDE. Por US$ 4, é mais barato que um Arduino Uno, mas, como funciona com 3,3 V, é preciso ter cuidado com módulos de 5 V. Para os detalhes, leia O que é o Raspberry Pi Pico?.

A maior vantagem do Pico nesta comparação é que ele funciona no mesmo nível de 3,3 V do Raspberry Pi: você pode ligar os pinos UART dele direto ao Pi, sem conversor de nível, ou conectá-lo ao USB e usá-lo exatamente como um Arduino. O código MicroPython abaixo envia dados no mesmo formato “A0:valor” do código Arduino acima e escuta os mesmos comandos de LED, então o script Python no Pi funciona sem nenhuma alteração. Salve o código no Pico como main.py com o Thonny e depois feche o Thonny para que a porta serial fique livre para o script no Pi.

1import sys, select, time
2from machine import ADC, Pin
3
4sensor = ADC(26)        # GP26 = ADC0 (fiziksel pin 31) / GP26 = ADC0 (physical pin 31)
5led = Pin(25, Pin.OUT)  # Pico dahili LED; Pico W'de Pin("LED") / onboard LED; use Pin("LED") on Pico W
6poll = select.poll()
7poll.register(sys.stdin, select.POLLIN)  # USB'den gelen veriyi dinle / listen for data over USB
8son = time.ticks_ms()
9
10while True:
11    # Pi'den komut var mı? / is there a command from the Pi?
12    if poll.poll(0):
13        komut = sys.stdin.readline().strip()
14        if komut == "LED1":
15            led.on()
16        elif komut == "LED0":
17            led.off()
18
19    # 500 ms'de bir, Arduino ile aynı biçimde gönder / every 500 ms, same format as the Arduino
20    if time.ticks_diff(time.ticks_ms(), son) >= 500:
21        son = time.ticks_ms()
22        deger = sensor.read_u16() >> 6  # 0-65535 -> 0-1023
23        print("A0:" + str(deger))

As fronteiras também estão ficando mais difusas. Em 2025, a Arduino lançou o Arduino UNO Q, que une os dois mundos em uma só placa: essa placa do tamanho de um Uno traz um processador Qualcomm de quatro núcleos rodando Debian Linux junto com um microcontrolador STM32U585 que executa sketches Arduino em tempo real. Ou seja, a arquitetura “Pi + Arduino” agora cabe em uma única placa. A lógica, porém, não muda: o lado Linux cuida da rede, do vídeo e da aplicação, enquanto o lado do microcontrolador cuida dos pinos e da temporização. Quem entende as diferenças deste artigo vai tirar muito mais proveito de placas híbridas como essa.

Erros comuns e ideias equivocadas

• “O Raspberry Pi Pico é um Raspberry Pi pequeno”: não é; ele não roda Linux e não tem saída HDMI. O Pico é um microcontrolador e pertence à mesma categoria do Arduino.
• Ligar um sinal de 5 V ao Pi: se o pino ECHO do HC-SR04 ou a linha TX do Arduino for ligado direto a um GPIO, o pino, ou até o processador, pode ser danificado para sempre; use um divisor de tensão.
• Procurar analogRead no Pi: o Raspberry Pi não tem entradas analógicas; use um MCP3008, um ADS1115 ou um Arduino ou Pico auxiliar.
• Desligar puxando o cabo: é o jeito mais rápido de corromper um cartão SD; use sudo poweroff todas as vezes.
• Alimentar um Pi 5 com carregador de celular: com uma fonte que não entrega 5 V 5 A, o Pi 5 limita a corrente total das portas USB a 600 mA e pode reiniciar sob carga.
• O erro “Permission denied: '/dev/ttyACM0'”: seu usuário não está no grupo dialout; rode o comando usermod e entre de novo na sessão. Com “Device or resource busy”, outro programa (o Monitor Serial ou o Thonny) está ocupando a porta.
• Achar que “o Arduino ficou ultrapassado, agora existe o Pi”: eles não são rivais, e sim ferramentas para trabalhos diferentes; a maioria dos aparelhos, de máquinas de lavar a carros, ainda funciona com microcontroladores.

Resumindo, o Raspberry Pi é um computador que pensa e enxerga, enquanto o Arduino é um controlador que transforma na hora o que sente em ação; um bom projeto muitas vezes combina os pontos fortes dos dois. No app BlueGrays você encontra dezenas de projetos com Arduino, ESP32 e Raspberry Pi Pico, de LEDs e sensores a robôs e montagens com Wi-Fi, cada um com esquema do circuito passo a passo e código pronto, e pode começar pelos gratuitos.