Traza:

Diferencias

Muestra las diferencias entre dos versiones de la página.

Enlace a la vista de comparación

Ambos lados, revisión anteriorRevisión previa
Próxima revisión		Revisión previa
iot:esp:esp32-ide [2025/11/19 14:52] – [Instalación en Arduino IDE] rabiot:esp:esp32-ide [2025/11/19 15:11] (actual) – rab
Línea 170: Línea 170:
  
 Debajo del LED interno parpadea (normalmente con una luz azul) junto con uno externo conectado a GPIO 2. Debajo del LED interno parpadea (normalmente con una luz azul) junto con uno externo conectado a GPIO 2.
- 
  
  
Línea 200: Línea 199:
 Por ejemplo, para leer el sensor táctil 0 (T0), debe hacer algo como: Por ejemplo, para leer el sensor táctil 0 (T0), debe hacer algo como:
  
-``` + 
-int value = touchRead(4); +  int value = touchRead(4); 
-```+
  
 Vamos a crear un código, donde si tocamos el sensor T0 (GPIO4), el LED se encenderá. Vamos a crear un código, donde si tocamos el sensor T0 (GPIO4), el LED se encenderá.
Línea 210: Línea 209:
 Debajo del código completo: Debajo del código completo:
  
-``` 
-/*****************************************************  
-* ESP32 Touch Test and LED Ctrl 
-* Touch pin ==> Touch0 is T0 which is on GPIO 4 (D4). 
-* LED pin   ==> D2 
-*  
-* MJRoBot.org 6Sept17 
-*****************************************************/ 
-#define TOUTCH_PIN T0 // ESP32 Pin GPIO4 o D4 
-#define LED_PIN 2 
  
-int touch_value = 100; +  /*****************************************************  
- +  * ESP32 Touch Test and LED Ctrl 
-//--------------------------------------------------- +  * Touch pin ==> Touch0 is T0 which is on GPIO 4 (D4). 
-void setup(){ +  * LED pin   ==> D2 
-  Serial.begin(115200);+  *  
 +  * MJRoBot.org 6Sept17 
 +  *****************************************************/ 
 +  #define TOUTCH_PIN T0 // ESP32 Pin GPIO4 o D4 
 +  #define LED_PIN 2 
 +   
 +  int touch_value = 100; 
 +   
 +  //--------------------------------------------------- 
 +  void setup(){ 
 +    Serial.begin(115200);
   while(!Serial){;}   while(!Serial){;}
        
-  Serial.println("ESP32 Touch Test"); +    Serial.println("ESP32 Touch Test"); 
-  pinMode(LED_PIN, OUTPUT); +    pinMode(LED_PIN, OUTPUT); 
-  digitalWrite (LED_PIN, LOW); +    digitalWrite (LED_PIN, LOW); 
-} +  } 
- +   
-//-------------------------------------------------- +  //-------------------------------------------------- 
-void loop(){ +  void loop(){ 
-  touch_value = touchRead(TOUTCH_PIN);+    touch_value = touchRead(TOUTCH_PIN);
      
-  Serial.println(touch_value);+    Serial.println(touch_value);
      
-  if (touch_value < 50){ +    if (touch_value < 50){ 
-    digitalWrite(LED_PIN, HIGH); +      digitalWrite(LED_PIN, HIGH); 
-    } +      } 
-  else{ +    else{ 
-    digitalWrite(LED_PIN, LOW);+      digitalWrite(LED_PIN, LOW);
   }   }
-  delay(1000); +    delay(1000); 
-} +  }
-```+
  
-![ESP32 Touch](https://media.giphy.com/media/Yw741LqTPQybu/giphy.gif) 
  
-## Entrada Análoga+=== Entrada Análoga ===
  
 Ahora probaremos como ingresar valores análogos de voltaje con un máximo de 3,3Vdc. Ahora probaremos como ingresar valores análogos de voltaje con un máximo de 3,3Vdc.
Línea 257: Línea 254:
 Hay en total 18 canales de entrada ADC de 12 bits cada uno, versus 1 ADC de 10 bits del ESP8266. Hay en total 18 canales de entrada ADC de 12 bits cada uno, versus 1 ADC de 10 bits del ESP8266.
  
-Canales ADC del ESP32:+== Canales ADC del ESP32: ==
  
   * GPIO0  ==> ADC2_CH1   * GPIO0  ==> ADC2_CH1
Línea 280: Línea 277:
 Para leer una entrada análoga, debe hacer lo mismo que ha hecho con el Arduino IDE y el ESP8266: Para leer una entrada análoga, debe hacer lo mismo que ha hecho con el Arduino IDE y el ESP8266:
  
-``` 
-int analog_value = analogRead(36); 
-``` 
  
-Es muy importante tener en cuenta que los ADC del ESP32 tienen 12bits de resolución (frente a 10bits en ESP8266 y Arduino), por lo que el rango total de lectura de ADC va a 4.095 (en vez de 1.027 en Arduinos y ESP8266) cuando se aplica un máximo de 3.3V a sus entradas.+  int analog_value = analogRead(36);
  
-Para la entrada, usemos un potenciómetro de 10K ohm, conectándolo entre 3.3V y GND. Usemos su salida variable del potenciometro para la entrada para los pines ESP32 ADC. El diagrama de arriba muestra el potenciómetro conectado a GPIO36 que es el ADC1 canal 0. Pruebe también otras entradas en su tarjeta. 
  
 +Es muy importante tener en cuenta que los ADC del ESP32 tienen 12bits de resolución (frente a 10bits en ESP8266 y Arduino), por lo que el rango total de lectura de ADC va a 4.095 (en vez de 1.027 en Arduinos y ESP8266) cuando se aplica un máximo de 3.3V a sus entradas.
  
-``` +Para la entrada, usemos un potenciometro de 10K ohm, conectándolo entre 3.3V y GND. Usemos su salida variable del potenciometro para la entrada para los pines ESP32 ADC. El diagrama de arriba muestra el potenciometro conectado a GPIO36 que es el ADC1 canal 0. Pruebe también otras entradas en su tarjeta.
-#define ANALOG_PIN_0  36+
  
-int analog_value = 0; 
  
-//---------------------------------------------------- +  #define ANALOG_PIN_0  36 
-void setup(){ +   
-  Serial.begin(115200); +  int analog_value = 0; 
-    while (!Serial) {;}+   
 +  //---------------------------------------------------- 
 +  void setup(){ 
 +    Serial.begin(115200); 
 +      while (!Serial) {;}
          
-  Serial.println("\n\nESP32 Analog IN Test"); +    Serial.println("\n\nESP32 Analog IN Test"); 
-} +  }
- +
-//---------------------------------------------------- +
-void loop(){ +
-  analog_value = analogRead(ANALOG_PIN_0); +
- +
-  float voltage = (analog_value * (3.3 / 4095));+
      
-  Serial.print("Valor Analogo: ");  Serial.print(analog_value); +  //---------------------------------------------------- 
-  Serial.print(", Voltaje: ");      Serial.println(voltage, 3); +  void loop(){ 
-  delay(500); +    analog_value = analogRead(ANALOG_PIN_0); 
-} +   
-```+    float voltage = (analog_value * (3.3 / 4095)); 
 +     
 +    Serial.print("Valor Analogo: ");  Serial.print(analog_value); 
 +    Serial.print(", Voltaje: ");      Serial.println(voltage, 3); 
 +    delay(500); 
 +  } 
  
 Gire su potenciómetro y observe en la salida del Serial Monitor del IDE Arduino, las mediciones que van de 0 a 4095. Gire su potenciómetro y observe en la salida del Serial Monitor del IDE Arduino, las mediciones que van de 0 a 4095.
  
-## Salida Análoga usando PWM (dimmer digital)+=== Salida Análoga usando PWM (dimmer digital) ===
  
 Si queremos *Atenuar un LED* en ESP8266 o Arduino, podemos simplemente usar un comando como *analogWrite()*, que variará el valor de PWM de su salida, simulando un valor analógico. Desafortunadamente, todavía no tenemos ese tipo de comando desarrollado para el ESP32 en Arduino IDE. Pero la muy buena noticia es que los 36 GPIO's del ESP32 tienen una capacidad PWM, *¡lo que es genial!*. Solo debemos usar código más complejo para alcanzar el mismo resultado. Si queremos *Atenuar un LED* en ESP8266 o Arduino, podemos simplemente usar un comando como *analogWrite()*, que variará el valor de PWM de su salida, simulando un valor analógico. Desafortunadamente, todavía no tenemos ese tipo de comando desarrollado para el ESP32 en Arduino IDE. Pero la muy buena noticia es que los 36 GPIO's del ESP32 tienen una capacidad PWM, *¡lo que es genial!*. Solo debemos usar código más complejo para alcanzar el mismo resultado.
Línea 322: Línea 318:
 Entonces, programemos uno de esos GPIO con una señal de salida PWM. Entonces, programemos uno de esos GPIO con una señal de salida PWM.
  
-Puede encontrar un muy buen tutorial en detalles sobre cómo funciona PWM en este enlace: [esp32-arduino-led-pwm-fading](https://techtutorialsx.com/2017/06/15/esp32-arduino-led-pwm-fading/).+Puede encontrar un muy buen tutorial en detalles sobre cómo funciona PWM en este enlace: [[https://techtutorialsx.com/2017/06/15/esp32-arduino-led-pwm-fading/|esp32-arduino-led-pwm-fading]].
  
 Lo primero que hay que pensar sobre la generación de una señal PWM es su frecuencia. Utilizaremos un valor de 5000 Hz, que funciona bien con el LED. También debemos especificar el canal LED PWM y la resolución del ciclo de trabajo PWM, en bits. Podemos elegir un canal de 0 a 15 y una resolución entre 1 y 16 bits. Usaremos el canal 0 y una resolución de 8 bits. Lo primero que hay que pensar sobre la generación de una señal PWM es su frecuencia. Utilizaremos un valor de 5000 Hz, que funciona bien con el LED. También debemos especificar el canal LED PWM y la resolución del ciclo de trabajo PWM, en bits. Podemos elegir un canal de 0 a 15 y una resolución entre 1 y 16 bits. Usaremos el canal 0 y una resolución de 8 bits.
  
-``` + 
-int freq = 5000; +   int freq = 5000; 
-int ledChannel = 0; +   int ledChannel = 0; 
-int resolution = 8; +   int resolution = 8; 
-```+
  
 Usemos GPIO2, donde tenemos nuestro LED externo conectado (y el interno) o podemos usar el GPIO0 para un led externo. Usemos GPIO2, donde tenemos nuestro LED externo conectado (y el interno) o podemos usar el GPIO0 para un led externo.
  
-``` + 
-#define LED_PIN 0 +  #define LED_PIN 0 
-```+
  
 Estos parámetros deben ser definidos en la etapa del *setup()*, usando las siguientes funciones: Estos parámetros deben ser definidos en la etapa del *setup()*, usando las siguientes funciones:
  
-``` + 
-void setup(){ +  void setup(){ 
- ledcSetup( ledChannel, freq, resolution ); +   ledcSetup( ledChannel, freq, resolution ); 
- ledcAttachPin( LED_PIN, ledChannel ); +   ledcAttachPin( LED_PIN, ledChannel ); 
-} +  } 
-```+
  
 Para encender el LED con un brillo específico, debemos definir el "ciclo de trabajo". Para encender el LED con un brillo específico, debemos definir el "ciclo de trabajo".
Línea 351: Línea 347:
 Por ejemplo, para apagar el LED, el ciclo de trabajo debe ser cero y la función ledcWrite (ledChannel, dutyCycle) utilizada para enviar el valor a través de un canal PWM específico: Por ejemplo, para apagar el LED, el ciclo de trabajo debe ser cero y la función ledcWrite (ledChannel, dutyCycle) utilizada para enviar el valor a través de un canal PWM específico:
  
-``` 
-int dutyCycle = 0; 
  
-ledcWrite( ledChannel, dutyCycle ); +  int dutyCycle = 0;   
-```+  ledcWrite( ledChannel, dutyCycle ); 
  
 Los diferentes valores de la variable *dutyCycle* encenderán el LED con diferente brillo. Esta variable, *dutyCycle*, variará de 0 a 255, una vez que la resolución utilizada sea de 8 bits. Los diferentes valores de la variable *dutyCycle* encenderán el LED con diferente brillo. Esta variable, *dutyCycle*, variará de 0 a 255, una vez que la resolución utilizada sea de 8 bits.
Línea 361: Línea 356:
 Podemos usar el potenciómetro (conectado a la variable *analog_value*) para configurar manualmente la variable *dutyCycle*, pero una vez que su rango de valores sea diferente, usemos una función de mapa para hacer coincidir la entrada y la salida: Podemos usar el potenciómetro (conectado a la variable *analog_value*) para configurar manualmente la variable *dutyCycle*, pero una vez que su rango de valores sea diferente, usemos una función de mapa para hacer coincidir la entrada y la salida:
  
-``` 
-dutyCycle = map( analog_value, 0, 4095, 0, 255 ); 
-``` 
  
-Ahora veremos el código completo:+  dutyCycle = map( analog_value, 0, 4095, 0, 255 );
  
-``` 
-/*****************************************************  
-* ESP32 Analog Input/Output Test  
-* Analog Input: ADC_1_0 pin ==> GPIO36 (VP). 
-* PWM LED pin   ==> GPIO0 
-*  
-* MJRoBot.org 6Sept17 
-*****************************************************/ 
-//Analog Input 
-#define ANALOG_PIN_0  36 
  
-// PMW LED +Ahora veremos el código completo:
-#define LED_PIN       0+
  
-int freq = 3000;          // Periodo de PWM 
-int ledChannel = 0; 
-int resolution = 8; 
-int dutyCycle = 0; 
  
-int analog_value = 0; +  /*****************************************************  
-//------------------------------------------------------- +  * ESP32 Analog Input/Output Test  
-void setup(){ +  * Analog Input: ADC_1_0 pin ==> GPIO36 (VP). 
-  Serial.begin(115200); +  * PWM LED pin   ==> GPIO0 
-    while(!Serial){;} +  *  
- +  * MJRoBot.org 6Sept17 
-  Serial.println("\n\nESP32 Analog IN/OUT Test");+  *****************************************************/ 
 +  //Analog Input 
 +  #define ANALOG_PIN_0  36
      
-  ledcSetup(ledChannel, freq, resolution); +  // PMW LED 
-  ledcAttachPin(LED_PIN, ledChannel); +  #define LED_PIN       0
-  ledcWrite(ledChannel, dutyCycle); +
-} +
- +
-//------------------------------------------------------- +
-void loop(){ +
-  analog_value = analogRead(ANALOG_PIN_0); +
-  Serial.println(analog_value);+
      
-  dutyCycle = map(analog_value, 0, 4095, 0, 255); +  int freq = 3000;          // Periodo de PWM 
-  ledcWrite(ledChannel, dutyCycle); +  int ledChannel = 0; 
-  delay(500); +  int resolution = 8; 
-} +  int dutyCycle = 0; 
-``` +   
- +  int analog_value = 0; 
-![ESP32 PWM + POT](https://media.giphy.com/media/LTa4zJFsUzQiI/giphy.gif)+  //------------------------------------------------------- 
 +  void setup(){ 
 +    Serial.begin(115200); 
 +      while(!Serial){;} 
 +   
 +    Serial.println("\n\nESP32 Analog IN/OUT Test"); 
 +     
 +    ledcSetup(ledChannel, freq, resolution); 
 +    ledcAttachPin(LED_PIN, ledChannel); 
 +    ledcWrite(ledChannel, dutyCycle); 
 +  } 
 +   
 +  //------------------------------------------------------- 
 +  void loop(){ 
 +    analog_value = analogRead(ANALOG_PIN_0); 
 +    Serial.println(analog_value); 
 +     
 +    dutyCycle = map(analog_value, 0, 4095, 0, 255); 
 +    ledcWrite(ledChannel, dutyCycle); 
 +    delay(500); 
 +  }
  
-## Control de Motor Servo+=== Control de Motor Servo ===
  
 Controlemos un Motor Servo usando la capacidad PWM de nuestro ESP32. Controlemos un Motor Servo usando la capacidad PWM de nuestro ESP32.
Línea 420: Línea 412:
 En primer lugar, es importante recordar que la frecuencia para trabajar con un Micro Servo es de 50Hz, por lo que debemos cambiar el parámetro de frecuencia a 50 (en lugar de 5000 con LED). También debemos especificar el canal LED PWM y la resolución del ciclo de trabajo PWM, en bits. Usaremos nuevamente el canal 0 y una resolución de 8 bits. En primer lugar, es importante recordar que la frecuencia para trabajar con un Micro Servo es de 50Hz, por lo que debemos cambiar el parámetro de frecuencia a 50 (en lugar de 5000 con LED). También debemos especificar el canal LED PWM y la resolución del ciclo de trabajo PWM, en bits. Usaremos nuevamente el canal 0 y una resolución de 8 bits.
  
-``` + 
-int freq = 50; + 
-int channel = 0; +  int freq = 50; 
-int resolution = 8; +  int channel = 0; 
-```+  int resolution = 8; 
  
 La salida hacia el Motor Servo, se conectará a la salida GPIO5. La salida hacia el Motor Servo, se conectará a la salida GPIO5.
  
-``` + 
-#define SERVO_PIN 5 +  #define SERVO_PIN 5 
-```+
  
 Al igual que con el LED, esos parámetros se deben definir durante la fase de *setup()*, utilizando las siguientes funciones: Al igual que con el LED, esos parámetros se deben definir durante la fase de *setup()*, utilizando las siguientes funciones:
  
-``` + 
-void setup(){+  void setup(){
  ledcSetup( channel, freq, resolution );  ledcSetup( channel, freq, resolution );
  ledcAttachPin( SERVO_PIN, channel );  ledcAttachPin( SERVO_PIN, channel );
-} +  } 
-```+
  
 Para colocar el servo en un ángulo específico, debemos definir el "ciclo de trabajo" (por favor, vea el diagrama de arriba). Para colocar el servo en un ángulo específico, debemos definir el "ciclo de trabajo" (por favor, vea el diagrama de arriba).
Línea 445: Línea 438:
 Por ejemplo, para colocar el servo alrededor de 90 grados, el ciclo de trabajo debe estar alrededor de 21 y la función *ledcWrite(ledChannel, dutyCycle)* se debe usar para enviar el valor a través del canal PWM: Por ejemplo, para colocar el servo alrededor de 90 grados, el ciclo de trabajo debe estar alrededor de 21 y la función *ledcWrite(ledChannel, dutyCycle)* se debe usar para enviar el valor a través del canal PWM:
  
-``` 
-int dutyCycle = 21; 
  
-ledcWrite( channel, dutyCycle ); + 
-```+  int dutyCycle = 21; 
 +   
 +  ledcWrite( channel, dutyCycle ); 
  
 Diferentes valores de la variable *dutyCycle* posicionarán el servo con diferentes ángulos. Esta variable, *dutyCycle*, debe variar de 10 a 32 (este rango se obtuvo manualmente). Diferentes valores de la variable *dutyCycle* posicionarán el servo con diferentes ángulos. Esta variable, *dutyCycle*, debe variar de 10 a 32 (este rango se obtuvo manualmente).
Línea 455: Línea 449:
 Al igual que con el LED, el potenciómetro (conectado a la variable de valor analógico) se puede utilizar para configurar manualmente la variable dutyCycle y así cambiar la posición del servo. Una vez que sus rangos de valores son diferentes, utilicemos una función de mapa para que coincida con la entrada y la salida: Al igual que con el LED, el potenciómetro (conectado a la variable de valor analógico) se puede utilizar para configurar manualmente la variable dutyCycle y así cambiar la posición del servo. Una vez que sus rangos de valores son diferentes, utilicemos una función de mapa para que coincida con la entrada y la salida:
  
-``` 
-dutyCycle = map( analog_value, 0, 4095, 10, 33); 
-``` 
  
-Ahora veremos el código completo:+  dutyCycle = map( analog_value, 0, 4095, 10, 33);
  
-``` 
-/*****************************************************  
-* ESP32 Servo Control  
-* Analog Input: ADC_1_0 pin ==> GPIO36 (VP). 
-* PWM SERVO pin   ==> GPIO 05 
-*  
-* MJRoBot.org 6Sept17 
-*****************************************************/ 
  
-//Analog Input +Ahora veremos el código completo:
-#define ANALOG_PIN_0 36+
  
-int analog_value = 0; 
  
-// PMW SERVO 
-#define SERVO_PIN 5 
  
-int freq = 50; +  /*****************************************************  
-int channel = 0; +  * ESP32 Servo Control  
-int resolution = 8; +  * Analog Input: ADC_1_0 pin ==> GPIO36 (VP). 
-int dutyCycle = 21; +  * PWM SERVO pin   ==> GPIO 05 
- +  *  
-//---------------------------------------------------- +  * MJRoBot.org 6Sept17 
-void setup(){ +  *****************************************************/ 
-  Serial.begin(115200);+   
 +  //Analog Input 
 +  #define ANALOG_PIN_0 36 
 +   
 +  int analog_value = 0; 
 +   
 +  // PMW SERVO 
 +  #define SERVO_PIN 5 
 +   
 +  int freq = 50; 
 +  int channel = 0; 
 +  int resolution = 8; 
 +  int dutyCycle = 21; 
 +   
 +  //---------------------------------------------------- 
 +  void setup(){ 
 +    Serial.begin(115200);
   while(!Serial){;}   while(!Serial){;}
      
-  Serial.println("\n\nESP32 Servo Control");+    Serial.println("\n\nESP32 Servo Control");
      
-  ledcSetup(channel, freq, resolution); +    ledcSetup(channel, freq, resolution); 
-  ledcAttachPin(SERVO_PIN, channel); +    ledcAttachPin(SERVO_PIN, channel); 
-  ledcWrite(channel, dutyCycle); +    ledcWrite(channel, dutyCycle); 
-} +  }
- +
-//---------------------------------------------------- +
-void loop(){ +
-  analog_value = analogRead(ANALOG_PIN_0);+
      
-  Serial.print(analog_value); +  //---------------------------------------------------- 
-  Serial.print(" Duty Cycle ==> "); +  void loop(){ 
-  Serial.println(dutyCycle);+    analog_value = analogRead(ANALOG_PIN_0);
      
-  dutyCycle = map(analog_value, 0, 4095, 10, 33); +    Serial.print(analog_value); 
-  ledcWrite(channel, dutyCycle); +    Serial.print(" Duty Cycle ==> "); 
-  delay(50); +    Serial.println(dutyCycle); 
-} +     
-```+    dutyCycle = map(analog_value, 0, 4095, 10, 33); 
 +    ledcWrite(channel, dutyCycle); 
 +    delay(50); 
 +  } 
  
 Ahora podemos trabajar con el sensor ultrasónico en la parte superior del servo y construir un *Radar IoT!*. ¡Pero este será otro tutorial! Ahora podemos trabajar con el sensor ultrasónico en la parte superior del servo y construir un *Radar IoT!*. ¡Pero este será otro tutorial!
  
-![ESP32 Servo](https://media.giphy.com/media/8CbYnjPzMlMgE/giphy.gif) +=== Conectando a Internet para tener la hora local ===
- +
-## Conectando a Internet para tener la hora local+
  
 Después de probar algunas de las capacidades *digitales/analógicas* y de *entrada/salida* de GPIO, ¡conectemos nuestro ESP32 en Internet! Después de probar algunas de las capacidades *digitales/analógicas* y de *entrada/salida* de GPIO, ¡conectemos nuestro ESP32 en Internet!
Línea 519: Línea 512:
 Con la familia ESP8266 estábamos usando la biblioteca *esp8266wifi.h* para eso. Con el ESP32, la biblioteca que se debe usar es:  Con la familia ESP8266 estábamos usando la biblioteca *esp8266wifi.h* para eso. Con el ESP32, la biblioteca que se debe usar es: 
  
-``` 
-<wifi.h> 
-``` 
  
-Un ejemplo muy simple sería programar nuestra placa para capturar desde Internet la hora local. Esta es una muy buena característica para tener a mano en proyectos. El siguiente código lo hará por nosotros:+  <wifi.h>
  
-``` 
-/************************************************************** 
- * Local Time Stamp with ESP32 
- * Developed by Marcelo Rovai - 8 September 2017 
- **************************************************************/ 
-#include <NTPClient.h> 
-#include <WiFi.h> 
-#include <WiFiUdp.h> 
  
-#define NTP_OFFSET  -3  * 60 * 60 // In seconds +Un ejemplo muy simple sería programar nuestra placa para capturar desde Internet la hora local. Esta es una muy buena característica para tener a mano en proyectos. El siguiente código lo hará por nosotros:
-#define NTP_INTERVAL 60 * 1000    // In miliseconds +
-#define NTP_ADDRESS  "europe.pool.ntp.org"+
  
-WiFiUDP ntpUDP; 
  
-NTPClient timeClient(ntpUDP, NTP_ADDRESS, NTP_OFFSET, NTP_INTERVAL);+  /************************************************************** 
 +   * Local Time Stamp with ESP32 
 +   * Developed by Marcelo Rovai - 8 September 2017 
 +   **************************************************************/ 
 +  #include <NTPClient.h> 
 +  #include <WiFi.h> 
 +  #include <WiFiUdp.h> 
 +   
 +  #define NTP_OFFSET  -3  * 60 * 60 // In seconds 
 +  #define NTP_INTERVAL 60 * 1000    // In miliseconds 
 +  #define NTP_ADDRESS  "europe.pool.ntp.org" 
 +   
 +  WiFiUDP ntpUDP; 
 +   
 +  NTPClient timeClient(ntpUDP, NTP_ADDRESS, NTP_OFFSET, NTP_INTERVAL); 
 +   
 +  void setup(){ 
 +    Serial.begin(115200); 
 +    timeClient.begin(); 
 +  }
  
-void setup(){ 
-  Serial.begin(115200); 
-  timeClient.begin(); 
-} 
-``` 
  
-## Simple Servidor WiFi+=== Simple Servidor WiFi ===
  
 Probemos ahora nuestro ESP32 como un servidor WiFi simple. Probemos ahora nuestro ESP32 como un servidor WiFi simple.
Línea 560: Línea 553:
   * Creado para el Arduino el 25/11/2012 por Tom Igeo.   * Creado para el Arduino el 25/11/2012 por Tom Igeo.
   * Portada para Sparkfun ESP32 31.01.2017 por Joan Hendrik Berlin.   * Portada para Sparkfun ESP32 31.01.2017 por Joan Hendrik Berlin.
 +
  
 Un servidor web simple que le permite parpadear un LED a través de la web. Este programa imprimirá la dirección IP de su red WiFi ESP32 en el monitor serie. Desde allí, puede abrir esa dirección en un navegador web para encender y apagar el LED en el pin 5.  Un servidor web simple que le permite parpadear un LED a través de la web. Este programa imprimirá la dirección IP de su red WiFi ESP32 en el monitor serie. Desde allí, puede abrir esa dirección en un navegador web para encender y apagar el LED en el pin 5. 
Línea 567: Línea 561:
   * http://10.0.1.40/H, enciende el led.   * http://10.0.1.40/H, enciende el led.
   * http://10.0.1.40/L, apaga el led.   * http://10.0.1.40/L, apaga el led.
 +
  
 Este ejemplo está escrito para una red que utiliza el cifrado WPA. Para WEP o WPA, cambie la llamada adecuadamente de *Wifi.begin()*. Este ejemplo está escrito para una red que utiliza el cifrado WPA. Para WEP o WPA, cambie la llamada adecuadamente de *Wifi.begin()*.
  
-Circuito: LED conectado al pin 5+  Circuito: LED conectado al pin 5
  
 Entonces, usemos el programa sin modificaciones significativas. Cambiar el pin del LED externo a GPIO5. Entonces, usemos el programa sin modificaciones significativas. Cambiar el pin del LED externo a GPIO5.
Línea 578: Línea 573:
 Primero ingrese sus credenciales de la red WiFi: Primero ingrese sus credenciales de la red WiFi:
  
-``` + 
-const char * ssid = "SSID"; +  const char * ssid = "SSID"; 
-const char * password = "su-password"; +  const char * password = "su-password"; 
-```+
  
 Y cargue el programa en su ESP32. Y cargue el programa en su ESP32.
  
  

Índice

Este es un índice de todas las páginas disponibles ordenado por espacios de nombres.

 
 
Recent changes RSS feed Creative Commons License Donate Minima Template by Wikidesign Driven by DokuWiki