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í:
~~~bash
# for arduino brand, stop ModemManager grabbing port
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:
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.
```bash
# 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.
|Pin Adap. | Pin micro|
|--------- | ---------|
|3.3v | No usado |
|GND | GND |
|VBUS | VCC |
|TXD | RXI |
|RXD | TXO |
|DTR | DTR |
- **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
* [esta puede ser útil o no](https://github.com/LilyGO/TTGO-T2-SSD1331-SD)
* [Y esta igual](https://sites.google.com/site/jmaathuis/arduino/lilygo-ttgo-t-display-esp32)
#### ESP32-C3
Para el Arduino IDE instalamos las bibliotecas _latest_ siguiendo las instrucciones de [este enlace](https://docs.espressif.com/projects/arduino-esp32/en/latest/installing.html#windows-manual-installation)
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.
{{<admonitiontype=warningtitle="Actualizar ESP32 Arduino (in sketchbook)"open=true>}}
Es de suponer que estas bibliotecas se actualizan via git,
{{</admonition>}}
### 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](https://github.com/rogerclarkmelbourne/Arduino_STM32)): `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í](https://github.com/stm32duino/Arduino_Core_STM32). 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](https://git.comacero.com/salvari/guide_LinuxMint#platformio).
En mi ordenador todas las pruebas con distintos micros han funcionado hasta ahora sin problemas con los _udev rules_ que tenía configurados. Pero desde el propio _Platformio_ recomiendan instalar a mayores el fichero [99-platformio-udev.rules](https://github.com/platformio/platformio-core/blob/develop/scripts/99-platformio-udev.rules)
Para recargar las _udev rules_: `udevadm control --reload-rules && udevadm trigger`
{{</admonition>}}
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:
```ini
; 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
- [Micropython on ESP32](https://bhave.sh/micropython-urequests/)
- [Run Micropython on Docker Container](https://bhave.sh/micropython-docker/)
{{</admonition>}}
### 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
```bash
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](https://www.raspberrypi.com/documentation/microcontrollers/micropython.html) 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](https://github.com/Xinyuan-LilyGO/T-PicoC3)
- [Report on CNX](https://www.cnx-software.com/2022/05/02/lilygo-t-picoc3-board-merges-rp2040-esp32-c3-integrates-color-display/ )
- [Debugging an Array](https://community.st.com/t5/stm32cubemonitor-mcus/how-to-watch-an-array-using-stm32cubemonitor/td-p/225086)
- [Trasmitting Structures via USB](https://medium.com/vicara-hardware-university/a-guide-to-transmitting-structures-using-stm32-uart-and-python-56b67f806566)
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.
{{<admonitiontype=warningtitle="Bloques de código"open=true>}}
Es **IMPORTANTE** insertar nuestro código en los bloques señalados por comentarios, por que de lo contrario, si cambiamos algo en la configuración del micro y regeneramos el código lo que no esté en los bloques marcados se eliminará automáticamente.
**¡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_:
```c
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "usbd_cdc_if.h"
/* USER CODE END Includes */
```
Sección del programa:
```c
/* 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:
```bash
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`
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](https://learnesp32.com/) 17 horas y media de video. El curso tiene muy buena pinta pero vale 50 eurazos.
- [ESP32 and PlatformIO IoT Project](https://www.udemy.com/course/esp32-platformio/) By Dalmaris parece muy orientado a la nube y con Platformio, son 10 horas de video
- [MicroPython with the ESP32](https://www.udemy.com/course/micropython-with-the-esp32/) By Dalmaris 10 horas y media de videos acerca de Micropython en esp32.
- [Deepbluembedded](https://deepbluembedded.com/esp32-programming-tutorials/) Una colección de cursos que parecen basados en el Arduino IDE
- [IoT Application Development with the ESP32 Using the ESP-IDF](https://www.udemy.com/course/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](https://www.udemy.com/course/esp32-for-arduino-makers/) Curso con Arduino IDE by Dalmaris, tal vez no sea tan malo
* stm-32
- [De Arduino a STM32 (by Tutoelectro)](https://www.youtube.com/watch?v=E8JpLtMlokw&list=PL1Hs_F1k2mdTwlGSv7lglkF_LtY0125OB)
### Referencias Generales ###
* [Smart health connected devices](https://www.absmarthealth.com/how-to-diy-smart-health-connected-objects/)
* [Zephir project RTOS by The Linux Foundation](https://docs.zephyrproject.org)
