Sensor de temperatura - Protocolo TFA - ESP32-C3 super mini

  Página principal

Sensor de temperatura
Protocolo  TFA
ESP32-C3 super mini

---

Esta es la continuación del sensor con el protocolo TFA realizado con un ATMEGA328, pero en este caso lo realizo con un ESP32_C3 super mini.


Que cada uno mire en su placa la configuración de pins.
Se puede encontrar en:
    /home/usuario/.arduino15/packages/esp32/hardware/esp32/3.3.0/variants/lolin_c3_mini

Se diseña el esquema y el circuito impreso en KICAD.




El circuito impreso se realizó con el método de transferencia de tinta tóner.
Quedando como se ve en la foto.


Como no me quería arriesgar en alimentar el ESP-C3 con los 4V que proporciona la batería 18650, he bajado el voltaje a 3.3V utilizando un diodo que tiene una caída de voltaje de 0.6V .

Quedando todo el conjunto ...


El 95% del código es el mismo que con el ATmega328, pero he tenido que cambiar la forma en que se duerme el microcontrolador.

    esp_sleep_enable_timer_wakeup(1000000); // 1 Segundo
    esp_light_sleep_start();

También he solucionado algún error, sobre todo el que siempre sonaba un pitido cuando mandaba datos, y solo lo tiene sonar la primera vez.

Como el micro se encuentra dormido el 98% del tiempo, cuando se programa por segunda vez, no responde a la programación.
Para poder programarlo, deberás pulsar los dos botones a la vez (BOOT y RESET), sin dejar de presionar el BOOT, soltar el RESET, y ahora mandar el código al microprocesador.
El consumo es el siguiente:
Alimentado a 5V en el pin de 5V -> 0.78mA (Dormido)        27mA(Despierto)
Alimentado a 3.3V en el pin de 3.3V -> 0.5mA        26mA(Despierto)



El próximo cambio será utilizar un 18B20 como sensor de temperatura, en este montaje se desaprovecha el AHT20.

Programa


Saludos.
Juan Galaz


Bibliografía:
http://seta43.duckdns.org/2026/tfa/tfa.html
http://seta43.duckdns.org/ard433.html
http://seta43.duckdns.org/termot.html
http://seta43.duckdns.org/temt3.html

Entrenador Morse- Paleta simple y paleta doble con ESP32C3 MINI

  Página principal

Entrenador Morse
Paleta simple y paleta doble
ESP32 C3 MINI

 

---

En el anterior montaje había realizado un entrenador morse con el arduino, ahora lo hago con el ESP32 C3 MINI.
http://seta43.duckdns.org/morse/maniall.html
Este proyecto solo es una adaptación del anterior, me ha llevado 1 hora modificar un poco el código  y el circuito.

Probando varias placas y consultando varios tutoriales, encontré mi placa que funcionaba como LOLIN C3 MINI.
El problema que existen muchos ensambladores de placas, y algunos no figuran el modelo.
Que cada uno mire en su placa la configuración de pins.
Se puede encontrar en:
    /home/usuario/.arduino15/packages/esp32/hardware/esp32/3.3.0/variants/lolin_c3_mini

Después se hace el ajuste de los pins en el programa.

#define PIN_SOUND 4
#define TONO 647  //704

#define MILED 21
#define PUNTO 0
#define RAYA 1
#define MANI 1
#define PULSADOR 3

Ahora se cambia un poco el circuito.




Espero que les guste este montaje, y que practiquen mucho el morse.

VIDEO

PROGRAMA

Saludos.
Juan Galaz


Bibliografía:
http://seta43.duckdns.org/morse/maniall.html
http://seta43.duckdns.org/morse/morsema.html
https://morsecode.world/international/decoder/audio-decoder-adaptive.html
https://es.wikipedia.org/wiki/C%C3%B3digo_morse
http://seta43.duckdns.org/armorse.html
http://seta43.duckdns.org/amorb.html

Encender 4 LED con un móvil utilizando ESP32 C3

ESP32C3 MINI
WEB SERVER AP (Punto de acceso)

---

Hace unos años realicé con el ESP8266 un montaje que hacía encender 4 LED desde un navegador.
http://seta43.duckdns.org/espb.html
En este montaje realizo un servidor en modo Punto de Acceso.
Se conecta directamente el teléfono movil al wifi creado con el ESP32 C3, sin intervención de ningún router.


Probando varias placas y consultando varios tutoriales, encontré mi placa que funcionaba como LOLIN C3 MINI.
El problema que existen muchos ensambladores de placas, y algunos no figuran el modelo.
En mi caso la configuración de pins son:
static const uint8_t TX = 21;
static const uint8_t RX = 20;

static const uint8_t SDA = 8;
static const uint8_t SCL = 10;

static const uint8_t SS = 5;
static const uint8_t MOSI = 4;
static const uint8_t MISO = 3;
static const uint8_t SCK = 2;

static const uint8_t A0 = 0;
static const uint8_t A1 = 1;
static const uint8_t A2 = 2;
static const uint8_t A3 = 3;
static const uint8_t A4 = 4;
static const uint8_t A5 = 5;
Que cada uno mire en su placa la configuración de pins.
Se puede encontrar en:
    /home/usuario/.arduino15/packages/esp32/hardware/esp32/3.3.0/variants/lolin_c3_mini

El primer montaje solo utilizo 4 diodos LED y una resistencia.
El mando de encendido y apagado se hace con un teléfono conectado directamente la Wifi creado con el ESP32 C3.





Me di cuenta que no se proporcionaba ninguna información , por lo que he añado un OLED donde indico el nombre de la red Wifi, la contraseña y la IP.




PROGRAMA

VIDEO

Saludos.
Juan Galaz


Bibliografía:
https://randomnerdtutorials.com/getting-started-esp32-c3-super-mini/
http://seta43.duckdns.org/espb.html
https://github.com/sidharthmohannair/Tutorial-ESP32-C3-Super-Mini
https://www.luisllamas.es/probamos-el-nuevo-esp32-c3-el-sustituto-del-esp8266/
https://www.espressif.com/sites/default/files/documentation/esp32-c3-mini-1_datasheet_en.pdf
https://www.mechatronicstore.cl/conectando-la-esp32-c3-super-mini-a-arduino-paso-a-paso/?srsltid=AfmBOopdSs8GEHCtRzY2aXz168xDNPLSEk_YsHXers0j9pHBz6SHsCk4
https://www.youtube.com/watch?v=0sum5XaOdW0

Antena Loop III

  Página principal

Antena Loop
III

Una vez que tenemos construida la antena Loop pasamos a la parte de control de sintonia.
En este artículo realizo la parte de control de los 2 servos que manejan la capacidad de los condensadores de la antena Loop.

Para el control de los dos servos se podría emplear un mando infrarrojo, alguna vez lo he empleado.
Pronto lo desestimé,  el mando por infrarrojos debe tener visión directa con la antena, en muchos casos la antena puede estar en el exterior, y la emisora en el cuarto de radio, en el interior.
La opción más fácil es emplear Bluetooth, y eso hice, utilizar un arduino junto con un módulo bluetooth (HC-05 o HC-06).
Una vez montado todo, funcionaba perfectamente.
Como yo no estaba totalmente satisfecho, pensé en utilizar un Chip ESP32 que tiene incorporado el Bluethooth, y empece con probar con el ESP32-C3, es pequeño y tiene todo lo necesario.
No tenía mucha práctica con el ESP32-C3, pero empecé con ello.
Monte el circuito con los 2 servos, y todo funcionaba bien manejándolos desde la consola serie, pero cuando pasé a la parte de Bluetooth todo se torció. El ESP32-C3 no es compatible con Bluetooth clásico, sino que utiliza Bluetooth de baja energía (BLE), y este no soporta el interface serie.
Hice bastante pruebas, y cuando conseguí que funcionase algo del Bluetooth, resultó que la señal no pasaba ni una pared.
Cansado de perder el tiempo con el ESP32-C3, pasé a su hermano mayor el ESP32 clásico.
Montado el circuito con el ESP32 todo funcionaba a la primera.


El circuito está alimentado por 2 baterías 18650 de 3.7V en serie .
Los 7,4V se reducen a 5V con un 7805 que alimentará los 2 servos y el ESP32.
Todo los componentes se meten en una caja estanca eléctrica, de la cual sale el cable que se conecta a los 2 servos.
En mi caso no he colocado un interruptor, he utilizado un conector externo.


Para el control a distancia utilizo un móvil android.
En un primer momento he utilizado una aplicación gratuita  Serial Bluetooth Terminal.


Funciona perfectamente, y si configuras algún botón, mucho mejor.
Las opciones son:
x34    Cambia el valor de C1 a 34 , condensador grande.
y45    Cambia el valor de C2 a 45 , condensador pequeño.

+    Incrementa el valor de C1
-    Decrementa el valor de C1
q    Incrementa el valor de C2
a    Decrementa el valor de C2

o    Activa los servos.
c    Desactiva los servos.

Conviene una vez que se sintoniza la antena, desactiva los servos.

Funcionaba bien, pero no estaba conforme con utilizar este programa.
Busqué en mis antiguos proyectos de android, y encontré uno que hacía uso del terminal serie por Bluetooth.
En este caso estaba programado en B4A , un compilador Basic para android.
Desde que había programado en B4A había pasado mucho tiempo, y me costó empezar.
Ahora el programa era de código abierto, pero tuve bajar todos los ficheros, además de que solo funcionaba en 32 bits.
Como quería que funcionase en dispositivos antiguos, tuve que importar proyectos antiguos, si creaba uno nuevo ya no funcionaba  en dispositivos antiguos. :(  . Además al instalar el programa creado debes aceptar una doble confirmación.
Al final conseguí que funcionase,  aunque la interface es un poco fea.




Ajuste de la antena LOOP.



Programas , Arduino, B4A, APK

VIDEO

Espero que os haya gustado este montaje, me ha llevado bastante tiempo.


Saludos.
Juan Galaz


Bibliografía:
https://loop-magnetic-ce3yu.blogspot.com/2015/01/antena-loop-magnetica_31.html
https://www.nonstopsystems.com/radio/frank_radio_antenna_magloop.htm#top-of-page
http://www.pearltrees.com/kc4fne/loop-antennas/id25196879
http://www.radioamatoripeligni.it/i6ibe/loopflat/loopflat.htm
https://www.ivarc.org.uk/uploads/1/2/3/8/12380834/multi-band_hf_magnetic_loop_slides_-1.pdf

CLIENTE HTTP CON ESP32 , CONTROL VARIOS SERVIDORES IoT

  Página principal

CLIENTE HTTP CON ESP32
CONTROL VARIOS SERVIDORES IoT
ESP-01 (esp8266)

---

En marzo de 2022 se realizó un diseño de Server HTTP con el ESP-01 que lleva integrado un ESP8266, cuyo tamaño y pines son adecuados para controlar el encendido y apagado de los focos de iluminación de diferentes áreas, incluso para echar a andar a apagar algunos aparatos domésticos, como ventiladores, calefactores, etc. El proyecto se puede consultar en la siguiente liga: http://seta43.blogspot.com/search?q=esp-01

El control podía hacerse desde un Smartphone, tablet, PC o laptop, ingresando la dirección web de cada servidor ESP-01, por ejemplo http://192.168.0.195 apareciendo una página con 3 botones, 2 de ellos para encender y apagar el foco o dispositivo en la zona donde tal servidor estuviera instalado.

Sin embargo este método, aunque efectivo, tiende a ser lento considerando que hay que encender el Smartphone, teclear la dirección o link del que se quiere tener control, y finalmente oprimir el botón “ENCENDER” para que aquella zona se ilumine o se active. Resulta algo que se lleva un tiempo y es engorroso.

En el proyecto actual se ha seleccionado un ESP32, el cual ya armado consta únicamente de 6 botones tipo push-button (y posiblemente 6 LEDs) para que de manera inmediata el operador presione el que corresponde a la zona desee activar, con un toque rápido. Cuando se desea desactivar dicha zona, por ejemplo apagar la iluminación, el mismo botón ha de presionarse, pero dilatando algo más de 2 segundos. Es decir, se pensó en la urgencia de encender cierta zona, y de apagarla ya sin prisas y con el menor esfuerzo posible o tiempo dedicado a tal fin.

El ESP32 montado en el protoboard se muestra a continuación, con su adaptador que permite el uso de más conexiones (ver: http://seta43.blogspot.com/search?q=adaptador)

Para aquellos que les guste este proyecto, lo pueden modificar, incluso colocarle los respectivos LEDs y su código correspondiente, para indicar cual zona está activada (Encendida), por lo que se proporciona el programa respectivo de Arduino IDE.

Alfredo Segura, México. Agosto de 2025.

PROGRAMA

Saludos.
Alfredo Segura, México. Agosto de 2025.

ADAPTADOR PARA ESP32

 

Atras

ADAPTADOR PARA ESP32

Alfredo Segura.

Este pequeño proyecto consiste en fabricar un adaptador para el ESP32, el cual tenemos comprobado que es difícil trabajarlo en un protoboard estándar, ya que su anchura, apenas le permite posicionarse en los extremos externos de dicho protoboard, dejando solamente una línea de contactos disponible para conexiones externas.

Buscando en Internet un adaptador para el efecto, me sorprende que no haya uno como el que yo realicé, cuya fabricación y armado permite colocarlo en el protoboard en los contactos más cercanos a la división con que cuentan los protoboards en el centro.

Lo primero que hay que hacer es la plantilla de PCB como se muestra en la siguiente figura:

El siguiente paso es crear la tarjeta de cobre (PCB) de un solo lado con esta plantilla, para lo cual yo uso el método más antiguo, que consiste en los siguientes pasos:

1.- Preparar una placa de cobre (un solo lado) con el tamaño de la plantilla, debidamente lavado con detergente, para eliminar cualquier residuo de suciedad, principalmente grasa.

2.- Imprimir la plantilla sobre papel ‘transfer’ en una impresora laser en negro.

3.- Fijar el papel ‘transfer’ ya impreso en la placa de cobre usando cinta adhesiva.

4.- Poner la placa de cobre con el papel ‘transfer’ en una superficie completamente plana , con el papel transfer por el lado de arriba y cubrirlo con dos hojas de papel higiénico.

5.- Con una plancha muy caliente hacer presión sobre el conjunto, girando la plancha en varias direcciones. (nunca deslizar), solo ejercer presión hacia abajo.

6.- Con 2 minutos de esta operación, concluir el proceso de la plancha y retirar el papel ‘transfer’, verificando que el tóner se haya pasado totalmente a la placa de cobre.

7.- Sumergir la placa de cobre con la plantilla ya pegada en un recipiente de plástico con una cantidad moderada de Cloruro Férrico y mover constantemente observando cómo el cobre va desapareciendo de la placa, quedando únicamente las pistas cubiertas de tóner.

8.- Cuando todo el cobre ha desaparecido, recoger y guardar el Cloruro Férrico usado en otro recipiente con tapa, para una ocasión posterior. En el recipiente de plástico donde se hizo el proceso, se echa bastante agua limpia para retirar todo residuo de Cloruro Férrico, cuidando de que no toque la piel o a ropa, ya que es imposible limpiarlo.

9.- En el mismo recipiente con agua y usando una fibra de metal delgada, se pasa por encima del tóner repetidamente hasta eliminarlo, quedando únicamente las pistas de cobre expuestas.

10.- Una vez debidamente seca la tablilla, se procede a pasarle el cautín y un poco de soldadura, de tal manera que todas las pistas queden con una fina capa de estaño, para protección del cobre por oxidación a futuro. Se cortan las tres partes de este diseño, para su ensamblaje posterior.

Concluido el proceso anterior, se realiza la perforación de los hoyos y posteriormente se incrustan los’ headers’ machos y hembras como se muestra en la Fig. 2.

En la Fig. 3 se muestra otra vista del ensamblaje y soldadura de los ‘headers’ uniendo las 3 partes entre si de las tablillas PCB de este diseño.

En la siguiente figura (Fig. 4) se observa el adaptador con un ESP32 ya incrustado en su parte superior y a su vez colocado en el protoboard, precisamente en las líneas de orificios mas contiguos al canal central de dicho protoboard, dejando disponibles casi todos los puntos de contacto para cualquier diseño.

Entre las placas verticales de este diseño, se puede rellenar con polietileno caliente, de tal manera que al enfriarse otorgue resistencia a dichas placas para su uso constante.

El ESP32 se puede poner en cualquier sentido en el adaptador, y éste a su vez también en cualquier sentido sobre el protoboard.

Ing. Alfredo Segura, México. Julio de 2025.

ESP32 - Reproductor de WAV

  Página principal

ESP32
Reproductor de WAV

---

En el anterior proyecto ../vozmemo.html había realizado un reproductor de WAV desde una memoria Flash, utilizando el arduino.
Ahora me dispongo a realizar el mismo proyecto pero con el ESP32, y utilizando la memoria Flash que incorpora la placa, en este caso para la placa LOLIN 32 la memoria es  T25S32.
He utilizado la placa LOLIN 32 debido a que es más pequeña y la tenía cerca, pero el montaje funciona con cualquier placa ESP32.
En el caso del montaje con arduino, grabar la memoria Flash con un programador, en este montaje los datos de sonido WAV  se incorporan en el propio código.

Empezamos con el sonido grabado en formato de 11KHz y 8bits.

Una vez que tenemos el archivo WAV, debemos transformarlo a código C.
Utilizamos el programa HxD , es un editor hexadecimal que tiene la opción de exportarlo a código C.

Obtenemos un fichero con extensión .c , aunque lo he renombrado con extensión .h , es un gusto mio.

Ahora debemos editar el fichero para cambiar el tipo de dato.
Debemos cambiar de:
 unsigned char rawData[301892] = {
a
const char rawData[] = {

Con este cambio los datos se almacenan en la memoria Flash.

El fichero lo copiamos al mismo directorio del proyecto arduino y lo agregamos con:

#include "metro1.h"
long tamano=sizeof(rawData);

---

En el código  de programa del ESP32, creamos una interrupción cada 11KHz, que lo que hace es leer los datos WAV almacenados en la memoria Flash y mandarlos al convertidor D/A.

hw_timer_t *timer = NULL;

void IRAM_ATTR timerInterrupcion()
{
 if(dire>tama) { fin=1; dacWrite(25, 128);  } //
 if(fin==0) {  dacWrite(25, rawData[dire++]);  }
}

void setup()
{
  ....
  timer = timerBegin(1000000); // Timer 0, clock divider 80
  timerAttachInterrupt(timer, &timerInterrupcion); // Attach the interrupt handling function
  timerAlarm(timer, 90, true, 0); // ((1/11000)*1000000)
  ...
}

---

He creado dos programas, uno que utiliza el terminal para mandar el numero de trozo WAV a reproducir.

---

En el  segundo he añadido un display OLED y un mando rotatorio para elegir el sonido a reproducir, también se puede mandar los códigos desde consola.


Para leer el mando rotatorio utilizo las entradas en modo INPUT_PULLUP, debería funcionar tal como está en el código.
El problema es que algunos pin del ESP32 no se pueden poner en modo INPUT_PULLUP, si no os funciona con está configuración, deberéis colocar una resistencia de 10K desde las entradas hasta Vcc.

---

He tenido un problema con las librerías del ESP32.
Como yo utilizo Linux para programar, y tiene su propio Arduino en los repositorios, si mezcláis las librerías con la versión que viene de serie en Linux, saldrán errores.
Solución, desinstalar el Arduino que viene en Linux, y bajar de la página de arduino la versión arduino-1.8.19 y utilizar esta última.

Como en la versión de arduino, el leer byte a byte desde la memoria Flash no es del todo rápido, próximamente intentaré crear un buffer de 100 bytes para que sea más rápido.

PROGRAMA

09/07/02024
Como había prometido, he realizado una segunda versión, en esta la lectura de los datos desde la memoria Flash la hago de 100 datos cada vez.
En el arduino se notaba que aumentaba el rendimiento del programa, pero en este caso al ser un procesador 10 veces más rápido, no se nota mucho.
De todas formas he programado el cambio.
PROGRAMA2

VIDEO DEMOSTRATIVO


Saludos.
Juan Galaz



Bibliografía:
../vozmemo.html
voz2.html
arduvoz.html
arvoc.html .

ESP32 Emulador ZX SPECTRUM - Vídeo PAL

  Página principal

ESP32
Emulador
ZX SPECTRUM - PAL

---

Cada uno tiene mitificado el ordenador en el cual empezó, y el mio es el ZX SPECTRUM.
Otro circuito que encontré para hacer con el ESP32 es un emulador de Spectrum.
    https://github.com/sdima1357/spectrum128_esp32_usb_host_pal_tv
Existe otro emulador pero la salida es por VGA, es mucha de mejor su calidad de video, pero no se podría conectar a televisiones antiguas.
El entorno de desarrollo es MX21, es una distribución basada en Debian, pero bastante mas actualizada, recomiendo que la probéis.

$ python3 --version
Python 3.9.2

$ uname -a
Linux mx21 6.0.0-6mx-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.0.12-1~mx21+1 (2022-12-15) x86_64 GNU/Linux

El primer paso es instalar el entorno de desarrollo ESP, esto me dio mucho trabajo, hasta que descubrí que con la última versión la 5, producía errores en la compilación, por lo que tuve que instalar la versión 4.4.4

mkdir -p ~/esp
cd ~/esp
git clone -b v4.4.4 --recursive https://github.com/espressif/esp-idf.git
cd ~/esp/esp-idf
./install.sh esp32

cd esp-idf/
. ./export.sh

Este último paso ./export.sh configura el entorno del terminal, si se cierra el terminal deberemos volver a ejecutarlo.

Ahora nos toca bajar el emulador desde la página del proyecto.

cd ..
git clone https://github.com/sdima1357/spectrum128_esp32_usb_host_pal_tv

No metemos en el directorio del proyecto y lo compilamos y grabamos el ejecutable en la ESP32 .

cd spectrum128_esp32_usb_host_pal_tv-main/
idf.py -p /dev/ttyUSB0 flash

Si todo fue bien, después de un rato de compilación, grabará los ficheros *.bin en el ESP32, para luego reiniciarse.
....
....
Writing at 0x000665df... (100 %)
Wrote 368880 bytes (223758 compressed) at 0x00010000 in 5.2 seconds (effective 567.4 kbit/s)...
Hash of data verified.
Compressed 3072 bytes to 103...
Writing at 0x00008000... (100 %)
Wrote 3072 bytes (103 compressed) at 0x00008000 in 0.1 seconds (effective 377.3 kbit/s)...
Hash of data verified.

Leaving...
Hard resetting via RTS pin...
Done

Si tenemos conectado la salida de vídeo a un televisor, veremos que arranca el emulador de el Spectrum.
Aconsejo que no conectéis la tarjeta SD la primera vez, de esta forma entraremos en el menú de selección de tipo 48K/128K
Tal y como compilamos las fuentes originales, el brillo es muy bajo, por lo que decidí estudiar el código.
En el fichero smain.c debemos retocar un poco el código para aumentar los niveles de salida de video.
Existen 2 líneas una comentada y otra descomentada, cambiarlas de forma que queden así.

//#define IRE(_x)            ((uint32_t)(((_x)+40)*255/3.3/147.5) << 8)   // 3.3V DAC
#define IRE(_x)          ((uint32_t)(((_x)+40)*255*2/3.3/147.5) << 8)   // 3.3V DAC

Esto lo que hace es cambiar los niveles iniciales de la señal de vídeo.
Ahora el nivel de brillo es bastante mejor, y aún se podría poner mejor, pero no he querido retocar el código original.

Las ROMS de programas del Spectrum deberán grabarse dentro de un directorio z48 si son del modelo 48K y en un directorio z128 si son del modelo de 128K.
Todo esto está documentado en el fichero README.md que se encuentra en las fuentes.
En este mismo fichero se explica la conexiones del ESP32 al teclado y a la SD.

1 Analog color PAL-TV 50 Hz output: (GPIO25)
2 Two  (bitband) USB-HID controllers (DP/DM) GPIO16/ GPIO17 - USB 1 GPIO18/ GPIO19 - USB 2
3 Emulation  AY-3-8910 (GPIO27)
4 SDCard control (.tap .z80 .sna) read pins:
    PIN_NUM_MISO 2
    PIN_NUM_MOSI 15
    PIN_NUM_CLK 14
    PIN_NUM_CS 13
5 Screen width F4/F5
6 Tape speed normal/fast F11/F12


Esquema de conexión.


He utilizado la placa de mi anterior montaje.


Menú de selección de ROMS


Jugando al JET PAC.


Muestra de una línea de la señal PAL.

Ya puedo jugar a mi juego preferido en el ZX Spectrum   PENETRATOR
Como podemos observar, la calidad del video compuesto no es el mejor, y sobre todo si utilizamos las pantalla planas, pero se puede jugar perfectamente.

Gracias Samsonov Dima


Saludos.
Juan Galaz


Bibliografía:

https://github.com/sdima1357
https://github.com/sdima1357/spectrum128_esp32_usb_host_pal_tv

ESP32 emulador de consolas

Página principal

ESP32
Emulador
esp_8_bit

---

Buscando montajes curiosos con la ESP32 encontré esp_8_bit ,un emulador de:

Atari 400/800, XL, XEGS, 5200
Sega Master System, Game Gear
Nintendo Entertainment System

y los mas interesante es que genera video compuesto, tanto PAL o NTSC.
Generar video compuesto(color) con arduino era realmente difícil, pero con el ESP32 de doble núcleo es posible.

    -----------
    |         |
    |      25 |------------------> video out
    |         |
    |      18 |---/\/\/\/----|---> audio out
    |         |     1k       |
    |         |             ---
    |  ESP32  |             --- 10nf
    |         |              |
    |         |              v gnd
    |         |
    |         |     3.3v <--+-+   IR Receiver
    |         |      gnd <--|  )  TSOP4838 etc.
    |       0 |-------------+-+   (Optional)
    -----------

Al disponer el ESP32 de conexión bluetooth, he utilizado un viejo mando de la consola wii, que funciona perfectamente.

El entorno de trabajo y compilación fué Debian 11 y el IDE de arduino VER. 1.9.19 .
Una de las cosas que me llevo mas tiempo fue un error en la compilación bajo Debian 11, decía que no tenia instalado la librería serial de python.
Para instalar la librería serie para python se puede hacer de dos métodos:
   sudo pip3 install pyserial
  python3 -m pip install pyserial
y la respuesta era : Requirement already satisfied: pyserial in /usr/lib/python3/dist-packages (3.5b0)
En teoría ya las tenía instalada.
Después de muchas pruebas descubrí que en Debian 11 el enlace directo de python apunta al python2,  y debía apuntar a python3.
Muchas de estas cosas pasan con Debian, al ser en muchos casos demasiado conservador.
Para cambiar el enlace directo tecleamos desde root:
   rm /usr/bin/python
  ln -s /usr/bin/python3 /usr/bin/python

Para compilar nuestro emulador, debemos bajar las fuentes de: esp_8_bit
Descomprimimos en el directorio de compilación, en mi caso es Arduino.
Arrancamos la IDE de arduino y configuramos el tipo de emulador y el sistema de televisión (PAL o NTSC) en el fichero config.h.
Si todo fue bien nos saldrán el video compuesto por el pin25 y el audio por el pin18.

Existen unos cuantos incluidos en el emulador, pero si queremos incluir otros juegos debemos instalar una utilidad en la IDE de arduino, ESP32FS.
El ESP32 normal tiene 4Mbytes de memoria, de los cuales para nuestro proyecto utilizamos la mitad para el programa, y la otra mitad para una especie de disco con el formato SPIFSS.
Las ROMS de los juegos se almacenan en el disco SPIFF, y para subir ficheros a este disco utilizamos ESP32FS.
Para instalar la utilidad ESP32FS la descargamos y la descomprimimos en:
~/Arduino/tools/   quedando como    ~/Arduino/tools/ESP32FS/tool/esp32fs.jar  .

Cuando reiniciamos la IDE de arduino nos aparecerá en el menu de Herramientas/ESP32_Sketch_Data_Upload
Si ejecutamos esta opción del menú, los ficheros (ROMS) que se encuentran en el directorio de esp_8_bit/data se subirán a la memoria del ESP32.


En algún caso algunas entradas de video compuesto la impedancia es bastante baja y la salida del ESP32 no alcanza a dar la señal correcta.
Para estos casos he creado un pequeño circuito:

 
Como me funcionaba en la protoboard , lo he pasado a circuito impreso.


Como podemos observar, la calidad del video compuesto no es el mejor, y sobre todo si utilizamos las pantalla planas, pero se puede jugar perfectamente.
También he observado que con algunas ROMS se bloquea el emulador en algún momento.

Gracias Peter Barrett


Saludos.
Juan Galaz


Bibliografía:

https://github.com/rossumur/esp_8_bit
https://github.com/me-no-dev/arduino-esp32fs-plugin/releases/

 

ESP32 - Repetidor códigos IR

  Página principal

ESP32
Repetidor códigos IR

DISEÑO Y CONSTRUCCIÓN DE UN SISTEMA
 TRANSMISOR – RECEPTOR POR BLUETOOTH PARA ENVIAR RÁFAGAS IR (INFRARROJO)
Y CONTROLAR DISPOSITIVOS EN ESPACIOS SEPARADOS

Alfredo Segura, Mexico febrero de 2022

---

Seguramente algunos de nosotros hemos tenido la necesidad de controlar nuestro Decoder de TV que se ha colocado en la sala de estar, en donde está nuestra TV principal. Si deseamos tener otro Decoder en nuestra habitación, tendremos que pagar una renta mensual  adicional. Y si aún queremos otro más en la habitación de los chicos, pues la renta mensual sube, debido a que ciertas empresas de cable, cobran en base al número de televisores (y Decoders) que se requieran en una  residencia habitacional.



Para el momento de dejar la sala de estar e ir a mi habitación, para seguir viendo la TV, cómodamente desde la cama, he diseñado un dispositivo que capta las ráfagas de IR (infrarrojo) del Control Remoto (Mando) del Decoder, el cual he llevado conmigo a la habitación. Este dispositivo usa un ESP32-WROOT-32, trabajando con BluetoohSerial (BLE) y al cual he conectado un sensor de ráfaga IR (VR-38).


Las ráfagas se pueden detectar haciendo uso de la librería IRrecv.h, la cual está incluida en la librería IRremoteESP8266 que se puede descargar desde github para Linux o Windows:

https://github.com/crankyoldgit/IRremoteESP8266

La librería está muy completa, ya que tiene detectores para protocolos básicos como NEC, RC5, RC6, JVC y su gran número adicionales, que se detectan en forma automática. Incluso se pueden determinar, el tipo de protocolo, el valor recibido CMD, la dirección ADDRESS y otros.

Una vez detectado el código de mi Control Remoto (Mando a distancia) por el ESP32, un simple comando se usa para transmitirlo por Bluetooh a otro dispositivo, que también he diseñado y fabricado, que es el Receptor Rx, igual con un ESP32. Este simple comando es:

SerialBT.write(comando);

Volviendo la mirada al Receptor de Bluetooth, éste genera los pulsos de acuerdo al protocolo NEC (que es mi caso) de acuerdo al comando recibido.

Para simplificar todo el proceso en este Receptor he hecho una tabla en la que se observa que todos los comandos del Control Remoto (Mando) tienen exactamente la misma ADDRESS y solo cambia el CMD (comando):

TECLA	ADDR _HIGH	ADDR_LOW	CMD	#CMD
1	64	64	1	254
2	64	64	2	253
3	64	64	3	252
4	64	64	4	251
5	64	64	5	250
6	64	64	6	249
7	64	64	7	248
8	64	64	8	247
9	64	64	9	246
0	64	64	0	255
CH +	64	64	31	224
CH -	64	64	30	225
VOL +	64	64	21	234
VOL -	64	64	28	227
TODAS	64	64	X	Y

Así que en el Receptor solamente puse atención en el dato de “comando” CMD y mediante un tramo de código, fui asignando el comando completo que debía enviarse a un PIN seleccionado del ESP32, que funge como emisor de IR, y esa señal se envía a un transistor NPN como buffer que proporciona señal a un LED emisor Infrarrojo:

switch (comando.toInt()) {
      case 127:     // 1
        hexcomando = 0x0202807F;
        break;
      case 191:     // 2
        hexcomando = 0x020240BF;
        break;
      case 63:     // 3
        hexcomando = 0x0202C03F;
        break;
      case 223:     // 4
        hexcomando = 0x020220DF;
        break;
      case 95:     // 5
        hexcomando = 0x0202A05F;
        break;
….
}

irtrans.sendNEC(hexcomando);        // Este simple comando genera ráfaga para un LED-IR

Se anexan los programas tanto de transmisor en ambiente de Arduino:
ESP32_DecoderTVTx.ino
ESP32_DecoderTVRx.ino

Una vez probados ambos dispositivos (Tx y Rx), se diseñan las tablillas PCB donde serán montados los ESP32 y todos sus componentes, que realmente son muy pocos.

En las fotografías que se anexan, se muestran las tablillas sin montar en sus respectivas cajas, de tal manera que se puedan ver los detalles de su construcción.

Se anexan también los diseños PCB para ambos dispositivos.












Y así, finalmente me he podido llevar virtualmente el Decoder a mi recámara en donde con el mismo Control Remoto (Mando), puedo cambiar de canal, poner MUTE, subir volumen, etcétera.
El diseño se pone a la disposición de los entusiastas electrónicos para que lo repliquen, lo mejoren, y lo disfruten.

PROGRAMAS

Saludos.
Alfredo Segura
Mexico febrero de 2022


Bibliografía: