Microprocesadores: apuntes

Notas conectando distintos procesadores al portátil y al IDE Arduino

Troubleshooting

Prueba a parar el infame ModemManager:

1

sudo systemctl stop ModemManager

Si tienes una versión antigua de brltty (brltty -V menor que 6.5) puedes probar a parar el servicio:

1

systemctl stop brltty-udev.service

attiny

Es necesario instalar libusb-0.1-4 en nuestro S.O.

1

sudo apt install libusb-0.1-4

También debemos crear el fichero /etc/udev/rules.d/49-digispark.rules con el siguiente contenido:

1

SUBSYSTEM=="usb", ATTR{idVendor}=="16d0", ATTR{idProduct}=="0753", MODE="0660", GROUP="dialout"

Una vez hecho esto lo attiny funcionan correctamente, pero son peculiares: hay que lanzar el download desde el arduino IDE con el dispositivo desconectado y conectarlo al puerto usb cuando nos lo indique el IDE.

Configuración en IDE Arduino

• Board: Digispark (Default - 16.5mhz)
• Port: No creo que importe
• Programmer: Micronucleous

ch340/ch341

Problemas con ModemManager

Añadimos además una linea al fichero 99-arduino.rules que queda así:

1
2
3
4
5
6
7
8

# for arduino brand, stop ModemManager grabbing port
ATTRS{idVendor}=="2a03", ENV{ID_MM_DEVICE_IGNORE}="1"
# for sparkfun brand, stop ModemManager grabbing port
ATTRS{idVendor}=="1b4f", ENV{ID_MM_DEVICE_IGNORE}="1"
# for ardupilot brand, stop ModemManager grabbing port
ATTRS{idVendor}=="2341", ENV{ID_MM_DEVICE_IGNORE}="1"
# for ch401, stop ModemManager grabbing port
ATTRS{idVendor}=="1a86", ENV{ID_MM_DEVICE_IGNORE}="1"

Estas reglas como indican los comentarios evitan que ModemManager capture estas marcas de dispositivos.

Problemas con Brltty

En Linux Mint Vera aparece un nuevo problema: El sistema usa una versión antigua (menor que 6.5) de Brltty (se puede comprobar ejecutando brltty -V) En esta versión el ch340 es reconocido como un transductor Braille y capturado por el Brltty. Si no queremos tener problemas con los Arduino con ch340 tenemos que editar el fichero /usr/lib/udev/rules.d/85-brltty.rules y comentar la linea que se corresponde con el Device ID del arduino:

1
2
3

# Device: 1A86:7523
# Baum [NLS eReader Zoomax (20 cells)]
# ENV{PRODUCT}=="1a86/7523/*", ENV{BRLTTY_BRAILLE_DRIVER}="bm", GOTO="brltty_usb_run"

Puedes recargar las reglas de dispositivos con el comando sudo udevadm control --reload-rules

Otra forma más expeditiva de terminar con el problema es desactivar completamente y para siempre el servicio brltty. Yo prefiero dejarlo configurado.

1
2
3
4
5
6
7
8

# Find-out the service
systemctl list-units | grep brltty

# Mask the service to avoid starting it in the future
systemctl mask brltty-udev.service

# Stop the service now
systemctl stop brltty-udev.service

Arduino Nano con ch341

• Board: Arduino Nano
• Processor: Depende, hay que probar combinaciones de procesador y bootloader
• Port: El que toque (ttyUSBn)
• Programmer: None

Arduino Pro mini

Hay que usar FTDI adapter, con el mio el cable va plano.

• Board: Arduino Pro or Pro mini
• Processor: atmega328P 5V 16mhz
• Port: El que toque (ttyUSBn)
• Programmer: None

Arduino IDE

Orígenes de bibliotecas configurados en el IDE Arduino

1
2
3
4
5
6
7

https://adafruit.github.io/arduino-board-index/package_adafruit_index.json
https://github.com/stm32duino/BoardManagerFiles/raw/master/STM32/package_stm_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://dl.espressif.com/dl/package_esp32_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
http://digistump.com/package_digistump_index.json
https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json

ESP8266

ESP8266 Arduino IDE

Seguimos esta página a ver a donde llegamos.

Añadimos este origen en el IDE Arduino: http://arduino.esp8266.com/stable/package_esp8266com_index.json

Works!! al menos el blink

La tarjeta que tenemos equipa un ESP-12E

• Board: NodeMCU 1.0 (ESP-12E Module)
• Port: El que toque (ttyUSBn)

Wemos D1 Lite

Wemos D1 Lite en Arduino IDE

• Board: LOLIN(Wemos) D1 mini Lite (con mi placa)
• Port: El que toque (ttyUSBn)
• Resto de parámetros por defecto

Funciona sin necesidad de virtualenv ni nada (cargado WifiScan)

Probas

Vamos a echar un ojo al código que nos propone Andreas Spiess en este video

Nos descargamos el repo de ejemplos de aqui y los programas corregidos por el señor Spiess de aqui

Aunque tampoco es que consigamos gran cosa mirando esto.

Vamos a instalar la Biblioteca para el sensor SHT30 descargando de el github

Y con este programilla funciona:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <WEMOS_SHT3X.h>

SHT3X sht30(0x45);

void setup() {

  Serial.begin(115200);

}

void loop() {

  if(sht30.get()==0){
    Serial.print("Temperature in Celsius : ");
    Serial.println(sht30.cTemp);
    Serial.print("Temperature in Fahrenheit : ");
    Serial.println(sht30.fTemp);
    Serial.print("Relative Humidity : ");
    Serial.println(sht30.humidity);
    Serial.println();
  }
  else
  {
    Serial.println("Error!");
  }
  delay(1000);

}

Para probar el OLED instalamos la librería Adafruit SSD 1306 Wemos mini OLED (de Adafruit y mcauser) también necesitamos la Adafruit GFX

NO FUNCIONA (creo que me he cargado el OLED)

Biblioteca para MQTT en ESP8266 https://github.com/knolleary/pubsubclient

ESP32

ESP32 Arduino IDE

Mi placa funciona en el IDE Arduino:

• Arrancar el IDE desde el virtualenv de PlatformIO (el IDE Arduino necesita pyserial instalado)
• Board: ESP32 Dev Module
• El resto por defecto

Probar con esto:

• https://diyprojects.io/getting-start-programming-esp32-platformio-ide/#.X3JHm5qxWV4
• Una guía: https://tttapa.github.io/ESP8266/Chap01%20-%20ESP8266.html

TTGO T4

• Instalamos la librería TFT_eSPI

Aparentemente hay que usar el ‘ESP32 Dev Module’ en el IDE Arduino

• Una demo con cryptomonedas
• Test code
• Hackaday
• Proyectos con Arduino y MicroPython

Andreas Spies

• Hoja comparativa
• Video comparativo

Mas cosas:

• esta puede ser útil o no
• Y esta igual

ESP32-C3

Para el Arduino IDE instalamos las bibliotecas latest siguiendo las instrucciones de este enlace

Basicamente:

1
2
3
4
5

mkdir -p ~/Arduino/hardware/espressif && \
cd ~/Arduino/hardware/espressif && \
git clone https://github.com/espressif/arduino-esp32.git esp32 && \
cd esp32/tools && \
python3 get.py

Reiniciamos el Arduino IDE si estaba arrancado y en el menú de Boards veremos la entrada ESP32 Arduino (in sketchbook) con las últimas versiones de las tarjetas.

STM32 Blue Pill

Los micros que yo tengo son STM32F103C8T6

Para programar el Blue Pill desde el Arduino IDE tenemos dos posibles ruta para añadir en nuestras Arduino Ide Preferences

• La de la comunidad stm32duino (ver el github): http://dan.drown.org/stm32duino/package_STM32duino_index.json esta versión soporta las placas Mapple. Con este origen en el Board Manager de Arduino nos aparecen dos opciones:
  • STM32F1xx/GD32F1xx boards by stm32duino
  • STM32F4xx boards by stm32duino
• La que parece oficial de STMicroelectronics:https://github.com/stm32duino/BoardManagerFiles/raw/main/package_stmicroelectronics_index.json. Puede comprobarse la dirección aquí. Con este origen en el Board Manager del IDE nos aparece una opción:
  • STM32 MCU based boards by STMicroelectronics con soporte para muchísimas placas

PlatformIO

Hacemos la instalación de Platformio a través de VS Code como detallamos en este documento.

Una vez que VS Code instala el Platformio tendremos disponible un entorno virtual con las herramientas que se han instalado en ~/.platformio/penv/. Yo me he creado un alias mypio que me permite activar ese entorno virtual, por ejemplo para acceder al Platformio CLI.

Platformio, por defecto, deja los proyectos en ~/Documents/PlatformIO/Projects

Probado con un Arduino Nano y funciona a la primera con VsCode:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

; PlatformIO Project Configuration File
;
;   Build options: build flags, source filter
;   Upload options: custom upload port, speed and extra flags
;   Library options: dependencies, extra library storages
;   Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html

[env:nanoatmega168]
platform = atmelavr
board = nanoatmega168
framework = arduino

ESP32

Framework ‘arduino’

Creamos un nuevo proyecto con

1
2
3
4

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino

Si es la primera vez que usas el framework (arduino en este caso) tardará un ratillo en descargarlo de internet.

Framework ‘ESP-IDF’

Creamos un nuevo proyecto con:

1
2
3
4

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = espidf

El código del blink:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <driver/gpio.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

#define LED_PIN 2

void led_blink(void *pvParams) {
    gpio_pad_select_gpio(LED_PIN);
    gpio_set_direction (LED_PIN,GPIO_MODE_OUTPUT);
    while (1) {
        gpio_set_level(LED_PIN,0);
        vTaskDelay(1000/portTICK_RATE_MS);
        gpio_set_level(LED_PIN,1);
        vTaskDelay(1000/portTICK_RATE_MS);
    }
}

void app_main() {
    xTaskCreate(&led_blink,"LED_BLINK",512,NULL,5,NULL);
}

Referencias

• PlatformIO samples (github)
• PlatformIO for Arduino, ESP8266, and ESP32 Tutorial (Andreas)
• PlatformIO and Wemos D1

Micropython

Instalación del editor Thonny

Para poder usar la biblioteca Tkinter en cualquier entorno virtual parece que tenemos que tener instalado el paquete python3-tk en nuestro sistema.

En principio nos dicen que Thonny viene con Python 3.7 incluido, pero para Linux no parece que traiga ningún Python. Thonny arrancará usando el Python por defecto del entorno virtual que creemos, pero nos dejará seleccionar otras versiones si las ve disponibles. De momento creamos el entorno virtual para Thonny con la última versión disponible (en pyenv) de Python 3.7

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

sudo apt install python3-tk            # Asegurate de tener esto instalado

pyenv install 3.7.13                   # Instalamos el último python 3.7
pyenv virtualenv 3.7.13 ve_thonny      # creamos el entorno virtual

mkdir ~/work/thonny                    # creamos un directorio de trabajo
cd ~/work/thonny
pyenv local ve_thony                   # asignamos un ve al directorio
pip install thonny                     # instalamos thonny
thonny                                 # y lo arrancamos

MicroPython con las Raspberry Pi Pico

Para instalar el MicroPython en nuestra Pico necesitamos que se monte como un dispositivo de almacenamiento externo. Si viene directa de fábrica es el comportamiento por defecto, de lo contrario tenemos que:

• Desconectar el USB de la Pico del ordenador
• Con el USB desconectado pulsamos el boton de Boot Select en la Pico y sin soltarlo la conectamos por USB al ordenador
• Mantenemos el botón pulsado tres segundos y soltamos, deberíamos ver la Pico montada como almacenamiento externo

Ahora basta con descargar el fichero UF2 de MicroPython desde la página oficial y dejar una copia en el sistema de ficheros de la Pico, en cuanto tenga el fichero descargado se reiniciará y ejecutará el MicroPython

Una vez tengamos la Pico conectada y ejecutando el Python podemos usar el editor Thonny para conectarnos a ella, basta con arrancar el edito y en la opcion Run::Select Interpreter escoger la opción MicroPython (Raspberry Pi Pico), con eso ya estaremo conectados al interprete de la Pico y podremos ejecutar programas (Hay que salvarlos en la Pico, el editor te dejará escoger donde quieres salvarlos)

T-Pico C3

• Github site from Xinyuan Lilygo
• Report on CNX

STM32 y el entorno STM32CubeIDE

De momento solo estoy probando la BluePill con STLink V2 (chino). Las BluePill que tengo yo llevan el micro F103C8T6

Instalamos el STM32CubeIDE con la opción de paquetes .deb

Programando un Blink

Configuramos el pin 13 (corresponde al pin de usuario) como output no le ponemos nada a mayores. Si optamos por ponerle una etiqueta, p. ej. LEDUSER podemos hacer referencia a la etiqueta en el código.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

/* USER CODE BEGIN WHILE */
while (1)
{
  HAL_Delay(1000);
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, 0);
  HAL_Delay(1000);
  // Otra solución
  HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
  HAL_Delay(1000);
  // Usando etiquetas de GPIO
  HAL_GPIO_TogglePin(LEDUSER_GPIO_Port, LEDUSER_Pin);
  HAL_Delay(1000);

  /* USER CODE END WHILE */
  /* USER CODE BEGIN 3 */
}

STM32 USB-CDC

¡Ojo! además de configurar correctamente el USB, es decir, activarlo en la sección de Connectivity y configurar correctamente el reloj para poder dar señal al USB, tendremos que añadir el Middleware que nos interese (en este ejemplo usamos Virtual Port COM )

También tendremos que hacer un #include "usbd_cdc_if.h" en la sección correspondiente a los Private Includes de nuestro main.c.

Sección de includes:

1
2
3
4

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "usbd_cdc_if.h"
/* USER CODE END Includes */

Sección del programa:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  uint8_t txBuffer[] = {'H', 'o', 'l', 'a', '\n'};
  while (1)
  {
	CDC_Transmit_FS(txBuffer, 5);
	HAL_Delay(100);

    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */

Si cargamos el programa y conectamos la Blue Pill al usb de nuestro ordenador (yo desconecto previamente el stlink) podremos comprobar que estamos recibiendo con:

1

cat /dev/ttyACM0

PlatformIO

Instalando el Espressif SDK

• Abrimos VS code
• Abrimos el Platformio
• Nuevo proyecto
• Escogemos Espressif ESP32 Dev como board
• Escogemos ESP-IDF como framework

Con esto conseguiremos que el módulo Platformio descargue el framework de Espressif en el directorio ~/.platformio/packages/framework-espidf

Experimentos con el ESP32

Conversores usb ttl

CP2102 5PIN

1. tamaño de PCB: 26,5mm * 15,6mm

2. PCB Color: rojo

3. Peso: 4g

4. Uso del nuevo chip CP2102

5. Con fusible reajustable. En el caso de cortocircuito accidental puede proteger eficazmente su dispositivo y el puerto USB del ordenador para descargar

6. Con tres leds: Indicador de potencia, recepción de datos del indicador, indicador de transmisión de datos, estado del trabajo de un vistazo

7. 3,3 V y 5V con dos salidas de potencia

8. Todos los pines de plomo útiles

9. Con la salida de señal de reinicio puede ser directamente Pro mini y otra tarjeta Arduino para descargar!

10. Sistemas operativos compatibles:

    • Windows 98 / Me / 2000 / XP / 7
    • MAC OS-9
    • MAC OS
    • X-Windows CE
    • Linux 2,40 o posterior

PL2303HX

Características:

• Controlador importado RS232 TTL, que puede estabilizar el flash con alta velocidad
• Fusible de autorecuperación de 500mA para protección
• Dos indicadores de transmisión de datos pueden monitorizar el estado de la transferencia de datos en tiempo real
• Reserve interfaz de pin de 3,3 V y 5V, fácil para el DDWRT de diferentes sistemas de voltaje que necesitan energía
• La placa entera está recubierta por una manga termoretráctil transparente de alta calidad, haciendo que la PCB esté aislada desde el exterior,
• Para que la tabla no se queme con Un corte corto de material.
• Paquete electrostático, asegura que la placa no se dañará antes de su uso
• Apoyo WIN7 sistema

Especificaciones:

• Dimensión: about50x15x7mm
• Peso neto: 5g
• Peso del paquete: 15g
• Color: azul el pin con muchísimas patitas

USB a TTL CH340G

Características:

• USB incorporado al chip de transferencia TTL.
• Diseñado para ser utilizado para proyectos electrónicos USB a TTL.
• Salida de interfaz TTL, fácil de conectar a su MCU.
• LED de estado
• Salida de potencia Dual de 3,3 V y 5V, funciona con dispositivos de 3,3v y 5v.
• Tamaño: 55mm * 16mm
• ¿Servidor 2008/Win7/Win8 32 bits / 64 bits?

1. soporte de WINDOWS 98/ME/2000/XP/Server 2003/VISTA/
2. 3 V3 y 5V por una selección de riesgo de cortocircuito;
3. No solo tiene led de alimentación PWR, también hay indicador TXD y RXD, si el producto es fácil de aprender e intuitivo de trabajar en la ausencia delinstrumento en la caja;
4. pin amarillo de alta calidad, pin duradero que el mercado negro, hermoso;
5. Nuevos chips CH340G originales, los chips se recomiendan USB oficial a los chips TTL no aparecerán debido a diferentes controladores/diferentes ordenadores como resultado de incompatibilidades.

CH340/módulo interruptor USB TTL/Transferencia USB RS232/sobre PL2303/ downloader/ 9 cepillo Junta STC oficial descargar chip Perfectamente compatible con todas las Series MCU no será debido a los diferentes controladores que conduzcan a problemas como PL2303 no puede descargar el programa. Ultra-estable

Referencias

Cursos:

• esp-32:

  • idf-esp framework course 17 horas y media de video. El curso tiene muy buena pinta pero vale 50 eurazos.
  • ESP32 and PlatformIO IoT Project By Dalmaris parece muy orientado a la nube y con Platformio, son 10 horas de video
  • MicroPython with the ESP32 By Dalmaris 10 horas y media de videos acerca de Micropython en esp32.
  • Deepbluembedded Una colección de cursos que parecen basados en el Arduino IDE
  • IoT Application Development with the ESP32 Using the ESP-IDF by Kevin Aguilar (ocho horas de video) Un curso avanzado de uso del ESP-IDF y FreeRTOS, pero parece que depende/usa el AWS de Amazon.
  • ESP32 for Arduino Makers Curso con Arduino IDE by Dalmaris, tal vez no sea tan malo

• stm-32

  • De Arduino a STM32 (by Tutoelectro)

Referencias Generales

• Smart health connected devices
• Zephir project RTOS by The Linux Foundation