openpilot es una colección de procesos independientes que se comunican via cereal (basado en Cap’n Proto + ZMQ). Los procesos principales son:
camerad → captura frames de cámara → publica en msgq
modeld → consume frames → corre la red neuronal → publica plan de manejo
controlsd → consume el plan → genera CarControl (steering/gas/brake)
pandad → consume CarControl → lo serializa a CAN → lo manda al Panda via USB
boardd → idem, maneja la comunicación física con el Panda
Para correr sin comma device necesitás reemplazar dos capas:
Sí, el Panda es prácticamente el único componente de comma que necesitás comprar. Todo lo demás se resuelve con hardware genérico.
| Componente | Qué comprar | Para qué sirve |
|---|---|---|
| PC/laptop con Linux | El tuyo (Arch ya está) | Corre todos los procesos de openpilot |
| Panda | ~$99 en comma.ai/shop | Interfaz USB ↔ CAN bus del auto. Es open source hardware |
| Arnés para tu auto | ~$100-150 en comma.ai/shop | Se conecta entre el conector ADAS del auto y el Panda |
| Webcam USB | Logitech C920/C615, NexiGo N60 | Mínimo 720p, mínimo ~78° FOV. Una sola alcanza |
| Cable USB-A a USB-A | Cualquiera | PC → Panda |
El Panda es open source (firmware en GitHub: commaai/panda), por lo que en teoría podrías fabricar uno vos, aunque comprar el oficial es más práctico.
Antes de gastar un peso, confirmá en https://comma.ai/vehicles si tu auto está soportado. Para que funcione, el auto necesita:
Si tu auto tiene ACC y alguna forma de LKAS/LCA, casi con certeza tiene las interfaces necesarias para que openpilot funcione.
openpilot se desarrolla y testea sobre Ubuntu 24.04, que es el target principal aparte del hardware embebido. Corriendo en cualquier otro sistema no está recomendado y probablemente requiera modificaciones.
Para Arch, la aproximación más limpia es un contenedor o chroot Ubuntu 24.04, o bien instalar dependencias manualmente. La ruta DIY:
# Clonar el repo
git clone https://github.com/commaai/openpilot.git
cd openpilot
git submodule update --init --recursive
# Instalar dependencias (en Arch, equivalentes AUR/pacman)
# El script oficial es para Ubuntu pero podés leerlo:
cat tools/ubuntu_setup.sh
# Dependencias clave en Arch:
sudo pacman -S python python-pip clang cmake capnproto \
zeromq openssl libyaml eigen ffmpeg v4l-utils \
qt6-base qt6-multimedia vulkan-icd-loader
pip install -r tools/requirements.txt
pip install -r requirements.txt
# Build (usa scons internamente)
scons -j$(nproc)
Si hay problemas de compatibilidad en Arch, la alternativa más limpia es usar systemd-nspawn o Docker con Ubuntu 24.04 para no pelear contra diferencias de libc/capnproto.
El Panda es un dispositivo USB que expone la interfaz CAN del auto. En Linux:
# Después de conectar el Panda via USB:
lsusb | grep -i comma
# Debería aparecer algo como: Bus 001 Device 004: ID bbaa:ddcc
# Reglas udev (si no tenés acceso sin sudo):
# El repo del panda trae udev rules:
git clone https://github.com/commaai/panda
cd panda
sudo cp drivers/linux/panda.rules /etc/udev/rules.d/
sudo udevadm control --reload-rules
# Verificar que openpilot detecta el panda:
python -c "import panda; p = panda.Panda(); print(p.get_version())"
El arnés se conecta en el conector del módulo de cámara ADAS (detrás del espejo retrovisor, típicamente). Interrumpe la señal entre la cámara de fábrica y la ECU, y añade acceso al CAN bus. El proceso no requiere modificaciones permanentes al vehículo y es completamente reversible.
Auto [conector ADAS] ─── Arnés ─── [pasa la señal al módulo original]
└──── [OBD-C / USB-C] ──── Panda ──── [USB-A] ──── PC
Se necesita una webcam USB de al menos 720p y 78 grados de FOV (ej. Logitech C920/C615, NexiGo N60). El setup es: conectar la cámara primero, luego conectar el Panda.
# Verificar que la cámara es reconocida:
v4l2-ctl --list-devices
# Ejemplo: /dev/video0
# Correr openpilot con webcam:
cd openpilot
USE_WEBCAM=1 python system/manager/manager.py
# Si tenés múltiples cámaras y la road camera no es /dev/video0:
USE_WEBCAM=1 ROAD_CAM=1 python system/manager/manager.py
# (ROAD_CAM=N usa /dev/videoN)
# Si querés también driver monitoring camera:
USE_WEBCAM=1 ROAD_CAM=0 DRIVER_CAM=1 python system/manager/manager.py
Arrancá el auto, el UI debería mostrar la vista de la cámara, y vas a entrar en proceso de calibración automática.
openpilot necesita calibrar la posición de la cámara respecto al auto. Esto lo hace automáticamente mientras manejás ~10-20 km en ruta recta. El proceso corre en el servicio calibrationd y guarda el estado en /data/params.
El port de webcam demuestra la independencia de plataforma de openpilot, pero las conexiones USB poco confiables y las webcams que se mueven son una preocupación seria. Las webcams también son diferentes a las cámaras con las que se entrenaron los modelos, por lo que se espera que openpilot funcione significativamente peor con este setup.
Resumiendo las limitaciones reales:
[webcam USB] → camerad (USE_WEBCAM=1)
↓ msgq (ZMQ)
modeld (red neuronal, corre en CPU/GPU)
↓ msgq
controlsd (control PID/MPC)
↓ msgq
pandad → [Panda USB] → [Arnés] → [CAN bus del auto]
↓
ECU de dirección / acelerador / freno
Si tu auto está en la lista soportada, el mínimo que necesitás gastar es el Panda (~$99) + el arnés para tu modelo (~$100-150). Todo lo demás ya lo tenés. ¿Qué auto tenés?
Perfecto, ahora tengo todo lo que necesito para darte una respuesta realmente técnica y detallada. Acá va:
openpilot es una colección de procesos independientes que se comunican via cereal (basado en Cap’n Proto + ZMQ). Los procesos principales son:
camerad → captura frames de cámara → publica en msgq
modeld → consume frames → corre la red neuronal → publica plan de manejo
controlsd → consume el plan → genera CarControl (steering/gas/brake)
pandad → consume CarControl → lo serializa a CAN → lo manda al Panda via USB
boardd → idem, maneja la comunicación física con el Panda
Para correr sin comma device necesitás reemplazar dos capas:
Sí, el Panda es prácticamente el único componente de comma que necesitás comprar. Todo lo demás se resuelve con hardware genérico.
| Componente | Qué comprar | Para qué sirve |
|---|---|---|
| PC/laptop con Linux | El tuyo (Arch ya está) | Corre todos los procesos de openpilot |
| Panda | ~$99 en comma.ai/shop | Interfaz USB ↔ CAN bus del auto. Es open source hardware |
| Arnés para tu auto | ~$100-150 en comma.ai/shop | Se conecta entre el conector ADAS del auto y el Panda |
| Webcam USB | Logitech C920/C615, NexiGo N60 | Mínimo 720p, mínimo ~78° FOV. Una sola alcanza |
| Cable USB-A a USB-A | Cualquiera | PC → Panda |
El Panda es open source (firmware en GitHub: commaai/panda), por lo que en teoría podrías fabricar uno vos, aunque comprar el oficial es más práctico.
Antes de gastar un peso, confirmá en https://comma.ai/vehicles si tu auto está soportado. Para que funcione, el auto necesita:
Si tu auto tiene ACC y alguna forma de LKAS/LCA, casi con certeza tiene las interfaces necesarias para que openpilot funcione.
openpilot se desarrolla y testea sobre Ubuntu 24.04, que es el target principal aparte del hardware embebido. Corriendo en cualquier otro sistema no está recomendado y probablemente requiera modificaciones.
Para Arch, la aproximación más limpia es un contenedor o chroot Ubuntu 24.04, o bien instalar dependencias manualmente. La ruta DIY:
# Clonar el repo
git clone https://github.com/commaai/openpilot.git
cd openpilot
git submodule update --init --recursive
# Instalar dependencias (en Arch, equivalentes AUR/pacman)
# El script oficial es para Ubuntu pero podés leerlo:
cat tools/ubuntu_setup.sh
# Dependencias clave en Arch:
sudo pacman -S python python-pip clang cmake capnproto \
zeromq openssl libyaml eigen ffmpeg v4l-utils \
qt6-base qt6-multimedia vulkan-icd-loader
pip install -r tools/requirements.txt
pip install -r requirements.txt
# Build (usa scons internamente)
scons -j$(nproc)
Si hay problemas de compatibilidad en Arch, la alternativa más limpia es usar systemd-nspawn o Docker con Ubuntu 24.04 para no pelear contra diferencias de libc/capnproto.
El Panda es un dispositivo USB que expone la interfaz CAN del auto. En Linux:
# Después de conectar el Panda via USB:
lsusb | grep -i comma
# Debería aparecer algo como: Bus 001 Device 004: ID bbaa:ddcc
# Reglas udev (si no tenés acceso sin sudo):
# El repo del panda trae udev rules:
git clone https://github.com/commaai/panda
cd panda
sudo cp drivers/linux/panda.rules /etc/udev/rules.d/
sudo udevadm control --reload-rules
# Verificar que openpilot detecta el panda:
python -c "import panda; p = panda.Panda(); print(p.get_version())"
El arnés se conecta en el conector del módulo de cámara ADAS (detrás del espejo retrovisor, típicamente). Interrumpe la señal entre la cámara de fábrica y la ECU, y añade acceso al CAN bus. El proceso no requiere modificaciones permanentes al vehículo y es completamente reversible.
Auto [conector ADAS] ─── Arnés ─── [pasa la señal al módulo original]
└──── [OBD-C / USB-C] ──── Panda ──── [USB-A] ──── PC
Se necesita una webcam USB de al menos 720p y 78 grados de FOV (ej. Logitech C920/C615, NexiGo N60). El setup es: conectar la cámara primero, luego conectar el Panda.
# Verificar que la cámara es reconocida:
v4l2-ctl --list-devices
# Ejemplo: /dev/video0
# Correr openpilot con webcam:
cd openpilot
USE_WEBCAM=1 python system/manager/manager.py
# Si tenés múltiples cámaras y la road camera no es /dev/video0:
USE_WEBCAM=1 ROAD_CAM=1 python system/manager/manager.py
# (ROAD_CAM=N usa /dev/videoN)
# Si querés también driver monitoring camera:
USE_WEBCAM=1 ROAD_CAM=0 DRIVER_CAM=1 python system/manager/manager.py
Arrancá el auto, el UI debería mostrar la vista de la cámara, y vas a entrar en proceso de calibración automática.
openpilot necesita calibrar la posición de la cámara respecto al auto. Esto lo hace automáticamente mientras manejás ~10-20 km en ruta recta. El proceso corre en el servicio calibrationd y guarda el estado en /data/params.
El port de webcam demuestra la independencia de plataforma de openpilot, pero las conexiones USB poco confiables y las webcams que se mueven son una preocupación seria. Las webcams también son diferentes a las cámaras con las que se entrenaron los modelos, por lo que se espera que openpilot funcione significativamente peor con este setup.
Resumiendo las limitaciones reales:
[webcam USB] → camerad (USE_WEBCAM=1)
↓ msgq (ZMQ)
modeld (red neuronal, corre en CPU/GPU)
↓ msgq
controlsd (control PID/MPC)
↓ msgq
pandad → [Panda USB] → [Arnés] → [CAN bus del auto]
↓
ECU de dirección / acelerador / freno
Si tu auto está en la lista soportada, el mínimo que necesitás gastar es el Panda (~$99) + el arnés para tu modelo (~$100-150). Todo lo demás ya lo tenés. ¿Qué auto tenés?
Muy buena pregunta, y es un tema que generó bastante drama en la comunidad.
El Neo era básicamente un OnePlus 3T rooteado corriendo NEOS (un Android customizado). comma publicó todo:
commaai/neoCualquiera podía replicar todo desde cero. Era genuinamente open source hardware.
Acá es donde se complicó. comma empezó a usar hardware propietario basado en Snapdragon (chip de Qualcomm) y:
Igual o peor. Hardware cerrado, diseño no publicado.
La razón nunca fue declarada oficialmente, pero la comunidad especula dos cosas:
1. Modelo de negocio — Si publican los esquemáticos, cualquiera fabrica el device por $50 y no le compran el comma four a $999.
2. Qualcomm — Los chips Snapdragon tienen restricciones de licencia que podrían impedir publicar ciertos aspectos del diseño.
| Componente | Open Source? |
|---|---|
| Software openpilot | ✅ MIT license |
| Firmware Panda | ✅ open source |
| agnos (el OS) | ✅ mayormente |
| opendbc (DBC files de autos) | ✅ |
| Esquemáticos del arnés (neo repo) | ✅ algunos modelos |
| Hardware del comma three/four | ❌ cerrado |
| Esquemáticos del Panda PCB | ⚠️ parcialmente (versiones viejas) |
Hay bastante tensión en la comunidad por esto. comma se presenta como empresa “open source” pero el hardware principal hace años que no lo es. El Panda sigue siendo el único puente viable entre openpilot y el auto, y aunque el firmware es libre, el diseño PCB de las versiones actuales no está publicado.
Por eso la comunidad de RetroPilot y otros intentaron diseñar clones desde cero usando el STM32F4 + transceiver CAN, que es exactamente lo que te mencioné antes — es posible hacerlo porque sabés qué chip usa y el firmware es libre, aunque no tengas los archivos KiCad del PCB oficial.
Excelente pregunta. Vamos a investigar bien esto.Ahora tengo todo claro. La respuesta es muy concreta:
Y esto es lo que hay publicado en commaai/neo:
| Archivo/Carpeta | Qué es |
|---|---|
board/ |
Esquemáticos EagleCAD del board CAN (STM32F205 + transceiver) — el precursor del Panda |
case/eon/ |
Archivos STL para imprimir la carcasa en 3D |
car_harness/ |
Esquemáticos PDF de arneses para Honda Nidec, Honda Bosch, Toyota |
car_harness/OBD-C.sch.pdf |
El conector OBD-C genérico |
car_harness/open_pinout.sch.pdf |
Pinout abierto para agregar tu propio auto |
El Neo es una plataforma de investigación robótica open source. Está impulsada por un smartphone OnePlus 3 y una placa de interfaz CAN basada en STM32F205, en una carcasa impresa en 3D con refrigeración activa.
El firmware del Panda está en GitHub (commaai/panda) y es open source. Pero los archivos KiCad/EagleCAD del PCB de las versiones actuales (Panda Black, el que se vende hoy) no están publicados como sí lo estaba el board del Neo.
Lo que sí podés hacer: el firmware detecta el tipo de hardware con detect_board_type(), y soporta múltiples variantes. Podés flashear ese firmware en un STM32F405 genérico de AliExpress (~$5) y conectarle un transceiver CAN — básicamente estás reconstruyendo el Neo board con chips modernos.
[OnePlus 3T] ← hardware que ya no sirve, openpilot lo droppeó
↓ reemplazado por
[Tu PC con Arch] + [webcam USB] ← el "compute" moderno equivalente
↓ conectado via USB a
[STM32F405 + SN65HVD230] ← clon del Panda, firmware de commaai/panda
↓ conectado via conector propietario a
[Arnés DIY con esquemáticos de commaai/neo/car_harness]
↓
[CAN bus de tu auto]
El límite real no es el hardware sino el software: openpilot moderno ya no soporta el OnePlus 3T, pero eso no importa porque vos usás tu PC. Lo que sí podés replicar libremente es todo el stack de interfaz CAN usando los archivos publicados en el repo neo + el firmware del Panda.
¿Qué auto tenés? Con eso te digo si hay un arnés ya diseñado en el repo o si hay que hacerlo desde el open_pinout.sch.pdf.
Acá la respuesta honesta: videos específicos de openpilot corriendo en PC con webcam en un auto real son escasos. Lo que encontré:
1. “Openpilot with PC Webcam is so close!” (Oct 2024)
youtube.com/watch?v=ZK4mmyX1saQ
Alguien intentando correr openpilot con webcam en PC en un auto real. Es un short/clip, no un tutorial completo, pero es exactamente lo que buscás — del año pasado.
2. “Building a Self Driving Car EP1 - comma neo w/ openpilot” (2017)
youtube.com/watch?v=PwOnsT2UW5o
El tutorial clásico de construir el Neo desde cero. Está desactualizado pero muestra el proceso físico de armar el hardware.
3. “openpilot in the simulator!” (2020)
youtube.com/watch?v=c2plaUSx2tk
El video oficial de comma corriendo openpilot con webcam en PC + CARLA simulator. No es en un auto real pero muestra el setup.
La razón es simple: el setup PC+webcam+Panda funciona pero nadie lo termina de hacer andar bien sin el hardware oficial, entonces la mayoría no graba el resultado. El issue de GitHub que encontré lo dice explícitamente:
"$999 is still a bit much for casual interest in openpilot. Let’s develop a cheap kit… panda + car harness + webcam plugged into a laptop."
Eso fue abierto en abril 2025 — o sea que comma misma reconoce que este setup DIY no está bien documentado todavía.
Un ingeniero de hardware de comma publicó en diciembre 2024 un blog post donde instaló openpilot en un Volvo 940 de 1993 — un auto sin ningún CAN bus moderno, fabricando actuadores de dirección desde cero. Prometió open sourcear el código. Es el nivel máximo de DIY:
practicapp.com/carbagepilot-part1/
Para aprender visualmente, el mejor recurso es el Discord oficial de comma (discord.comma.ai) — canal #developer y #community-hardware. Ahí hay gente que comparte clips y experiencias de setups alternativos que no llegan a YouTube.
¿Querés que te arme un roadmap de qué hacer primero si quisieras intentar esto con tu auto?
El blog solo tiene la Parte 1 publicada por ahora. Pero leí todo el artículo completo. Te lo explico:
Robbe Derks — ingeniero de hardware en comma.ai durante 5 años. O sea no es un random, es literalmente alguien que construyó el hardware interno de comma. Su GitHub es github.com/robbederks.
Decidió participar en la “Carbage Run”, una travesía de 6 días por Suecia hasta el círculo polar con autos que tienen más de 20 años y valor menor a €1000. La ruta completa, incluyendo el viaje desde Bélgica, implicaría manejar aproximadamente 6000 km en poco más de una semana, frecuentemente en condiciones difíciles.
Y se le ocurrió la idea obvia: ¿por qué no hacerlo autónomo?
El Volvo 940 de 1993 tiene muy poca electrónica: la dirección es hidráulica, el acelerador está conectado al carburador por un cable bowden, y el freno usa asistencia de vacío.
Sin CAN bus, sin EPS, sin nada. Un auto completamente analógico. Entonces tuvo que retrofitear actuadores modernos uno por uno.
Retrofitó un actuador de dirección asistida eléctrica (EPS) y su ECU de un Toyota Corolla 2020. Cortaron la columna de dirección original del Volvo y soldaron los splines del Corolla en el medio. El EPS solo necesita GND, 12V constante (fusible de 80A), una señal de “ignición” y CAN al sensor de ángulo.
También instaló un sensor de ángulo de dirección externo del Corolla para darle a openpilot la referencia absoluta del volante.
Reemplazó el sistema de vacío original con un Bosch iBooster, el mismo sistema que usa Tesla. Para su sorpresa, el patrón de agujeros del iBooster coincidió perfectamente con el del Volvo sin necesitar una placa adaptadora.
También prometió open sourcear el trabajo de hacer el iBooster controlable via CAN fuera de su contexto Tesla original — eso todavía no está publicado.
Para el acelerador, no encontró una solución automotriz apropiada. Compró un servo RC impermeable de AliExpress y su padre mecanizó una polea que se monta sobre él. Dos cables conectados a la válvula de aire del carburador: el que jala más fuerte gana, lo que permite al conductor anular el sistema simplemente pisando más fuerte el acelerador.
También instaló un sensor de radar Continental de Tesla detrás de la parrilla delantera. Si bien el ACC solo con visión funciona en openpilot, poder contar con un radar real hace la experiencia más suave y consistente.
Todavía no completamente. El blog tiene solo la Parte 1 (actuadores mecánicos). El autor prometió:
El blog solo tiene esa parte publicada a mayo 2026. Dado que la carrera era en enero 2025, es probable que la parte 2 y 3 estén demoradas pero vengan. Su GitHub (robbederks) es donde eventualmente aparecerá todo.
Lo que hizo es el nivel máximo de DIY con openpilot:
Auto de 1993 completamente analógico
+ EPS de desarmadero ($junkyard)
+ iBooster de Tesla (segundo mano)
+ Servo RC de AliExpress ($20)
+ Radar de Tesla (junkyard)
+ comma device + openpilot
= Auto semi-autónomo en 6000km de ruta invernal
Sin comprar hardware de comma (excepto posiblemente el Panda). Todo el compute y la lógica de conducción: openpilot. Todo el hardware físico: piezas de desarmadero y AliExpress.