Mostrando entradas con la etiqueta BLINK. Mostrar todas las entradas
Mostrando entradas con la etiqueta BLINK. Mostrar todas las entradas

sábado, 27 de agosto de 2022

Raspberry pi pico programación C Semáforo

  Página principal

Raspberry pi pico
programación C
Semáforo



Anteriormente se realizó estos dos montaje programando en python y IDE arduino, ahora lo realizo en C.
En estos dos primeros montajes realizaré un parpadeo de un LED y en el segundo un semáforo.
Para programar en C debemos instalar una SDK.

https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf

He realizado un pequeño tutorial en vídeo de como instalar el SDK sobre Linux - Debian11.



Estos son los pasos para instalar y compilar con la SDK

Fuente capítulo 2 de "Getting started with Raspberry Pi Pico"


ROOT
====
sudo apt update
sudo apt install cmake gcc-arm-none-eabi libnewlib-arm-none-eabi build-essential


USUARIO
=======
cd ~/
mkdir pico
cd pico

git clone -b master https://github.com/raspberrypi/pico-sdk.git
cd pico-sdk
git submodule update --init
cd ..
git clone -b master https://github.com/raspberrypi/pico-examples.git

----Update----
cd pico-sdk
git pull
git submodule update


----Compilar ejemplos ---

cd pico-examples
mkdir build
cd build
export PICO_SDK_PATH=../../pico-sdk
cmake ..


cd blink
make -j4

---Encende la Raspberry pi pico mientras está pulsado botón BOOT--
cp blink.uf2 /media/USUARIO/RPI-RP2/


Para que no tenga que desconectar y conectar el usb cada vez que cargo un programa la raspberry pi pico, he colocado un pulsador en el pin 3v3_ENABLE.
Ahora cada vez que tengo que probar un programa, solo tengo que pulsar a la vez los botones BOOT y 3v3_ENABLE, y soltar 3v3_ENABLE y BOOT, por este orden.
Inmediatamente se pondrá en el modo de carga de programa.



En la propia placa de Raspberry se incluye un LED en el pin GP25, aunque externamente no se puede acceder al pin GP25.
He utilizado el programa de Blink que viene en ejemplos.


/*
 * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#include "pico/stdlib.h"

int main() {
#ifndef PICO_DEFAULT_LED_PIN
#warning blink example requires a board with a regular LED
#else
    const uint LED_PIN = PICO_DEFAULT_LED_PIN;
    gpio_init(LED_PIN);
    gpio_set_dir(LED_PIN, GPIO_OUT);
    while (true) {
        gpio_put(LED_PIN, 1);
        sleep_ms(100);
        gpio_put(LED_PIN, 0);
        sleep_ms(400);
    }
#endif
}
blink.c

add_executable(blink
        blink.c
        )

# pull in common dependencies
target_link_libraries(blink pico_stdlib)

# create map/bin/hex file etc.
pico_add_extra_outputs(blink)

# add url via pico_set_program_url
example_auto_set_url(blink)
CMakeLists.txt




En el segundo montaje realizo un simple semáforo.
Se utilizan 5 pin de la Raspberry, 3 son para las luces de los coches, y 2 para las luces de los peatones.

Entorno para compilar Semaforo
#!/bin/sh
export PICO_SDK_PATH=~/pico/pico-sdk
echo ======ENTORNO============
echo ENTORNO
echo $PICO_SDK_PATH
echo ======COMPILAR===========
echo 'mkdir build && cd build'
echo cmake ..
echo make 
echo 'make -j$(nproc)'
echo 'cp programaPI.uf2 /media/usuario/RPI-RP2/'
echo




#include <stdio.h>
#include <pico/stdlib.h>


/*
# SEMÁFORO PARA RASPBERRY PI PICO en C
# SETA43
# seta43.duckdns.org
# seta43.blogspot.com
# Palencia / España
# 25-08-2022
*/

#define sROJO 18
#define sAMARILLO 19
#define sVERDE 20

#define pVERDE 17
#define pROJO 16

int tPARPADEO=400;
int tSEMAFORO=10000;
int tAMARILLO=3000;
long tPEATON=6000;

int main()
{
    stdio_init_all();
    const uint LED_PIN = PICO_DEFAULT_LED_PIN;
   
    gpio_init(LED_PIN);
    gpio_set_dir(LED_PIN, GPIO_OUT);
   
    gpio_init(sROJO);
    gpio_set_dir(sROJO, GPIO_OUT);
    gpio_init(sAMARILLO);
    gpio_set_dir(sAMARILLO, GPIO_OUT);
    gpio_init(sVERDE);
    gpio_set_dir(sVERDE, GPIO_OUT);
   
    gpio_init(pROJO);
    gpio_set_dir(pROJO, GPIO_OUT);
    gpio_init(pVERDE);
    gpio_set_dir(pVERDE, GPIO_OUT);
 
   
    printf("Hello world %d\n",LED_PIN);

    while (true)
    {
      gpio_put(sAMARILLO, 0);
      gpio_put(sROJO, 1);
      gpio_put(pROJO, 0);
      gpio_put(pVERDE, 1);
      sleep_ms(tPEATON);
     
      for(int z=0;z<=7;++z)
          {
            gpio_put(pVERDE, 0);
            sleep_ms(tPARPADEO);
            gpio_put(pVERDE, 1);
            sleep_ms(tPARPADEO);
          }
      gpio_put(pROJO, 1);
      sleep_ms(1000);

      gpio_put(sVERDE, 1);
      gpio_put(sROJO, 0);
      sleep_ms(tSEMAFORO);
      gpio_put(sAMARILLO, 1);
      gpio_put(sVERDE, 0);
      sleep_ms(tAMARILLO);
     
    }
}

main.c

cmake_minimum_required(VERSION 3.13)

include($ENV{PICO_SDK_PATH}/external/pico_sdk_import.cmake)

project(programaPI C CXX ASM)

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)

pico_sdk_init()

add_executable(${PROJECT_NAME} main.c)

pico_add_extra_outputs(${PROJECT_NAME})

target_link_libraries(${PROJECT_NAME} pico_stdlib)

pico_enable_stdio_usb(${PROJECT_NAME} 1)
pico_enable_stdio_uart(${PROJECT_NAME} 0)

CMakeLists.txt

He realizado el mismo programa pero creando funciones tipo arduino.

/*
# SEMÁFORO PARA RASPBERRY PI PICO en C
# SETA43
# seta43.duckdns.org
# seta43.blogspot.com
# Palencia / España
# 25-08-2022
*/

#include <stdio.h>
#include <pico/stdlib.h>

#define sROJO 18
#define sAMARILLO 19
#define sVERDE 20

#define pVERDE 17
#define pROJO 16

int tPARPADEO=400;
int tSEMAFORO=10000;
int tAMARILLO=3000;
long tPEATON=6000;


#define OUTPUT 1
#define INPUT 0
#define HIGH 1
#define LOW 0

void pinMode(unsigned int port, char modo)
{
    gpio_init(port);
    if(modo==OUTPUT)
        gpio_set_dir(port, GPIO_OUT);
     else
        gpio_set_dir(port, GPIO_IN);
}

void digitalWrite(unsigned int port, char val)
{
    gpio_put(port, val);
}

void delay(long t)
{
    sleep_ms(t);
}



int main()
{
      stdio_init_all();
      pinMode(sROJO, OUTPUT);
      pinMode(sAMARILLO, OUTPUT);
      pinMode(sVERDE, OUTPUT);

      pinMode(pVERDE, OUTPUT);
      pinMode(pROJO, OUTPUT);

      //#INICIALIZAR
      digitalWrite(sAMARILLO, HIGH);
      digitalWrite(sROJO, HIGH);
      digitalWrite(sVERDE, LOW);
      digitalWrite(pROJO, HIGH);
      digitalWrite(pVERDE, LOW);
      delay(1000);
   
    while(1)
    {
      digitalWrite(sAMARILLO, LOW);
      digitalWrite(sROJO, HIGH);
      digitalWrite(pROJO, LOW);
      digitalWrite(pVERDE, HIGH);
      delay(tPEATON);

      //Parpadeo verde peatón
      for(int z=0;z<=7;++z)
      {
        digitalWrite(pVERDE, LOW);
        delay(tPARPADEO);
        digitalWrite(pVERDE, HIGH);
        delay(tPARPADEO);
      }
      digitalWrite(pROJO, HIGH);
      delay(1000);

      digitalWrite(sVERDE, HIGH);
      digitalWrite(sROJO, LOW);
      delay(tSEMAFORO);
      digitalWrite(sAMARILLO, HIGH);
      digitalWrite(sVERDE, LOW);
      delay(tAMARILLO);
    }
   
}

main.c


Espero que este montaje os haya parecido interesante.

Saludos.

Juan Galaz



Bibliografía:

https://datasheets.raspberrypi.com/pico/raspberry-pi-pico-c-sdk.pdf
https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf
seta_PIB
seta_PIA
https://lindevs.com/set-up-raspberry-pi-pico-sdk-on-ubuntu
https://www.electroniclinic.com/raspberry-pi-pico-rp2040-programming-in-micropython-with-examples/
https://www.youtube.com/watch?v=2gihPgEkvL8
https://picockpit.com/raspberry-pi/es/todo-sobre-la-frambuesa-pi-pico/


jueves, 25 de agosto de 2022

Raspberry pi pico IDE Arduino, BLINK, Semáforo

  Página principal

Raspberry pi pico
IDE Arduino
Práctica 1 y 2



Anteriormente se realizó estos dos montaje programando en python, ahora lo realizo con el interface de arduino.
En estos dos primeros montajes realizaré un parpadeo de un LED y en el segundo un semáforo.
Para añadir esta tarjeta a la interface de arduino debemos realizar una serie de pasos.
He realizado un pequeño tutorial en vídeo de como instalar la tarjeta en arduino sobre Linux.
Video tutorial.

Enlace para instalar la placa en arduino.

https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

Para los que les guste una explicación mas completa os dejo 3 enlaces:

https://www.electroniclinic.com/raspberry-pi-pico-rp2040-programming-in-micropython-with-examples/
https://www.youtube.com/watch?v=2gihPgEkvL8

https://picockpit.com/raspberry-pi/es/todo-sobre-la-frambuesa-pi-pico/


En la propia placa de Raspberry se incluye un LED en el pin GP25, aunque externamente no se puede acceder al pin GP25.



/*
  Blink
*/

void setup()
{
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop()
{
  digitalWrite(LED_BUILTIN, HIGH); 
  delay(100);                     
  digitalWrite(LED_BUILTIN, LOW); 
  delay(100);                    
}



En el segundo montaje realizo un simple semáforo.
Se utilizan 5 pin de la Raspberry, 3 son para las luces de los coches, y 2 para las luces de los peatones.



/*
# SEMÁFORO PARA RASPBERRY PI PICO
# SETA43
# seta43.duckdns.org
# seta43.blogspot.com
# Palencia / España
# 25-08-2022
*/

#define sROJO 18
#define sAMARILLO 19
#define sVERDE 20

#define pVERDE 17
#define pROJO 16

int tPARPADEO=400;
int tSEMAFORO=10000;
int tAMARILLO=3000;
long tPEATON=6000;

void setup()
{
  pinMode(sROJO, OUTPUT);
  pinMode(sAMARILLO, OUTPUT);
  pinMode(sVERDE, OUTPUT);

  pinMode(pVERDE, OUTPUT);
  pinMode(pROJO, OUTPUT);

  //#INICIALIZAR
  digitalWrite(sAMARILLO, HIGH);
  digitalWrite(sROJO, HIGH);
  digitalWrite(sVERDE, LOW);
  digitalWrite(pROJO, HIGH);
  digitalWrite(pVERDE, LOW);
  delay(2);

}


void loop()
{
  digitalWrite(sAMARILLO, LOW);
  digitalWrite(sROJO, HIGH);
  digitalWrite(pROJO, LOW);
  digitalWrite(pVERDE, HIGH);
  delay(tPEATON);

  //Parpadeo verde peatón
  for(int z=0;z<=7;++z)
  {
    digitalWrite(pVERDE, LOW);
    delay(tPARPADEO);
    digitalWrite(pVERDE, HIGH);
    delay(tPARPADEO);
  }
  digitalWrite(pROJO, HIGH);
  delay(1000);

  digitalWrite(sVERDE, HIGH);
  digitalWrite(sROJO, LOW);
  delay(tSEMAFORO);
  digitalWrite(sAMARILLO, HIGH);
  digitalWrite(sVERDE, LOW);
  delay(tAMARILLO);
 
}







VÍDEOS



En cuestión de consumo, la placa Raspberry pi pico alimentada con 4V en el pin VSYS, el consumo es de entre 23 y 30 mA.

En cuanto a velocidad de programar en python a programar en C el resultado es el siguiente;

#python
# 74 KHz


import machine

led = machine.Pin(17, machine.Pin.OUT)

while True:
    led.value(0)
    led.value(1)

//  IDE arduino
//  sin goto 606 KHz

//  con goto 798 KHz

void setup()
{
  pinMode(17, OUTPUT);
}

void loop()
{
volver:
  digitalWrite(17, HIGH);                     
  digitalWrite(17, LOW);                      
  goto volver;
}

Debemos saber que se sube a la placa el programa mucho más rápido con el entorno de Python.
Vemos también que es 10 veces más rápido el programa en C.
Para casos que no se necesite mucha rapidez, como el caso del semáforo, es más cómodo programar en Python.



Espero que este montaje os haya parecido interesante.
 
Saludos.
Juan Galaz



Bibliografía:
seta_PIA
https://www.electroniclinic.com/raspberry-pi-pico-rp2040-programming-in-micropython-with-examples/
https://www.youtube.com/watch?v=2gihPgEkvL8
https://picockpit.com/raspberry-pi/es/todo-sobre-la-frambuesa-pi-pico/

miércoles, 24 de agosto de 2022

Raspberry pi pico Python Práctica 1 y 2, Blink, Semáforo

  Página principal

Raspberry pi pico
Python
Práctica 1 y 2




Este es mi primer contacto con la Raspberry pi pico, además de su programación en python.
En estos dos primeros montajes realizaré un parpadeo de un LED y en el segundo un semáforo.
Para programar en python debemos realizar unos pasos previos. He realizado un pequeño tutorial en vídeo de como instalar el entorno python sobre Linux.
Video tutorial.
Para los que les guste una explicación mas completa os dejo dos enlaces:

https://www.electroniclinic.com/raspberry-pi-pico-rp2040-programming-in-micropython-with-examples/
https://www.youtube.com/watch?v=2gihPgEkvL8

En la propia placa de Raspberry se incluye un LED en el pin GP25, aunque externamente no se puede acceder al pin GP25.
También he colocado un LED externo conectado al pin GP26 mediante una resistencia de 1K.



import machine
import utime

led = machine.Pin(25, machine.Pin.OUT)
led26 = machine.Pin(26, machine.Pin.OUT)

while True:
    led.value(0)
    led26.value(0)
    utime.sleep(0.1)
    led.value(1)
    led26.value(1)
    utime.sleep(0.1)





En el segundo montaje realizo un simple semáforo.
Se utilizan 5 pin de la Raspberry, 3 son para las luces de los coches, y 2 para las luces de los peatones.
# SEMÁFORO PARA RASPBERRY PI PICO
# SETA43
# seta43.duckdns.org

# seta43.blogspot.com
# Palencia / España
# 24-08-2022

import machine
import utime


sROJO = machine.Pin(18, machine.Pin.OUT)
sAMARILLO = machine.Pin(19, machine.Pin.OUT)
sVERDE = machine.Pin(20, machine.Pin.OUT)

pROJO = machine.Pin(16, machine.Pin.OUT)
pVERDE = machine.Pin(17, machine.Pin.OUT)

tPARPADEO=0.4
tSEMAFORO=10
tAMARILLO=3
tPEATON=6

#INICIALIZAR
sAMARILLO.value(1)
sROJO.value(1)
sVERDE.value(0)
pROJO.value(1)
pVERDE.value(0)
utime.sleep(2)

while True:
    sAMARILLO.value(0)
    sROJO.value(1)
    pROJO.value(0)
    pVERDE.value(1)
    utime.sleep(tPEATON)
   
    #PARPADEO VERDE PEATON
    for i in range(0, 7):
        pVERDE.value(0)
        utime.sleep(tPARPADEO)
        pVERDE.value(1)
        utime.sleep(tPARPADEO)  
    pROJO.value(1)
    utime.sleep(1)
   
    sVERDE.value(1)
    sROJO.value(0)
    utime.sleep(tSEMAFORO)   
    sAMARILLO.value(1)
    sVERDE.value(0)
    utime.sleep(tAMARILLO)






VÍDEO SEMÁFORO

Espero que este montaje os haya parecido interesante.


Saludos.
Juan Galaz



Bibliografía:
https://www.electroniclinic.com/raspberry-pi-pico-rp2040-programming-in-micropython-with-examples/
https://www.youtube.com/watch?v=2gihPgEkvL8


jueves, 8 de abril de 2021

ESP32 BLINK


 

ESP32

BLINK


Este es mi primer contacto con el ESP32, es el hermano mayor de ESP8266 con el cual tomé contacto en:
espaa.html
espb.html
Existen multitud de páginas que explican mucho mejor que yo todas sus características , ver bibliografía.
Hay diferentes módulos del ESP32, y varían los pins y características.
Lo primero es instalar la placa ESP32 en la IDE del Arduino.
Añadir : https://dl.espressif.com/dl/package_esp32_index.json  en Gestor de URLs.....

Buscar esp32 e instalar.

Seleccionar vuestra tarjeta. En mi caso es ESP32 Dev Module.

Leemos el programa y compilamos.
En Linux nos puede ocurrir un error, que aunque tengamos instalado python nos salga un error de que no lo encuentra.
    exec: "python": executable file not found in $PATH
La solución es hacer un enlace, en Ubuntu 20 se hace con:
    sudo ln -s /usr/bin/python3 /usr/bin/python
Otro error fue que no tenía instalado la librería serial de python, en Ubuntu 20 lo hago con:
    sudo apt-get install python3-serial
Ahora si todo fue bien compilará e instalará.

Para mis prácticas he utilizado el ESP32-WROOM-32D, aunque en los esquemas utilice otro módulo, por lo que los pins varían.
int ledPin = 2;
void setup()
{
  pinMode(ledPin, OUTPUT);
}
void loop()
{
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

El primer proyecto es el parpadeo de un LED.




En algunos modelos de ESP32 como la placa de Althinker nos son capaces de entrar en modo de programación automática.
Cada vez que programamos el módulo debemos pulsar el botón BOOT.
Para los que quieran solucionar esta pega, se puede solucionar colocando un condensador de 22uF del pin EN a GND




Este será  el primero de una serie de artículos con el ESP32.

VÍDEO

Saludos.
Juan Galaz

Bibliografía:
https://randomnerdtutorials.com/installing-the-esp32-board-in-arduino-ide-windows-instructions/
https://www.profetolocka.com.ar/2020/07/09/programando-el-esp-32-con-el-arduino-ide/
https://www.prometec.net/presentando-el-esp32/


viernes, 17 de enero de 2020

Primeros pasos con ESP8266 IDE Arduino - BLINK

Página principal

ESP8266

BLINK


Hace 5 años había realizado montajes con el ESP8266, pero lo utilizaba con el Arduino para las comunicación.
Solo lo utilizaba mediante comando AT, a modo de modem, y la comunicación la hacia mediante el puerto serie.
    Arduino NANO - SERVER WEB con ESP8266 - Servidor de temperatura-ds18B20. ardwifi
En estos 4 años la programación del ESP8266 avanzó mucho, ahora el ESP8266 se puede programar directamente desde la IDE del Arduino. Como enseñar a configurar  la IDE de Arduino para programar el ESP8266 sería demasiado repetitivo debido a la gran cantidad de tutoriales que existen, he creído que lo mejor sería indicar los mejores enlaces que yo he encontrado.

https://polaridad.es/programar-un-modulo-wifi-esp8266-desde-el-ide-de-arduino/
https://www.luisllamas.es/programar-esp8266-con-el-ide-de-arduino/
https://www.instructables.com/id/Quick-Start-to-Nodemcu-ESP8266-on-Arduino-IDE/
https://www.esploradores.com/instalacion-del-gestor-del-microprocesador-es8266-en-el-ide-de-arduino/

En estas páginas se explica bastante bien como configurar la IDE del Arduino, seguro que existen otras muchas, pero son las que he utilizado.
Lo primero que he probado es hacer parpadear un LED , es como el hola mundo de la programación.
ESP8266 Blink
// El LED montado en el módulo está conectado a D4

#define LED D4

void setup()
{
  pinMode(LED, OUTPUT); 
}

void loop()
{
  digitalWrite(LED, LOW);
  delay(1000);                    
  digitalWrite(LED, HIGH); 
  delay(1000); 
}

Placa de desarrollo NodeMcu V3.

Lo primero que notamos al compilar y subir el programa es lo mucho que tarda, 21 segundos.
También lo que extraña es el tamaño del programa, 257672 bytes (24%), he de suponer, que sea debido a que además del programa suba un interprete o un pequeño sistema operativo.
Las siguientes modificaciones en el programa y su posterior compilación-subida a la placa solo tardan 8 segundos.
Haciendo algunas pruebas con compilación-subida a la placa, he notado que es mas rápido en versiones de sistema operativo de 32 bits que la de 64 bits , 20% mas rápido. Yo siempre he pensado que los 64 bits están sobrevalorados en muchas aplicaciones y procesadores.

Lo curioso de estas placas es el no disponer de un piloto LED que nos informe que la placa está alimentada, en muchas ocasiones no sabes si la tienes conectada.
Existe un un LED conectado al pin D4, que es el que utilizamos para nuestro montaje. En otros modelos de placa de desarrollo se encuentra conectado a otro pin.


En mi segunda prueba intento saber la máxima frecuencia de parpadeo del LED.
ESP8266 Blink-2
/*
  ESP8266 Blink
*/
// 545 KHz  y parpadeo cada 3 Segundos

#define LED D0

void setup() 
{
  pinMode(LED, OUTPUT); 
  ESP.wdtDisable();  
}

void loop()
{
volver:
  digitalWrite(LED, LOW);                   
  digitalWrite(LED, HIGH);
  ESP.wdtFeed(); //de otra forma salta el Watch Dog
  goto volver; 
}

El resultado de las pruebas me da 545 KHz  y parpadeo cada 3 Segundos, es como si hubiese una interrupción cada 3 segundos.
Después de mucho mirar por la WEB he descubierto que tiene activado por defecto el pero guardián cada 3 segundos.
Con la orden   ESP.wdtDisable();  desactivamos el Watchdog .
Aún así sigue reseteando cada 8 segundos.
Cuando el
Watchdog está desactivado durante mucho tiempo el módulo se desactiva.
Con la orden ESP.wdtFeed(); ya no se resetea el módulo, aunque pierda velocidad. ?????
El resultado es de 332KHz, y una onda que no es cuadrada.

/*
  ESP8266 Blink-2 versión 2
  384 KHz 
*/

#define LED D0

int z;

void setup()
{
  pinMode(LED, OUTPUT);
  ESP.wdtDisable(); 
}

void loop()
{
volver:
  digitalWrite(LED, LOW);                  
  digitalWrite(LED, HIGH);
  z++;
  if(z>60000)
    {
      ESP.wdtFeed(); //de otra forma salta el Watch Dog
      z=0;
    }
  goto volver;
}
Otro modo es poner cada cierto tiempo ESP.wdtFeed(); y ganamos algo de velocidad llegando a 384 KHz.

En un montaje hice pruebas stm2.html
En un  Arduino hacemos oscilar el puerto a 96 KHZ  ,y si utilizamos el 32F103C8T6 oscila a 817KHz .
Como con el Arduino tengo práctica, sé bastantes trucos, y  podemos llegar a 2.6 Mhz , incluso a 3.9 Mhz haciendo alguna trampa.

Otra de las prueba que suelo hacer es un bucle.

Bucle
//  Arduino
//  22.6 Seg.  __2000

//  STM
//  5.8 Seg.  ___2000

// ESP8266
// 6 Segundos

int n1,n2;
char z;

// STM
//#define LED PA0

//Arduino
//#define LED 13

//ESP8266
#define LED D0

void setup()
{
  pinMode(LED, OUTPUT);
  ESP.wdtDisable();
  Serial.begin(115200);
}

void loop()
{
    Serial.println("0");
    digitalWrite(LED, LOW);

    for(n1=0;n1<30000;n1++)
      {
        for(n2=0;n2<2000;n2++) { z=1; }
        ESP.wdtFeed();
      }
   
    Serial.println("1");
    digitalWrite(LED,HIGH );

    for(n1=0;n1<30000;n1++)
      {
        for(n2=0;n2<2000;n2++) { z=1; }
        ESP.wdtFeed();
      }           
}

El resultado es de 6 Segundos, parecido al  32F103C8T6 que tarda 5.8 Segundos.

Aunque me gusta el ESP8266  por su precio, tener WIFI y la memoria que lleva, veo que hay mucho que aprender en cuanto a su programación

Espero que les guste este montaje.

Saludos.
Juan Galaz

Bibliografía:

https://polaridad.es/programar-un-modulo-wifi-esp8266-desde-el-ide-de-arduino/
https://www.luisllamas.es/programar-esp8266-con-el-ide-de-arduino/
https://www.instructables.com/id/Quick-Start-to-Nodemcu-ESP8266-on-Arduino-IDE/
https://www.esploradores.com/instalacion-del-gestor-del-microprocesador-es8266-en-el-ide-de-arduino/

https://randomnerdtutorials.com/projects/#esp8266
https://randomnerdtutorials.com/getting-started-with-esp8266-wifi-transceiver-review/
https://www.prometec.net/esp8266-pluggin-arduino-ide/