Arduino (Español) - ArchWiki

Jump to content

# Arduino (Español)

From ArchWiki

Artículos relacionados

- AVR
- ESP32

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.

Nota Algunas placas, notablemente las Pro Mini, no presentan USB como todas y deben ser programadas con hardware adicional.
Tip Puede ser útil monitorear los mensajes del kernel con `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.

Nota Recuerda mantener cualquier programa de monitoreo serial cerrado durante la carga de código en orden para liberar el puerto serial para el programador.

## 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

Nota Como autoreset en conexión serial está activado por defecto en muchas placas, necesitas desactivar está función si quieres comunicarte directamente con tu placa con el último comando en vez de un emulador de terminal (arduino IDE, screen, picocom...). Si tienes una placa Leonardo, no te preocupes por esto, ya que it no se autoresetea. Si tienes una placa Uno, conecta un capacitor de 10 µF entre los pines RESET y GND. Si tiene otra placa, conecta un resistor de 120 ohms entre los pines RESET y 5V. Vea https://playground.arduino.cc/Main/DisablingAutoResetOnSerialConnection para más detalles.

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.

## Vea también

- Sitio web oficial
- Guía de Inicio IDE v2
- https://answers.ros.org/question/9097/how-can-i-get-a-unique-device-path-for-my-arduinoftdi-device/

Categories:

- Development (Español)
- Science (Español)

Arduino (Español)
Add topic