Arduino (Español)
Arduino es una plataforma de prototipos electrónicos de código abierto basada en la flexibilidad, hardware fácil de usar y software. Está destinado a artistas, diseñadores, entusiastas y cualquiera interesado en la creación de objetos o entorno interactivos.
Una vez conectado y configurado el usuario puede realizar tareas de leer/escribir sobre la conexión serial establecida. Algunos ejemplos son la interfaz a través de UART utilizando un programa de monitoreo serial, o programando el microcontrolador. Escribir, compilar y cargar tu código es facilitado usando el oficial Arduino IDE, el cual está disponible en los repositorios oficiales. Igualmente el usuario puede usar un compilador y programa preferido para programar el microcontrolador.
Instalación
- Instale arduino-cli para la CLI oficial.
- Instale arduino-ide-binAUR para la GUI oficial.
- Podrías necesitar cargar el módulo
cdc-acm.
Arduino IDE 1.x
La siguiente sección solo aplica a la versión 1.x del IDE. Sin embargo, puede ser posible adaptar algo de esto para el nuevo IDE.
Placas AVR
Para usar placas AVR como la Arduino Uno puedes instalar arduino-avr-coreAUR opcionalmente para usar avr-gcc upstream de Arch Linux en vez del viejo avr-core incluido. Si continúas queriendo usar el antiguo arduino-core necesitas instalar esto en el administrador de placas. Siempre puedes cambiar entre los diferentes cores en el menú Tools > Board.
Pinoccio Scout
Pinoccio Scouts también puede ser programado usando el Arduino IDE. Las instrucciones pueden ser encontradas aquí. Alternativamente puedes instalar arduino-pinoccioAUR.
Intel Galileo
Para usar las placas Intel Galileo con Arch Linux instale el Arduino IDE y descarga el paquete de las herramientas de Galileo vía Tools > Board > Board Manager. Para arreglar la instalación puedes seguir este post en GitHub.
Arduino IDE 1.x o 2.x
Estos pasos deberían ser válidos para ambas versiones del IDE.
Placas AVR
Las placas AVR son instaladas automáticamente por la versión 2.x del IDE sin embargo en las ambas versiones 1.x y 2.x las placas AVR pueden ser manejadas desde el manejador de placas.
SparkFun
Para usar placas SparkFun como la Pro Micro necesitas descargar sus definiciones de placa. Más información aquí y aquí.
RedBear Duo
Podrías necesitar instalar perl-archive-zip u obtendrá un error sobre crc32 desaparecido.
Configuración
La mayoría de placas Arduino tiene un puerto USB el cual puede ser usado para establecer una conexión serial. Esta conexión serial habilita al usuario para programar la placa. El microcontrolador principal de las mayoría de Arduinos, sin embargo, no tienen una interfaz USB integrada. Por lo tanto, la placa es usualmente equipada con un chip USB a serial entre el microcontrolador principal y el puerto USB.
Para alcanzar la conexión serial como USB, la mayoría de Arduinos genuinos están equipados con otro microcontrolador ATmega (ej: ATmega16U2). Ambos chips registran ellos mismos a través de USB como un dispositivo ACM, y como talm Linux usará el módulo cdc_acm. El Arduino se mostrará entonces como /dev/ttyACMx.
Las placas Arduino no genuinas ahorran en la interfaz del chip. Ellas usualmente son equipadas con un WCH CH340x chino o una falsificación de los modelos anteriormente mencionados. El CH340x se presenta como un dispositivo UART propietario a través de USB. Aquí el módulo ch341 es usado, haciendo que el Arduino se muestre como /dev/ttyUSBx. Este patrón de nombramiento puede ser personalizado por la modificación de las reglas udev.
Algunas placas pueden ser equipadas con un microcontrolador principal el cual se presenta como una interfaz USB nativa. Independientemente de si la placa tiene una interfaz de chip dedicado o no, las placas genuinas vendrán de fábrica con un cargador de arranque adecuado preinstalado. Tal que los cargadores de arranque automáticamente establezcan una conexión serian USB una vez son conectadas.
dmesg como la placa está siendo enchufada. Si una conexión correcta ha sido establecida, el puerto asignado puede ser leído en el mismo.Acceso serial
Para las placas que presentan un UART a través de USB, esto es necesario para habilitar acceso de lectura/escritura a el puerto serial a los usuarios[1]. Como es explicado en Udev#Allowing regular users to use devices, cree un archivo que contenga:
/etc/udev/rules.d/01-ttyusb.rules
ACTION!="remove", SUBSYSTEMS=="usb-serial", TAG+="uaccess"
Recargue las reglas de udev y reconecte el dispositivo Arduino. Antes de cargar al Arduino, esté seguro de seleccionar el puerto serial correcto, placa y procesador desde el menú Herramientas en 1.x y la opción Seleccionar placa (localizada en la parte superior del IDE) en 2.x.
stty
Preparar:
# stty -F /dev/ttyACM0 cs8 9600 ignbrk -brkint -imaxbel -opost -onlcr -isig -icanon -iexten -echo -echoe -echok -echoctl -echoke noflsh -ixon -crtscts
Envío de comandos a través de Terminal sin nueva línea después del comando:
# echo -n "Hello World" > /dev/ttyACM0
Leyendo lo que tu Arduino tiene para decirte:
$ cat /dev/ttyACM0
Arduino-Builder
También puedes compilar sketches de Arduino con la herramienta de línea de comandos arduino-builderAUR. En orden para usar el proporcionado arduino-avr-coreAUR con el avr-gcc de upstream y avrdude necesitas crear un pequeño archivo de configuración:
build.options.json
{
"fqbn": "archlinux-arduino:avr:uno",
"hardwareFolders": "/usr/share/arduino/hardware",
"toolsFolders": "/usr/bin"
}
Compila un sketch con:
$ arduino-builder -build-options-file build.options.json blink.ino
O pasa todas las opciones por línea de comandos:
$ arduino-builder -fqbn archlinux-arduino:avr:uno -hardware /usr/share/arduino/hardware -tools /usr/bin blink.ino
Alternativas al IDE
Arduino-CMake
Usando Arduino-CMake-Toolchain y CMake puedes construir firmware de Arduino desde la línea de comandos usando multiples sistemas de construcción. CMake te permite generar el sistema de construcción que encaje a lo que necesites, usando las herramientas que te gusten. Esto puede generar cualquier tipo de sistema de construcción, desde Makefiles simples, hasta proyectos completos para Eclipse, Visual Studio, XCode, etc.
Requerimientos: cmake, arduino, avr-gcc, avr-binutils, avr-libc, avrdude.
Makefile
En lugar de usar el IDE de Arduino, puedes usar otro editor y un Makefile.
Crea un directorio para programar tu Arduino y copia el Makefile en él. Puedes obtener una copia del Makefile en esta plantilla de GitHub.
Tendrás que modificarlo un poco para que refleje tu configuración. El Makefile es bastante intuitivo. Aquí tienes algunas líneas que podrías tener que editar:
PORT = normalmente /dev/ttyUSBx, donde x es el puerto serie USB al que está conectado tu Arduino. TARGET = nombre de tu sketch. ARDUINO = /usr/share/arduino/lib/targets/arduino.
Dependiendo de las funciones de la biblioteca que uses en tu sketch, es posible que tengas que compilar partes de la biblioteca. Para ello, debes editar tus archivos SRC y CXXSRC para incluir las bibliotecas necesarias.
Ahora debería poder make && make upload en su placa para ejecutar su boceto.
Arduino-mk
arduino-mk es otra alternativa al enfoque Makefile. Este habilita a los usuarios a tener un Makefile local que incluye Arduino.mk.
Para Arduino 1.5, intenta el siguiente Makefile local (porque la la estructura del directorio de la librería de Arduino 1.5 es un poco diferente):
ARDUINO_DIR = /usr/share/arduino ARDMK_DIR = /usr/share/arduino AVR_TOOLS_DIR = /usr AVRDUDE_CONF = /etc/avrdude.conf ARDUINO_CORE_PATH = /usr/share/arduino/hardware/archlinux-arduino/avr/cores/arduino ARDUINO_PLATFORM_LIB_PATH = /usr/share/arduino/hardware/archlinux-arduino/avr/libraries BOARDS_TXT = /usr/share/arduino/hardware/archlinux-arduino/avr/boards.txt ARDUINO_VAR_PATH = /usr/share/arduino/hardware/archlinux-arduino/avr/variants BOOTLOADER_PARENT = /usr/share/arduino/hardware/archlinux-arduino/avr/bootloaders BOARD_TAG = uno ARDUINO_LIBS = include /usr/share/arduino/Arduino.mk
En algunos casos podrías necesitar instalar avr-libc y avrdude.
Scons
Usando https://www.scons.org/ scons] junto con arscons es muy fácil compilar y cargar proyectos de Arduino desde la línea de comandos. Scons está basado en Python y necesitarás python-pyserial para usar la interfaz serial. Instala python-pyserial, scons, y arduino.
Esto obtendrá las dependencias que necesitas también. Crea el directorio del proyecto (por ejemplo: test), luego crea un archivo de proyecto de Arduino en tu nuevo directorio. Usa el mismo nombre del directorio y añade .ino (por ejemplo: test.ino). Obten el script SConstruct desde arscons y ponlo en tu directorio. Echa un vistazo en él y, si es necesario, editalo. Es un script de Python. Edita tu proyecto como te favorezca, luego ejecuta:
$ scons # Esto construirá el proyecto $ scons upload # Esto cargará el proyecto a tu Arduino
PlatformIO
PlatformIO es una herramienta escrita en Python para construir y cargar sketches para múltiples plataformas de hardware, en el momento de redactar este artículo, se trata de placas basadas en Arduino/AVR, TI MSP430 y TI TM4C12x. En un futuro próximo, el autor tiene previsto añadir una función de biblioteca que permita buscar e incluir bibliotecas directamente desde GitHub.
Instalación
Instale el paquete platformio-core
Uso
Lo siguiente está basado en Guía Oficial de Inicio de PlatformIO, la cual muestra como crear y cargar un proyecto de ejemplo.
Crea un nuevo directorio para el proyecto de platformio y entra en el directorio. Entonces ejecuta los siguientes comandos para inicializar el proyecto para una placa específica (aquí la megaatmega2560):
$ pio project init --board megaatmega2560
Esto descarga las herramientas y dependencias, y crea platformio.ini:
platformio.ini
; PlatformIO Project Configuration File [env:megaatmega2560] platform = atmelavr board = megaatmega2560 framework = arduino
Crea y añade código a main.cpp en la carpeta src/ como el código de ejemplo en la guía de inicio.
Entonces compila el código y carga esto a los dispositivos especificados en platformio.ini:
$ pio run $ pio run --target upload
Emacs
Es posible configurar Emacs como IDE.
Instale el paquete emacs-arduino-mode-gitAUR en orden para habilitar el arduino-mode en emacs.
Añade al script de inicio:
~/.emacs
;; arduino-mode
(require 'cl)
(autoload 'arduino-mode "arduino-mode" "Arduino editing mode." t)
(add-to-list 'auto-mode-alist '("\.ino$" . arduino-mode))
You can compile and upload the sketches using Arduino-mk (see above) with M-x compile make upload.
Recurso principal:
aquí.
Solución de problemas
Nombramiento consistente de dispositivos Arduino
If tiene más de un Arduino puede haberse enterado que sus nombres /dev/ttyUSB[0-9] son asignados en el order de conexión. En el IDE esto no es un gran problema, pero cuando tienes programado tu propio software para comunicar con un proyecto Arduino en el fondo esto puede ser molesto. Use las siguientes reglas udev para asignar enlaces simbólicos estáticos a tus Arduinos:
/etc/udev/rules.d/52-arduino.rules
SUBSYSTEMS=="usb", KERNEL=="ttyUSB[0-9]*", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6001", SYMLINK+="sensors/ftdi_%s{serial}"
Tus Arduinos deberán estar disponibles bajo nombres como /dev/sensors/ftdi_A700dzaF. Si quieres puedes también asignar nombres más significativos para varios dispositivos como esto:
/etc/udev/rules.d/52-arduino.rules
SUBSYSTEMS=="usb", KERNEL=="ttyUSB[0-9]*", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6001", ATTRS{serial}=="A700dzaF", SYMLINK+="arduino/nano"
el cual creará un enlace simbólico en /dev/arduino/nano al dispotivo con el número serial especificado.
Necesitas desconectar y reconectar tu Arduino para que esto tome efecto o ejecutar:
# udevadm trigger
Los pares habituales de idVendor/idProduct se pueden encontrar en /usr/share/arduino/hardware/archlinux-arduino/avr/boards.txt, dentro del paquete de distribución. Ten en cuenta que algunos de ellos (en particular los de FTDI) no son exclusivos de la plataforma Arduino. El uso del atributo serial es una buena forma de distinguir entre los distintos dispositivos.
Error abriendo el puerto serial
Es posible que veas el puerto serie al inicio del IDE, pero los LED de TX/RX no se encienden durante la carga. Quizás hayas cambiado previamente la velocidad de transmisión en el monitor serie a un valor que no es compatible. Edita ~/.arduino/preferences.txt para que serial.debug_rate tenga una velocidad diferente, como 115200.
Trabajando con Uno/Mega2560
El Arduino Uno y Mega2560 tienen una interfaz USB en la placa (un Atmel 8U2) que acetpa datos seriales, así que ellos acceden a través de /dev/ttyACM0 creado por el módulo del kernel cdc-acm cuando este es conectado.
El firmware 8U2 puede necesitar una actualización para facilitar comunicaciones seriales. Vea [2] Para más detalles y la respuesta #11 para un arreglo. El arduino bbs original, donde puedes encontrar una imagen explicando como obtener tu Uno en DFU, es ahora de solo lectura. Si no tienes una cuenta para ver la imagen, vea [3].
Puedes realizar una prueba general de funcionamiento de la Uno poniéndola en modo loopback y escribiendo caracteres en el monitor serie de Arduino a 115 200 baudios. Debería mostrarte los caracteres tal y como los has escrito. Para activarlo, conecta en cortocircuito los pines 0 -> 1 del lado digital y, mientras escribes, mantén pulsado el botón de reinicio o conecta en cortocircuito los pines GND -> RESET.
Puerto USB no reconocido con clones chinos baratos del Mega2560
Intenta instalando este driver: i2c-ch341-dkmsAUR.
Fallo al cargar: programador no está respondiendo
Cambiando los ajustes de procesador de ATmega328P a ATmega328P (Old Bootloader) (Vea Tools->Processor en Arduino IDE) puede ayudar con los fallos de carga.
Conflicto del puerto serial con brltty
Si el puerto serial para el Arduino no es visible como /dev/ttyUSB*, y el journal contiene lo siguiente cuando el dispositivo está conectado:
usb 3-1: usbfs: interface 0 claimed by ch341 while 'brltty' sets config #1 ch341-uart ttyUSB0: ch341-uart converter now disconnected from ttyUSB0
Entonces puede que necesites desinstalar el paquete brltty. Vea [4] para más detalles.
Error al cargar con Nano RP2040 Connect
Si la carga falla con el mensaje:
Failed uploading: uploading error: exit status 1
Has saltado #Acceso serial sigue las instrucciones para permitir a los usuarios el acceso de lectura y escritura al puerto serie.