Diferencia entre Raspberry Pi y Arduino: cuál elegir y por qué

La diferencia entre Raspberry Pi y Arduino cabe en una frase: la Raspberry Pi es un ordenador (una computadora) del tamaño de una tarjeta de crédito que ejecuta un sistema operativo Linux, mientras que Arduino es una placa con microcontrolador que ejecuta una y otra vez el único programa que le cargas. A la Pi puedes conectarle teclado, ratón y monitor, navegar por internet, procesar imágenes de una cámara con Python o montar un pequeño servidor en casa. Arduino, en cambio, empieza a funcionar en cuanto le das corriente, lee sensores con precisión de microsegundos, controla motores y LED sin un solo tropiezo y puede funcionar días con pilas.

En resumen, la Raspberry Pi es mejor opción para proyectos que necesitan cámara, procesamiento de imagen, interfaz gráfica o servicios de red, mientras que Arduino gana cuando necesitas sensores, motores, temporización precisa y bajo consumo. En esta guía comparamos las dos plataformas con cifras reales: tiempo de arranque, consumo, GPIO y entradas analógicas, lenguaje de programación, tiempo real y precio. Después te mostramos en una tabla cuál elegir para cada proyecto, te damos código de ejemplo para que ambas trabajen juntas por un cable USB y te explicamos dónde encaja la Raspberry Pi Pico, que a pesar de su nombre se parece mucho más a un Arduino.

¿Qué es una Raspberry Pi y qué es un Arduino?

La Raspberry Pi es un ordenador de placa única (SBC) desarrollado por la Raspberry Pi Foundation del Reino Unido. La Raspberry Pi 5 tiene un procesador Arm Cortex-A76 de cuatro núcleos a 2,4 GHz, de 1 a 16 GB de RAM, dos salidas HDMI 4K, USB 3.0, Ethernet Gigabit, Wi-Fi y Bluetooth. En lugar de disco duro usa una tarjeta microSD (o un SSD NVMe con una placa adicional) y en ella se instala Raspberry Pi OS, basado en Debian. Es decir, tienes delante un hermano pequeño y barato de tu ordenador de escritorio; la única diferencia es el conector GPIO de 40 pines de su borde, que te permite conectar directamente LED, pulsadores y sensores.

Arduino, por su parte, es una plataforma de microcontroladores de código abierto nacida en Italia. Su placa más popular, el Arduino Uno R3, lleva en su corazón un ATmega328P de 8 bits a 16 MHz: el procesador, 2 KB de RAM, 32 KB de memoria de programa y el convertidor analógico-digital están dentro del mismo chip. No hay sistema operativo, ni sistema de archivos, ni salida de vídeo. El código que escribes en el Arduino IDE de tu ordenador se compila y se guarda en la memoria flash de la placa; cada vez que se enciende, setup() se ejecuta una vez y luego loop() se repite para siempre. Para conocer mejor la plataforma, lee ¿Qué es Arduino?.

Respuesta rápida: ¿cuál conviene en cada caso?

Tabla comparativa: Raspberry Pi 5, Arduino Uno y Raspberry Pi Pico

Una nota rápida sobre los precios: como el coste de los chips de memoria LPDDR4 que usan la Raspberry Pi 4 y la 5 se ha disparado por la demanda de los centros de datos de IA, Raspberry Pi ha subido los precios varias veces desde diciembre de 2025; en octubre de 2026 la Pi 5 de 2 GB cuesta 77,50 $ de lista. La Pi Zero 2 W, que usa una memoria más antigua, se ha mantenido en 15 $. Además, la Pi necesita una tarjeta microSD, una fuente USB-C de 27 W y, a ser posible, un disipador, que suman otros 20–30 $ al total. Un Arduino Uno o una Pico solo necesitan un cable USB.

La diferencia fundamental entre un ordenador Linux y un microcontrolador

En la Raspberry Pi, el programa en Python que escribes es solo uno de los cientos de procesos que Linux gestiona a la vez. El núcleo (kernel) va repartiendo el procesador entre la conexión de red, la pantalla, los dispositivos USB, los servicios en segundo plano y tu programa. Es un esquema muy potente: puedes guardar registros en archivos, ejecutar a la vez un servidor web y una transmisión de cámara y editar tu código por SSH desde otra habitación. En Arduino, en cambio, lo único que corre en el procesador es tu código. Como no hay sistema operativo de por medio, la orden digitalWrite cambia el pin en pocos microsegundos, y siempre tarda lo mismo. En la práctica, esta diferencia implica lo siguiente:

• Multitarea: La Pi ejecuta a la vez un navegador, un script de Python y una base de datos; Arduino funciona con un único loop(), y tú mismo organizas varias tareas con millis().
• Almacenamiento: En la Pi puedes guardar gigabytes de fotos, registros y bases de datos; en el Uno tu programa debe caber en 32 KB y tus variables en 2 KB de RAM.
• Red: La Pi se conecta a internet por Wi-Fi y Ethernet nada más sacarla de la caja; el Uno no tiene conexión de red, así que necesitas un ESP32 o un módulo adicional.
• Mantenimiento: Como la Pi es un ordenador, necesita actualizaciones, contraseña de usuario y cuidar la seguridad; a Arduino le cargas el código una vez y funciona igual durante años.
• Cuando algo falla: Si un programa se cuelga en la Pi, el sistema sigue en pie y puedes leer el mensaje de error; si el código se bloquea en Arduino, la placa se detiene en silencio, aunque un temporizador watchdog puede reiniciarla sola.

Tiempo de arranque y cortes de corriente

En cuanto das corriente a un Arduino, tu programa empieza en menos de un segundo; incluso al pulsar el botón de reset, el bootloader solo espera un instante. La Raspberry Pi primero carga su bootloader, luego el núcleo de Linux y los servicios; según el modelo y la velocidad de la tarjeta SD, tarda entre 15 y 40 segundos en llegar al escritorio. Esto importa en dispositivos que deben funcionar justo después de un corte de luz, como un timbre, una alarma o un sistema de riego. Apagarla es todavía más delicado: Linux escribe constantemente en la tarjeta SD y, si la corriente se corta en mitad de una escritura, el sistema de archivos puede dañarse y la Pi quizá no vuelva a arrancar. Como el programa de Arduino está fijo en la memoria flash, puedes desenchufarlo cuando quieras.

Consumo y funcionamiento con baterías

En consumo, la diferencia es de 10 a 30 veces. Una Raspberry Pi 5 gasta unos 3 W en reposo y 7–8 W con el procesador a plena carga, y aún más si añades un disco USB y una cámara. Un Arduino Uno consume unos 50 mA, es decir, 0,25 W a 5 V, y una Pico alrededor de 0,1 W. En la tabla de abajo verás los tiempos de funcionamiento aproximados con una batería externa (power bank) de 10 000 mAh. El cálculo es este: los 10 000 mAh de la etiqueta se refieren a celdas de 3,7 V, unos 37 Wh; tras las pérdidas de la conversión a 5 V quedan unos 30 Wh útiles. Divide esa cifra entre el consumo de la placa en vatios. Para tu propio circuito, usa la calculadora de duración de batería.

Pines GPIO y entradas analógicas

El conector de 40 pines de la Raspberry Pi tiene 28 GPIO; GPIO 0 y 1 están reservados para la EEPROM de identificación de las placas HAT y normalmente no se usan. Estos pines trabajan a 3,3 V, no toleran 5 V y solo pueden dar unos pocos miliamperios por pin (como mucho unos 16 mA); puedes encender un LED con una resistencia en serie, pero no deberías mover directamente la bobina de un relé ni un motor. La mayor carencia es la falta de entradas analógicas: en la Pi no existe un equivalente a analogRead, así que para leer un sensor analógico como un potenciómetro, una LDR o un sensor de humedad del suelo necesitas un chip ADC externo. El Arduino Uno tiene 6 entradas analógicas y casi cualquier sensor de 5 V se conecta directamente.

Hay dos maneras de conectar un sensor analógico a la Pi. La primera es usar un módulo ADC como el MCP3008 de 8 canales y 10 bits por SPI o el ADS1115 de 4 canales y 16 bits por I2C; la librería gpiozero es compatible con el MCP3008 de serie. La segunda es conectar los sensores a un Arduino o una Pico y enviar las lecturas a la Pi por USB; más abajo tienes el código. Cómo funciona la lectura analógica lo explica el artículo ¿Qué es un ADC?, y los mapas de pines de las placas están en la herramienta Pinout.

Lenguaje de programación y entorno de desarrollo

Arduino se programa con el lenguaje Arduino, basado en C/C++: escribes el código en el Arduino IDE de tu ordenador, se compila y se carga en la placa por USB. En la Raspberry Pi, el código se escribe y se ejecuta en la propia Pi, sin un paso de carga aparte. El lenguaje más usado es Python, y Raspberry Pi OS trae ya instalados el editor Thonny y la librería gpiozero. También puedes usar cualquier lenguaje que funcione en Linux, como C, C++, Node.js, Go o Java. Así queda en Python en la Pi un programa de "el LED se enciende mientras pulsas el botón":

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

Conecta el pulsador entre GPIO27 y GND, y el LED a GPIO17 con una resistencia de 220 Ω; la clase Button activa por sí sola la resistencia pull-up interna. Guarda el archivo como buton_led.py y ejecútalo escribiendo python3 buton_led.py en el terminal. Ojo: en la Raspberry Pi 5 los GPIO se gestionan a través del nuevo chip RP1, por lo que la antigua librería RPi.GPIO no funciona y falla con "RuntimeError: Cannot determine SOC peripheral base address"; usa gpiozero en los proyectos nuevos. Si en Raspberry Pi OS actual pip install da el error "externally-managed-environment", instala el paquete con sudo apt install python3-... o crea un entorno virtual (venv). En la Raspberry Pi Pico aprovechas los mismos conocimientos de Python con MicroPython.

Tiempo real: ¿por qué Arduino para motores y sensores?

Como Linux reparte el procesador entre programas, tu código en Python puede quedarse en pausa unos milisegundos de vez en cuando, y no puedes saber cuándo ocurrirá. Para una página web da igual, pero para el hardware que depende de la temporización es un problema serio. Algunos ejemplos concretos:

• Sensor de distancia HC-SR04: El sonido tarda unos 58 µs en ir y volver por cada centímetro de distancia. Si se cuela un retraso de 100 µs mientras mides el eco, la lectura se desvía 1,7 cm; en la Pi estas desviaciones son habituales.
• Servomotor: Un servo se posiciona con un pulso de 1–2 ms dentro de una señal de 50 Hz, y 1 grado equivale a unos 5,5 µs. Un servo controlado con PWM por software desde la Pi tiembla; con Arduino se queda quieto.
• Tira LED WS2812B: Cada bit dura 1,25 µs y la temporización exige una precisión de 0,15 µs; la Pi solo lo consigue con el hardware SPI o PWM y DMA, mientras que Arduino y la Pico la controlan directamente.
• Motores paso a paso y encoders: Miles de pulsos de paso por segundo o las señales rápidas de un encoder se capturan sin perder ninguno en Arduino gracias a las interrupciones.

¿Cuál elegir para cada proyecto?

La cámara y el procesamiento de imagen son el punto fuerte de la Raspberry Pi. La Camera Module 3 de 12 MP con enfoque automático se conecta al conector de cámara con un cable plano; puedes hacer una foto con rpicam-still -o foto.jpg y, con las librerías Picamera2 y OpenCV, detectar movimiento, seguir colores, leer códigos QR o reconocer caras en Python. Para modelos de IA más pesados existen placas aceleradoras como la AI HAT+ o la AI Camera, que procesa la imagen dentro de la propia cámara. Los conectores de cámara de la Raspberry Pi 5 son más pequeños (22 pines) que en los modelos anteriores, así que las cámaras antiguas necesitan un cable adaptador adecuado. Los 2 KB de RAM del Arduino Uno, en cambio, no bastan ni para una foto pequeña; si solo quieres hacer fotos y enviarlas por Telegram, la barata ESP32-CAM es un buen término medio.

En sensores y motores, en cambio, Arduino prácticamente no tiene rival. Como trabaja a 5 V, la mayoría de los módulos del mercado, como el HC-SR04, los módulos de relé, el driver de motores L298N o las pantallas LCD de caracteres, se conectan sin circuitos adicionales, y los shields de motores, relés y sensores se montan directamente sobre la placa. En un coche robot, Arduino lee el sensor de distancia decenas de veces por segundo y detiene los motores en el instante en que ve un obstáculo; ese tiempo de reacción nunca depende de lo ocupado que esté un sistema operativo. Por el mismo motivo, los servomotores y los motores paso a paso funcionan con suavidad en Arduino.

Usar las dos juntas: Raspberry Pi + Arduino

En la mayoría de los proyectos avanzados, la mejor solución es combinar ambas. Piénsalo como el cuerpo humano: la Raspberry Pi es el cerebro; procesa la cámara, se conecta a internet, guarda registros y toma decisiones. Arduino es la médula espinal y los músculos; lee los sensores, mueve los motores y, ante una emergencia, reacciona por reflejo sin preguntar a la Pi. Por ejemplo, en un coche robot con cámara, la Pi encuentra la línea en la imagen y envía la orden "gira a la izquierda"; Arduino la convierte en velocidades de motor y se detiene por su cuenta si aparece un obstáculo. Las formas habituales de conectar las dos placas son:

1. Carga en la placa el código de Arduino de abajo desde tu ordenador (también puedes cargarlo desde la Pi con arduino-cli).
2. Conecta el Arduino a la Pi con un cable USB y averigua el nombre del puerto escribiendo ls /dev/ttyACM* /dev/ttyUSB* en el terminal. Un Uno original suele aparecer como /dev/ttyACM0 y los clones con chip CH340 como /dev/ttyUSB0.
3. Si la librería pyserial no está instalada, instálala con sudo apt install python3-serial.
4. Si tu usuario no puede acceder al puerto serie, escribe sudo usermod -a -G dialout $USER y después cierra la sesión y vuelve a entrar.
5. Guarda el código Python como pi_arduino.py y ejecútalo con python3 pi_arduino.py; si el monitor serie del Arduino IDE está abierto, ciérralo 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

Cada 500 ms el Arduino envía una línea del tipo "A0:512" y escucha las órdenes "LED1" o "LED0" terminadas en salto de línea; como usa millis(), esperar órdenes nunca retrasa las mediciones. En el lado de Python, la línea time.sleep(2) es importante: cuando la Pi abre el puerto serie, el Arduino se reinicia automáticamente y lo que se envía en los dos primeros segundos se pierde. Ajusta el umbral de 300 a tu sensor; según cómo hayas conectado la LDR, el valor puede subir o bajar en la oscuridad. Para más detalles sobre la comunicación serie, consulta Comunicación serie entre Arduino y Python y ¿Qué es UART?.

El lugar de la Raspberry Pi Pico: Raspberry Pi de nombre, microcontrolador de naturaleza

Este es el punto que más se confunde. Aunque la fabrica Raspberry Pi, la Raspberry Pi Pico no es un ordenador, sino una placa con microcontrolador como Arduino: no tiene sistema operativo, arranca al instante, consume unos 0,1 W y funciona en tiempo real. En su interior lleva el chip de doble núcleo RP2040 diseñado por la propia Raspberry Pi (la Pico 2 usa el RP2350 a 150 MHz). Frente al Arduino Uno tiene mucha más RAM (264 KB), un ADC de 12 bits y bloques PIO para tareas de temporización, y se programa con MicroPython, C/C++ o el Arduino IDE. Con sus 4 $ es más barata que un Arduino Uno, pero como trabaja a 3,3 V hay que tener cuidado con los módulos de 5 V. Para más detalles, lee ¿Qué es la Raspberry Pi Pico?.

La mayor ventaja de la Pico en esta comparación es que trabaja al mismo nivel de 3,3 V que la Raspberry Pi: puedes conectar sus pines UART directamente a la Pi sin conversor de nivel, o enchufarla por USB y usarla igual que un Arduino. El código MicroPython de abajo envía datos con el mismo formato "A0:valor" que el código de Arduino anterior y escucha las mismas órdenes del LED, así que el script de Python de la Pi funciona sin cambiar nada. Guarda el código en la Pico como main.py con Thonny y luego cierra Thonny para que el puerto serie quede libre para el script de la 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))

Además, las fronteras se difuminan cada vez más. En 2025 Arduino presentó el Arduino UNO Q, que une los dos mundos en una sola placa: esta placa con formato Uno lleva un procesador Qualcomm de cuatro núcleos con Debian Linux junto a un microcontrolador STM32U585 que ejecuta sketches de Arduino en tiempo real. Es decir, la arquitectura "Pi + Arduino" ya cabe en una única placa. Aun así, la lógica no cambia: la parte Linux se ocupa de la red, la imagen y la aplicación, y la parte del microcontrolador de los pines y la temporización. Quien entiende las diferencias de este artículo saca mucho más partido a estas placas híbridas.

Errores frecuentes y falsos mitos

• "La Raspberry Pi Pico es una Raspberry Pi pequeña": No lo es; no ejecuta Linux ni tiene salida HDMI. La Pico es un microcontrolador y pertenece a la misma categoría que Arduino.
• Conectar una señal de 5 V a la Pi: Si el pin ECHO del HC-SR04 o la línea TX del Arduino van directos a un GPIO, el pin o incluso el procesador pueden dañarse para siempre; usa un divisor de tensión.
• Buscar analogRead en la Pi: La Raspberry Pi no tiene entradas analógicas; usa un MCP3008, un ADS1115 o un Arduino o una Pico como ayudante.
• Apagar desenchufando: Es la forma más rápida de estropear una tarjeta SD; usa sudo poweroff siempre.
• Alimentar una Pi 5 con el cargador del móvil: Con una fuente que no da 5 V 5 A, la Pi 5 limita la corriente total de los puertos USB a 600 mA y puede reiniciarse con carga.
• El error "Permission denied: '/dev/ttyACM0'": Tu usuario no está en el grupo dialout; ejecuta el comando usermod y vuelve a iniciar sesión. Con "Device or resource busy", otro programa (el monitor serie o Thonny) está ocupando el puerto.
• Pensar que "Arduino está anticuado, ya existe la Pi": No son rivales, sino herramientas para trabajos distintos; la mayoría de los aparatos, desde una lavadora hasta un coche, siguen funcionando hoy con microcontroladores.

En resumen, la Raspberry Pi es un ordenador que piensa y ve, y Arduino un controlador que convierte al instante lo que percibe en acción; un buen proyecto suele combinar los puntos fuertes de ambos. En la app BlueGrays encontrarás decenas de proyectos con Arduino, ESP32 y Raspberry Pi Pico, desde LED y sensores hasta robots y montajes Wi-Fi, cada uno con su esquema paso a paso y el código listo, y puedes empezar por los gratuitos.