---
weight: 4
title: "Microprocesadores: apuntes"
date: 2023-09-08T12:12:46+0200
draft:  false
summary: "Apuntes de microprocesadores"
categories:
  - notes
tags:
  - ch340
  - attiny
  - arduino
  - platformio
  - esp32
  - esp8266
  - wemos d1
  - stm32
  - STM32CubeIDE
---

{{< figure src="/images/microproc/arduinos_a.jpg"
    title="arduinos"
    width=300 >}}


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

### Troubleshooting

Prueba a parar el infame _ModemManager_:

~~~bash
sudo systemctl stop ModemManager
~~~

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

```bash
systemctl stop brltty-udev.service
```

### attiny

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

~~~bash
sudo apt install libusb-0.1-4
~~~

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

~~~
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í:

~~~bash
# 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:

```bash
# 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.

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

![arduinos](/images/microproc/arduinos_a.jpg)

### Arduino IDE

#### Orígenes de bibliotecas configurados en el IDE Arduino

~~~
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](https://randomnerdtutorials.com/how-to-install-esp8266-board-arduino-ide/)
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](https://www.youtube.com/watch?v=G73fiaOpUAc)

Nos descargamos el repo de ejemplos de
[aqui](https://github.com/wemos/D1_mini_Examples) y los programas
corregidos por el señor Spiess de
[aqui](https://github.com/SensorsIot/Wemos-Shields)

Aunque tampoco es que consigamos gran cosa mirando esto.

Vamos a instalar la Biblioteca para el sensor SHT30 descargando de [el
github](https://github.com/wemos/WEMOS_SHT3x_Arduino_Library)

Y con este programilla funciona:

```cpp
#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](https://github.com/LilyGO/TTGO-T4-DEMO)
* [Test code](https://github.com/Xinyuan-LilyGO/LilyGo_Txx)
* [Hackaday](https://hackaday.com/2018/05/23/esp32-boards-with-displays-an-overview/)
* [Proyectos con Arduino y MicroPython](https://kreier.github.io/t-display/)
<!--
https://jonstephensonsblog.com/2019/12/06/using-the-ttgo-t-display-board/
https://www.youtube.com/watch?v=b8254--ibmM
https://sites.google.com/site/jmaathuis/arduino/lilygo-ttgo-t-display-esp32
http://pdacontroles.com/revision-modulo-esp32-ttgo-t-display-1-14/
https://www.profetolocka.com.ar/series/usando-la-placa-ttgo-t-display-de-lilygo/
-->

Andreas Spies

* [Hoja comparativa](https://docs.google.com/spreadsheets/d/1Mu-bNwpnkiNUiM7f2dx8-gPnIAFMibsC2hMlWhIHbPQ/edit#gid=0)
* [Video comparativo](https://www.youtube.com/watch?v=s12XuR7BJkw)

Mas cosas:

* [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)

Basicamente:

```bash
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.

{{< admonition type=warning title="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).

{{< admonition type=tip title="udev rules" open=true >}}

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
; https://docs.platformio.org/page/projectconf.html

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

### ESP32

#### Framework 'arduino'

Creamos un nuevo proyecto con

```ini
[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:

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

El código del blink:

```cpp
#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);
}
```

{{< admonition type=note title="TODOs" open=false >}}

- [Probar Wemos D1](https://docs.platformio.org/en/latest/boards/espressif8266/d1_mini.html)
- [Probar con ESP32](https://docs.platformio.org/en/latest/tutorials/index.html)
- [Probar ESP32-S3](https://docs.platformio.org/en/latest/boards/espressif32/esp32-s3-devkitc-1.html#board-espressif32-esp32-s3-devkitc-1)
- [ESP32 Wrover](https://docs.platformio.org/en/latest/boards/espressif32/esp-wrover-kit.html#board-espressif32-esp-wrover-kit)
- [Wemos D1 and Micropython](https://www.wemos.cc/en/latest/tutorials/index.html)

{{< /admonition >}}



### Referencias ##

* [PlatformIO samples (github)](https://github.com/platformio/platformio-examples)
* [PlatformIO for Arduino, ESP8266, and ESP32 Tutorial (Andreas)](https://www.youtube.com/watch?v=0poh_2rBq7E)
* [PlatformIO and Wemos D1](https://www.youtube.com/watch?v=V6bG-UvD54Q)


## Micropython

{{< admonition type=info title="Referencias Micropython" open=true >}}
- [micropython.org](https://micropython.org/)
- [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/ )


## STM32 y el entorno STM32CubeIDE

{{< admonition type=info title="Referencias" open=true >}}

- [STM32F1xxxx Reference Manual (pdf)](https://www.st.com/content/ccc/resource/technical/document/reference_manual/59/b9/ba/7f/11/af/43/d5/CD00171190.pdf/files/CD00171190.pdf/jcr:content/translations/en.CD00171190.pdf)
- [STM32F4xxxx Reference Manual (pdf)](https://www.st.com/resource/en/reference_manual/rm0090-stm32f405415-stm32f407417-stm32f427437-and-stm32f429439-advanced-armbased-32bit-mcus-stmicroelectronics.pdf)
- [USB intro  en la wiki de st.com](https://wiki.st.com/stm32mcu/wiki/Introduction_to_USB_with_STM32)
- [Una página con algunas referencias a distintas placas con micros STM32](https://stm32-base.org/)
- [Coleción de artículos en Hackaday](https://hackaday.com/series_of_posts/stm32-bootcamp/)
- [Baremetal programming guide](https://github.com/cpq/bare-metal-programming-guide)
- [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)

{{< /admonition >}}


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`

{{< admonition type=tip title="Programar con STLink V2" open=true >}}

Para cualquier proyecto de STM32 donde queramos programar el micro
usando el _ST Link V2_, siempre tenemos que configurar el _debugger_
desde la opción `System Core::sys::` tenemos que asegurarnos de que:
- `Debug: Serial Wire`
- `Timebase Source: SysTick`

{{< /admonition >}}

### Conexionado del ST-Link V2

El _pinout_ del ST-Link V2 clónico es:

{{< figure src="/images/microproc/Pinout_ST_Link_V2.webp"
    title="ST-Link V2: Pinout"
    width=300 >}}


Las conexiones que debemos hacer para programar nuestro microprocesador son:

| ST-Link  | STM-32 micro |
|:--------:|:------------:|
| GND      | GND          |
| SWCLK    | CLK          |
| SWDIO    | DIO          |
| 3.3 v    | 3.3 v        |



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

{{< admonition type=warning title="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.

{{< /admonition >}}


```c
/* 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_:

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

<!-- https://docs.platformio.org/en/latest/tutorials/espressif32/espidf_debugging_unit_testing_analysis.html#tutorial-espressif32-espidf-debugging-unit-testing-analysis -->

## Experimentos con el ESP32

<!--
https://emariete.com/cargador-bateria-esp8266-esp32-bien-hecho/
-->


## 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](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)
