Problemas al reconocer el puerto con el ESP8266



Node MCU
 es una plataforma para el desarrollo de proyectos IoT que integra el famoso chip ESP8266, el cual se ha extendido enormemente debido a su facilidad para desarrollar proyectos open source  que pueden ademas  pueden   involucrar el IoT  .

Esta placa  destaca  porque integra capacidades de comunicación via WiFi , conteniendo en su interior  un microprocesador que puede ser programado fácilmente usando el  conocido lenguaje de programación Lua o bien vía Arduino IDE.

Obviamente ante todo no podemos perder de vista su bajisimo precio ( menos de 7.5€  ) comparados con otras opciones , pues no debemos olvidar  que incluye  el modulo wifi integrado  y un bus GPIO para conectar dispositivos de E/S.
Node MCU es una plataforma de desarrollo permite un prototipado rápido, para una vez satisfechos con el resultado, portar el desarrollo a un sistema final con un chip ESP8266 como pieza central.

A la hora de programar nuevas funciones, si optamos por utilizar Lua, dispondremos de un sistema simple con buena comunidad de usuarios. En cambio programar con el sistema Arduino nos aporta un fantástico IDE y un sinfin de manuales y ejemplos de desarrollo.

Este modulo es Ideal como una solución independiente en lugar de Arduino además de Wi-Fi  integrado siendo fácil de programar a través del IDE de Arduino (como vamos a ver ) , al igual que un Arduino.
Todos los periféricos con bus I2C puede unirse,por ejemplo Pantallas OLED, pantallas LCD, temperatura, presión, sensores de humedad pueden ser conectados en paralelo. También se puede conectar múltiples DS18B20

Sin embargo, sólo hay una entrada analógica y salida y las pantallas táctiles no se pueden conectar con ella.

Los pasos  a seguir   para conectar un ESP8266     son los siguientes:

  •  Instalación del IDE de Arduino .Si aun no lo tiene instalado ,se puede hacer  desde aqui
  • Instalación  del paquete de la placa ESP8266 en Arduino IDE  siguiendo las instrucciones del sitio : https://github.com/esp8266/Arduino
esp
  • Instalación de los controladores USB

Es necesario instalar el controlador USB requerido en su ordenador  para que pueda programar el ESP8266.  Independientemente de la opción de firmware que elijamos, primero necesitamos comunicarnos con la placa de desarrollo ESP-12E utilizando la interfaz USB de la computadora.

El módulo USB a Serial UART incluido en la placa es Silicon Labs ‘CP2012, para lo cual generalmente necesitamos instalar los controladores de puerto COM virtual (VCP) fácilmente disponibles para su sistema operativo específico.Una vez instalado, debemos verificar que el CP2102 sea reconocido por su ordenador.

Una vez que el controlador está instalado, podemos conectar el cable USB al puerto USB de la computadora y la placa. Después de hacerlo, deberíamos ver el mensaje: software del controlador del dispositivo instalado correctamente.

Además, podemos verificar manualmente que todo funcione correctamente siguiendo estos pasos:

Abra el Administrador de dispositivos (disponible a través del Panel de control → Sistema y seguridad → Administrador de dispositivos en la sección Sistema)
Debajo de la entrada Puertos (COM & LPT), debe haber un puerto abierto llamado USB-SERIAL CP2102 (COM) donde hay un número típicamente mayor o igual a 3.

Ahora que estamos listos para comunicarnos con nuestro ESP8266 a través del CP2102, podemos explorar algunas de las diferentes opciones de firmware disponibles.

  • Conecte  un cable usb  de datos al ESP8266
  • Seleccione   Herramientas –>ESP8266   y ahi la placa que haya comprado. En caso de  haberla comprado en Amazon aqui seleccione  NodeMCU 1.0 (ESP-12EModule).

node.png
  • En el IDE de Arduino, vaya al menú de herramientas, seleccionada su placa y elija el  puerto al que está conectado su ESP8266.En el ejemplo  es el COM11
puerto.png

Problemas al reconocer el puerto

En varios casos, la placa no se detecta debido a que faltan los controladores. Sin embargo, también puede ser por el puerto USB o el cable.

Si después de instalar los controladores sigue sin funcionar, por favor:

  • Verifique conectando la placa en otro puerto
  • Intente cambiar el cable USB de conexión por otro porque a veces aunque haya alimentación pueden fallar ( no olvidar que en un cable USB standard deberia haber 4 hilos)
  • Pruebae en otro ordenador distinta

Una vez dicho eso, veamos los controladores de NodeMCU 8266 en Windows.

Controladores para esp8266 en Windows

Hay que ir al siguiente enlace:

https://github.com/nodemcu/nodemcu-devkit/tree/master/Drivers

Y descargar el archivo que se llama CH341SER_WINDOWS.zip. Si quieres un enlace directo lo dejo aquí:

https://github.com/nodemcu/nodemcu-devkit/raw/master/Drivers/CH341SER_WINDOWS.zip

Una vez que lo descargues, extraer el fichero comprimido con extension .zip. Tendrá un programa llamado CH341SER.EXE, ejecútelo y dale permisos de administrador.

En la siguiente ventana haz click en Install:

Instalar drivers de NodeMCU 8266 en Windows

Espere a recibir la notificación de que se ha instalado y eso es todo. Debe detectar el dispositivo en un puerto COM; yo lo tenía en el COM4.

Conclusión

Es necesario mencionar que esto lo probé en Windows 10 de 64 bits usando PlatformIO dentro de Visual Studio Code, pero supongo que debe funcionar de igual modo en otras plataformas.

Lo explicado aquí está en un issue de GitHub.

Simulador de Arduino


En el mundo del modelado 3D, Tinkercad se ha establecido como una valiosa introducción al diseño asistido por computadora (CAD) . Es un programa CAD gratuito e intuitivo basado en la web que cualquiera puede usar. De hecho, si desea comenzar con Tinkercad, incluso tenemos un tutorial para principiantes para que pueda comenzar .

Recientemente, Tinkercad ha introducido algo nuevo: una expansión para incluir circuitos en su capacidad de diseño llamada Tinkercad Circuits. Esto aporta un lado completamente nuevo a Tinkercad, que gira en torno a la simulación de circuitos con Arduino.

Arduino es una plataforma de creación de prototipos electrónicos de código abierto que también vende microcontroladores. Tinkercad Circuits permite a cualquiera crear y programar virtualmente proyectos Arduino sin la necesidad de hardware físico.

En este artículo, le mostraremos cómo programar un Arduino básico en Tinkercad, pero primero, echemos un vistazo más de cerca a las nuevas capacidades que ofrece Tinkercad Circuits.

Vamos a utilizar una herramienta de Autodesk gratuita y en la red: Tinkercad , pues en efecto de servir como una herramienta excelente de diseño en 3d también incluye un editor de componentes electrónicos, y lo que es aun mas interesante : un simulador

Una vez que decida crear un circuito, utilizará el nuevo entorno de Tinkercad Circuits. Puede parecer mucho al principio, pero no se deje intimidar: tenemos toda la información que necesita para tener éxito. Verá rápidamente que esta plataforma creativa es una excelente herramienta de creación de prototipos.

Área de construcción

En el lado derecho de la pantalla, verá un grupo de componentes electrónicos de arrastrar y soltar. Además, puede buscar y filtrar a través de una cantidad impresionante de componentes disponibles: hay de todo, desde LED hasta circuitos integrados (IC), e incluso algunas herramientas de instrumentos.

El área de construcción abierta es donde diseñas su creación. La barra de herramientas superior que comienza a la izquierda le brinda las operaciones generales para rotar, eliminar e incluso tomar notas sobre sus diferentes componentes. Una característica interesante es que, además de exportar y compartir su trabajo, puede descargar la lista de componentes. Esto hace que sea más fácil llevar sus creaciones al mundo real.

Para hacer las cosas fáciles vamos a usar un simple arduino al que conectaremos 4 entradas analógicas, y 5 digitales

Las entradas analógicas las conectaremos a 4 potenciómetros cuyo punto central lo enviaremos a los GPIO simulando asi 4 señales analógicas por lo que conectaremos también estos a 4 instrumentos analógicos para que de este modo podamos comprobar el valor de las salidas.

Las entradas digitales las conectaremos a un conmutador DIP y sus salidas conectaremos también a 4 leds con sus correspondientes resistencias con el fin de poder comprobar de este modo el estado de dichos interruptores.

Por ultimo conectaremos un pulsador y un led que no indica que el circuito esta funcionando,

Mas en detalle este es el esquema del montaje:

El diseño lo p uede descargar desde https://www.tinkercad.com/things/5P9LP1tlS9O-panel-osciloscopio-con-arduino-/

Área de programación

Una vez que tenga un componente programable en su diseño, puede abrir el visor de “Código” haciendo clic en el botón en la parte superior derecha de la barra de herramientas. Actualmente, los únicos dos dispositivos disponibles son el Arduino Uno R3 y el ATTiny. (El ATTiny es un Arduino más limitado y miniaturizado).

El área de programación es un entorno de desarrollo integrado (IDE) simplificado que hace que la programación del Arduino sea muy sencilla. El método predeterminado es a través de bloques de código, que veremos más adelante, y también hay una vista dual para aprender cómo los bloques de código se traducen en código real. Para aquellos que ya están familiarizados con la biblioteca Arduino, incluso hay una vista de texto.

En cuanto al código Arduino, simplemente hay que pulsar en el botón “Código” y justo ahí copiaremos el código de mas abajo ( ojo porque debe ser correcto sintácticamente hablando, porque en caso de que cometamos un error nos dará un error)

Este es el código para probar el montaje:

#define Sel1 7 // el potenciometro  P1 LO conectamos al GPIO7
#define Sel2 8 // el potenciometro  P2 LO conectamos al GPIO8
#define Sel3 9 // el potenciometro  P3 LO conectamos al GPIO9  
#define Sel4 10 //el potenciometro  P4 LO conectamos al GPIO10

#define trigger 3 // el pin al que conectamos el pulsador

int val = 0; //val se emplea para almacenar el estado del boton
int state = 0; // 0 se muestrean las señales de los ADC
int old_val = 0; // almacena el antiguo valor de val

int y1;  //Variable donde se guardara el valor leido del pin A0
int y2;  //Variable donde se guardara el valor leido del pin A1
int y3;  //Variable donde se guardara el valor leido del pin A2
int y4;  //Variable donde se guardara el valor leido del pin A3


void setup() {
  
  Serial.begin(115200);
  pinMode(Sel1,INPUT_PULLUP);
  pinMode(Sel2,INPUT_PULLUP);
  pinMode(Sel3,INPUT_PULLUP);
  pinMode(Sel4,INPUT_PULLUP);

  pinMode(trigger,INPUT_PULLUP);
  Serial.println("Empezando la simulacion");
}

void loop() {

   val = digitalRead(trigger); // lee el estado del Boton
    if ((val == HIGH) && (old_val == LOW)) {  //Detectamos flanco de subida
        state = 1 - state;           //Cambiamos el valor de state de 0 a 1 ó de 1 a 0            
        delay(10);               //pausa de 10ms
    }
    old_val = val; // actualizamos el valor del antiguo estado


  if (!state) {  //si la variable state es 0 escribimos en el serial


        if (!digitalRead(Sel1) && !digitalRead(Sel2)&& !digitalRead(Sel3) && !digitalRead(Sel4)) {
            
            y1 = analogRead(A0);  //Leemos el conversor A1 y guardamos la lectura en sensor1
            Serial.print(y1);      //Imprimimos en el serial el valor de sensor1
            Serial.print(",");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms

            y2 = analogRead(A1);  //Leemos el conversor A1 y guardamos la lectura en sensor1
            Serial.print(y2);      //Imprimimos en el serial el valor de sensor1
            Serial.print(",");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms

            y3 = analogRead(A2);  //Leemos el conversor A1 y guardamos la lectura en sensor1
            Serial.print(y3);      //Imprimimos en el serial el valor de sensor1
            Serial.print(",");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms

            y4 = analogRead(A3);  //Leemos el conversor A1 y guardamos la lectura en sensor1
            Serial.println(y4);      //Imprimimos en el serial el valor de sensor1
            //Serial.println(" ");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms
        }

    
          if (digitalRead(Sel1) && !digitalRead(Sel2)&& digitalRead(Sel3) && digitalRead(Sel4)) {
            
           // y1 = analogRead(A0);  //Leemos el conversor A1 y guardamos la lectura en sensor1
           // Serial.print(y1);      //Imprimimos en el serial el valor de sensor1
            Serial.print("");
            Serial.print(",");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms

            y2 = analogRead(A1);  //Leemos el conversor A1 y guardamos la lectura en sensor1
            Serial.print(y2);      //Imprimimos en el serial el valor de sensor1
            Serial.print(",");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms

           // y3 = analogRead(A2);  //Leemos el conversor A1 y guardamos la lectura en sensor1
          //  Serial.print(y3);      //Imprimimos en el serial el valor de sensor1
            Serial.print("");
            Serial.print(",");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms

            //y4 = analogRead(A3);  //Leemos el conversor A1 y guardamos la lectura en sensor1
           // Serial.println(y4);      //Imprimimos en el serial el valor de sensor1
            Serial.println(" ");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms
        }
        


    }

}

Solución de problemas:  si su programa no se comporta como se esperaba, verifique su cableado y programación. Asegúrese de que todos los pines estén conectados correctamente y de que cada bloque esté escrito correctamente.

Si todo parece funcionar, ¡enhorabuena! Siempre puede seguir jugando con el código y los diferentes componentes para aprender más sobre cómo funciona todo.

Fáciles medidas de c.a. con Arduino


Medir la tensión de ca de la red de suministro con Arduino puede ser una labor compleja dado el rango de tensiones que manejamos ,pero gracias a los transformadores de tensión vamos a ver cómo medir voltaje CA hasta 250 V, tanto en 50 Hz como en 60 Hz, usando el ZMPT101B, (ese es el nombre del transformador solamente, pero lo encontrará con este nombre o “sensor de voltaje CA”).

Este módulo basado en un transformador de precisión para medidas (el zMPT101B) y un circuito operacional (el LM358) con la electronica asociada

Hemos de dicir que ,usado el código correcto, es mucho mejor esta electronica para las medidas, que los otros métodos que usan transformador + rectificador + divisor de voltaje….que no siempre dan los valores correctos. Puede que otros sistemas muestren la señal cuadrada o triangular,lo cual afecta seriamente el RMS, pues el RMS es lo que queremos medir, y para ello debemos mantener la misma forma de la señal asi que al adaptarlo para el Arduino,y aquí es cuando el módulo es útil.

Debemos advertir nuevamente que este tipo de circuitos pueden ser peligrosas si no se extrema las medidas pues en los bornes atornillados debemos conectar la carga de ca de 220V

Sineses.png

El módulo toma la señal que queremos medir, aquí una potencia doméstica de 220V, tiene alrededor de 311V como pico.

El transformador del módulo lo devuelve al pico de 2.5V

Luego agrega un desplazamiento de 2.5V para adaptarlo al Arduino.

       

  Y aquí preste atención, algunos códigos se usan con este módulo, solo hacen una muestra de la señal y miden los picos, luego una pequeña multiplicación, y puede mostrarle el “RMS” de esta señal, pero esos códigos funcionan solo para señal de onda sinusoidal perfecta, si está midiendo otra forma de la señal sería falsa.

Y, por ejemplo, aquí utilizamos un atenuador de luz(dimmer), que se basa en un Triac y ya conoces la forma “extraña” de la señal que hace un Triac.

artículo-2014julio-ics-responde-el-desafío-de-fig1

Aquí puede ver que para medir el RMS no solo debe medir los picos y hacer los mismos cálculos para la señal de onda sinusoidal.

Pero debe hacerlo de la manera correcta y es muy difícil de codificar, por eso usaremos una biblioteca simple que como siempre hará el trabajo por nosotros. 

Visualización de la información

Para mostrar las medidas se puede usar por ejemplo una pantalla OLED en lugar de las tipicas basadas en LCD con el controlador de Toshiba HD44780,

LCD es el acrónimo de Liquid Crystal Display (en español Pantalla de Cristal Líquido). No podemos considerar que se trate de una tecnología novedosa. El LCD lleva con nosotros mucho tiempo, solo tenemos que echar la mirada hacia atrás y recordar esos relojes Casio o las calculadoras que llevamos a clase de matemáticas.

Estamos acostumbrados a que la materia pueda estar en estado sólido, líquido o gaseoso, los llamados estados de la materia. Pero ya en el siglo XIX se descubrió que había más estados en los que podía encontrarse la materia. El cristal líquido se encuentra en algún lugar entre el sólido y líquido.No es el objetivo de este post la física involucrada detrás de los LCD, solo decir que utiliza las propiedades de la luz polarizada para mostrarnos la información en una pantalla. A partir de una serie de filtros, se consigue mostrar la información gracias a la iluminación de fondo.

Hay una amplia gama de pantallas LCDs que podemos utilizar con Arduino. Aparte de las funcionalidades extra que nos puedan dar cada una de ellas, las podemos diferenciar por el número de filas y columnas, su tamaño.

Por ejemplo, una pantalla LCD de 16×1 tendrá una fila de 16 caracteres es decir, solo podremos mostrar 16 caracteres simultáneamente, al igual que un LCD de 20×4 tendrá 4 filas de 20 caracteres cada una.

LCD

En este artículo vamos a trabajar con un LCD típico, de 16×2. Esto significa que vamos a poder mostrar 16 caracteres en la primera fila y los mismos en la segunda fila.

La mayoría de las pantallas LCD que se están haciendo ahora, vienen con una fila de dieciséis pines. Los primeros catorce pines se utilizan para controlar la visualización. Los dos últimos son para la iluminación de fondo.

Aunque el dato se puede enviar en 8 bits , lo normal es usarlo partido en “trozos” de 4 bits, labor que será transparente al usuario gracias a las librería LiquidCrystal.h y que como es obvio se emplea para ahorrarnos 4 lineas de datos del GPIO de modo que necesitaríamos 4 para datos + 3 de control =7 pines de datos lógicamente mas 2 mas para la alimentación de 5v DC

PINFUNCIÓN
1GND (Tierra)
25 Voltios
3Control de contraste pantalla
4RS – Selector entre comandos y datos
5RW – Escritura y lectura de comandos y datos
6Sincronización de lectura de datos
7-14Pines de datos de 8-bit
15Alimentación luz de fondo (5V)
16GND (Tierra) luz de fondo (0V)

En la siguiente imagen vemos la correspondencia con los pines físicos del LCD.

Pines LCD 16x2

Esta imagen muestra la parte de abajo del LCD. Cuando lo conectes a la protoboard los pines estarán invertidos horizontalmente.

Otra alternativa es usar una pantalla OLED i2c de 128 * 32 , cuyo coste es irrisorio. Este tipo de pantallas esde reducidasa dimensiones y , puede usarlas en algunos proyectos pequeños de bricolaje y también les brinda muchas posibilidades para hacer (diferentes fuentes y tamaños de textos, diferentes formas, desplazamiento, imágenes bmp …) Tenga en cuenta que este tipo de pantalla no es una pantalla a color, las “nornales ” solo imprimen en azul (Izquierda) pero las hay en blanco, y algunos pueden tener amarillo + uno de los colores anteriores .

Este es un ejemplo cableado con una pantalla OLED .Este cableado depende de su versión de pantalla ,( el que vemos usa 4 pines : dos para la alimentacion con 3,3V DC y los dos de datos no cableando el pin RST).

circuito

Conexiones finales

Wiring.png

Este es todo el cableado y, como se mencionó, estamos usando una pantalla OLED de 128 × 32, puede usarla o no, el módulo está alimentado por 5v y entrega una señal analógica.

Configuración:

Lo primero que debe hacer es calibrar el módulo con su potenciómetro, cablear el módulo, enchufar el Arduino y cargar este simple código, y no olvide colocar las sondas de medición en la toma de corriente (¡¡¡CUIDADO !!! ) y ya conoce el voltaje.

El código para probar esto es realmente simple , usando eso si, el Serial Plotter de Arduino IDE:

void setup() {
Serial.begin(9600);
}

void loop() 
{
Serial.println(analogRead(A0));
}

Abra el trazador de serie del IDE de Arduino:

parcela1
plot2

Verá algo como esto en su trazador de serie, significa que no adquiere toda la señal, ajuste el potenciómetro hasta que tenga algo que parezca una onda sinusoidal. Sé que esa no es la señal de onda sinusoidal de CA.

plot3

Cuando tenga algo como esto, puede agregar un retraso para ver una buena onda sinusoidal, aquí es porque estoy midiendo justo después de mi atenuador de luz, verá un pequeño pico antes del pico de señal si mide el enchufe directamente, no lo hará

sinewaveee.png

Ahora que su módulo está calibrado, las calibraciones del código se basarán en él, así que trate de no cambiarlo.

Código:

La biblioteca que usamos es Filters.h, reduce la cantidad de trabajo para usted, descargue aquí o desde Github . 

Bibliotecas de pantallas OLED de Adafruit

 /* This code works with ZMPT101B AC voltage sensor module and 128x32 OLED display
 * It permits you to measure any AC voltage up to 250V, BE CAREFUL !!!
 * The functions from Filters library permits you to calculate the True RMS of a signal
 * Refer to www.surtrTech.com or SurtrTech YouTube channel for more details
 */

#include <Filters.h> //Easy library to do the calculations
#include <SPI.h>     //Libraries for the OLED display
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 32 // OLED display height, in pixels
#define OLED_RESET    -1 //

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET); //Declaring the display name (display)

float testFrequency = 50;                     // test signal frequency (Hz)
float windowLength = 40.0/testFrequency;     // how long to average the signal, for statistist

int Sensor = 0; //Sensor analog input, here it's A0

float intercept = -0.04; // to be adjusted based on calibration testing
float slope = 0.0405; // to be adjusted based on calibration testing
float current_Volts; // Voltage

unsigned long printPeriod = 1000; //Refresh rate
unsigned long previousMillis = 0;


void setup() {
  Serial.begin( 9600 );    // start the serial port
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //Start the OLED display 
  display.clearDisplay();
  display.setTextSize(2);                   
  display.setTextColor(WHITE);              
  display.setCursor(1,1);               
  display.print("SurtrTech");
  display.setCursor(1,20);
  display.setTextSize(1);
  display.print("AC Voltmeter");
  display.display();
  delay(5000);

}

void loop() {
  
  RunningStatistics inputStats;                //Easy life lines, actual calculation of the RMS requires a load of coding
  inputStats.setWindowSecs( windowLength );
   
  while( true ) {   
    Sensor = analogRead(A0);  // read the analog in value:
    inputStats.input(Sensor);  // log to Stats function
        
    if((unsigned long)(millis() - previousMillis) >= printPeriod) {
      previousMillis = millis();   // update time every second
            
      Serial.print( "\n" );
      
      current_Volts = intercept + slope * inputStats.sigma(); //Calibartions for offset and amplitude
      current_Volts= current_Volts*(40.3231);                //Further calibrations for the amplitude
      
      Serial.print( "\tVoltage: " );
      Serial.print( current_Volts ); //Calculation and Value display is done the rest is if you're using an OLED display
      
      
      display.clearDisplay();
      display.setTextSize(3);       //size of the text that will follow              
      display.setTextColor(WHITE);  //its color            
      display.setCursor(1,1);      //position from where you want to start writing           
      display.print(current_Volts,1);
      display.setCursor(115,00);
      display.setTextSize(2);
      display.print("V");
      display.setCursor(115,15);
      display.setTextSize(1);
      display.print("AC");
      display.display();
    }
  }

}

Pruebas:

Los valores seguramente no son perfectos y 100% precisos, pero como ve, necesita calibraciones muy precisas para hacerlo perfecto, y no olvide que está usando un módulo de 10 $ o menos, y allí se compara con un multímetro que usa TRMS. , Verdadero valor eficaz.

     Un multímetro que no sea TRMS también le dará una lectura falsa para una señal que no sea de onda sinusoidal,

Fuente: https://surtrtech.com/