sábado, 20 de octubre de 2018

ESP32 desde Cero - Tutorial 7: Mostrar los Datos de un Sensor en una Página Web

En este video explico cómo mostrar los datos del sensor interno de efecto Hall en una página web alojada en un servidor web dentro del mismo ESP32.


Código Fuente:

#include <WiFi.h>

//------------------Servidor Web en puerto 80---------------------

WiFiServer server(80);

//---------------------Credenciales de WiFi-----------------------

const char* ssid     = "---";
const char* password = "---";

//---------------------VARIABLES GLOBALES-------------------------
int contconexion = 0;

String header; // Variable para guardar el HTTP request

//------------------------CODIGO HTML------------------------------
String paginaInicio = "<!DOCTYPE html>"
"<html>"
"<head>"
"<meta charset='utf-8' />"
"<META HTTP-EQUIV='Refresh' CONTENT='1'>"
"<title>Servidor Web ESP32</title>"
"</head>"
"<body>"
"<center>"
"<h3>Servidor Web ESP32</h3>";

String paginaFin = "</center>"
"</body>"
"</html>";


//---------------------------SETUP--------------------------------
void setup() {
  Serial.begin(115200);
  Serial.println("");
  
  // Conexión WIFI
  WiFi.begin(ssid, password);
  //Cuenta hasta 50 si no se puede conectar lo cancela
  while (WiFi.status() != WL_CONNECTED and contconexion <50) { 
    ++contconexion;
    delay(500);
    Serial.print(".");
  }
  if (contconexion <50) {
      //para usar con ip fija
      //IPAddress ip(192,168,1,180); 
      //IPAddress gateway(192,168,1,1); 
      //IPAddress subnet(255,255,255,0); 
      //WiFi.config(ip, gateway, subnet); 
      
      Serial.println("");
      Serial.println("WiFi conectado");
      Serial.println(WiFi.localIP());
      server.begin(); // iniciamos el servidor
  }
  else { 
      Serial.println("");
      Serial.println("Error de conexion");
  }
}

//----------------------------LOOP----------------------------------

void loop(){
  WiFiClient client = server.available();   // Escucha a los clientes entrantes

  if (client) {                             // Si se conecta un nuevo cliente
    Serial.println("New Client.");          // 
    String currentLine = "";                //
    while (client.connected()) {            // loop mientras el cliente está conectado
      if (client.available()) {             // si hay bytes para leer desde el cliente
        char c = client.read();             // lee un byte
        Serial.write(c);                    // imprime ese byte en el monitor serial
        header += c;
        if (c == '\n') {                    // si el byte es un caracter de salto de linea
          // si la nueva linea está en blanco significa que es el fin del 
          // HTTP request del cliente, entonces respondemos:
          if (currentLine.length() == 0) {
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");
            client.println("Connection: close");
            client.println();
                     
            // Muestra la página web
            client.println(paginaInicio + String(hallRead()) + paginaFin);
            
            // la respuesta HTTP temina con una linea en blanco
            client.println();
            break;
          } else { // si tenemos una nueva linea limpiamos currentLine
            currentLine = "";
          }
        } else if (c != '\r') {  // si C es distinto al caracter de retorno de carro
          currentLine += c;      // lo agrega al final de currentLine
        }
      }
    }
    // Limpiamos la variable header
    header = "";
    // Cerramos la conexión
    client.stop();
    Serial.println("Client disconnected.");
    Serial.println("");
  }
}

domingo, 30 de septiembre de 2018

ESP32 desde Cero - Tutorial 6: Servidor Web (WebServer)

En este tutorial explico cómo hacer un servidor web (WebServer) usando la IDE de Arduino en un ESP32.


Código Fuente:

#include <WiFi.h>

//------------------Servidor Web en puerto 80---------------------

WiFiServer server(80);

//---------------------Credenciales de WiFi-----------------------

const char* ssid     = "-----";
const char* password = "-----";

//---------------------VARIABLES GLOBALES-------------------------
int contconexion = 0;

String header; // Variable para guardar el HTTP request

String estadoSalida = "off";

const int salida = 2;

//------------------------CODIGO HTML------------------------------
String pagina = "<!DOCTYPE html>"
"<html>"
"<head>"
"<meta charset='utf-8' />"
"<title>Servidor Web ESP32</title>"
"</head>"
"<body>"
"<center>"
"<h1>Servidor Web ESP32</h1>"
"<p><a href='/on'><button style='height:50px;width:100px'>ON</button></a></p>"
"<p><a href='/off'><button style='height:50px;width:100px'>OFF</button></a></p>"
"</center>"
"</body>"
"</html>";


//---------------------------SETUP--------------------------------
void setup() {
  Serial.begin(115200);
  Serial.println("");
  
  pinMode(salida, OUTPUT); 
  digitalWrite(salida, LOW);

  // Conexión WIFI
  WiFi.begin(ssid, password);
  //Cuenta hasta 50 si no se puede conectar lo cancela
  while (WiFi.status() != WL_CONNECTED and contconexion <50) { 
    ++contconexion;
    delay(500);
    Serial.print(".");
  }
  if (contconexion <50) {
      //para usar con ip fija
      //IPAddress ip(192,168,1,180); 
      //IPAddress gateway(192,168,1,1); 
      //IPAddress subnet(255,255,255,0); 
      //WiFi.config(ip, gateway, subnet); 
      
      Serial.println("");
      Serial.println("WiFi conectado");
      Serial.println(WiFi.localIP());
      server.begin(); // iniciamos el servidor
  }
  else { 
      Serial.println("");
      Serial.println("Error de conexion");
  }
}

//----------------------------LOOP----------------------------------

void loop(){
  WiFiClient client = server.available();   // Escucha a los clientes entrantes

  if (client) {                             // Si se conecta un nuevo cliente
    Serial.println("New Client.");          // 
    String currentLine = "";                //
    while (client.connected()) {            // loop mientras el cliente está conectado
      if (client.available()) {             // si hay bytes para leer desde el cliente
        char c = client.read();             // lee un byte
        Serial.write(c);                    // imprime ese byte en el monitor serial
        header += c;
        if (c == '\n') {                    // si el byte es un caracter de salto de linea
          // si la nueva linea está en blanco significa que es el fin del 
          // HTTP request del cliente, entonces respondemos:
          if (currentLine.length() == 0) {
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");
            client.println("Connection: close");
            client.println();
            
            // enciende y apaga el GPIO
            if (header.indexOf("GET /on") >= 0) {
              Serial.println("GPIO on");
              estadoSalida = "on";
              digitalWrite(salida, HIGH);
            } else if (header.indexOf("GET /off") >= 0) {
              Serial.println("GPIO off");
              estadoSalida = "off";
              digitalWrite(salida, LOW);
            }
            
            // Muestra la página web
            client.println(pagina);
            
            // la respuesta HTTP temina con una linea en blanco
            client.println();
            break;
          } else { // si tenemos una nueva linea limpiamos currentLine
            currentLine = "";
          }
        } else if (c != '\r') {  // si C es distinto al caracter de retorno de carro
          currentLine += c;      // lo agrega al final de currentLine
        }
      }
    }
    // Limpiamos la variable header
    header = "";
    // Cerramos la conexión
    client.stop();
    Serial.println("Client disconnected.");
    Serial.println("");
  }
}

sábado, 23 de junio de 2018

ESP32 desde Cero - Tutorial 5: Sensor de Efecto Hall Interno


Este es un video-tutorial donde explico cómo utilizar el Sensor de Efecto Hall (sensor magnético) que trae internamente el ESP32, desde la IDE de Arduino.  


Código Fuente:

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

void loop() {
  Serial.println("-250," + String(hallRead()) + ",250");
  delay(25);
}

domingo, 17 de junio de 2018

ESP32 desde Cero - Tutorial 4: ADC Conversor Analógico a Digital


En este video-tutorial, explico cómo utilizar los ADCs (conversor analógico a digital) de 12 bits del ESP32, en cualquiera de los 18 pines disponibles, desde la IDE de Arduino.  


Código Fuente:

void setup() {
  Serial.begin(115200);

  /*
  * Get ADC value for pin
  * */
  //analogRead(36);
  
  /*
  * Set the resolution of analogRead return values. Default is 12 bits (range from 0 to 4096).
  * If between 9 and 12, it will equal the set hardware resolution, else value will be shifted.
  * Range is 1 - 16
  *
  * Note: compatibility with Arduino SAM
  */
  //analogReadResolution(12);

  /*
  * Sets the sample bits and read resolution
  * Default is 12bit (0 - 4095)
  * Range is 9 - 12
  * */
  analogSetWidth(12);

  /*
  * Set number of cycles per sample
  * Default is 8 and seems to do well
  * Range is 1 - 255
  * */
  analogSetCycles(8);

  /*
  * Set number of samples in the range.
  * Default is 1
  * Range is 1 - 255
  * This setting splits the range into
  * "samples" pieces, which could look
  * like the sensitivity has been multiplied
  * that many times
  * */
  analogSetSamples(1);

  /*
  * Set the divider for the ADC clock.
  * Default is 1
  * Range is 1 - 255
  * */
  analogSetClockDiv(1);

  /*
  * Set the attenuation for all channels
  * Default is 11db
  * */
  analogSetAttenuation(ADC_11db); //ADC_0db, ADC_2_5db, ADC_6db, ADC_11db

  /*
  * Set the attenuation for particular pin
  * Default is 11db
  * */
  analogSetPinAttenuation(36, ADC_0db); //ADC_0db, ADC_2_5db, ADC_6db, ADC_11db

  /*
  * Get value for HALL sensor (without LNA)
  * connected to pins 36(SVP) and 39(SVN)
  * */
  //hallRead();

  /*
  * Non-Blocking API (almost)
  *
  * Note: ADC conversion can run only for single pin at a time.
  *       That means that if you want to run ADC on two pins on the same bus,
  *       you need to run them one after another. Probably the best use would be
  *       to start conversion on both buses in parallel.
  * */

  /*
  * Attach pin to ADC (will also clear any other analog mode that could be on)
  * */
  adcAttachPin(36);

  /*
  * Start ADC conversion on attached pin's bus
  * */
  adcStart(36);

  /*
  * Check if conversion on the pin's ADC bus is currently running
  * */
  //adcBusy(uint8_t pin);

  /*
  * Get the result of the conversion (will wait if it have not finished)
  * */
  //adcEnd(uint8_t pin);

  /**
  * When VDD_A is 3.3V:
  *
  * - 0dB attenuaton (ADC_ATTEN_DB_0) gives full-scale voltage 1.1V
  * - 2.5dB attenuation (ADC_ATTEN_DB_2_5) gives full-scale voltage 1.5V
  * - 6dB attenuation (ADC_ATTEN_DB_6) gives full-scale voltage 2.2V
  * - 11dB attenuation (ADC_ATTEN_DB_11) gives full-scale voltage 3.9V (see note below)
  *
  * @note The full-scale voltage is the voltage corresponding to a maximum reading (depending on ADC1 configured
  * bit width, this value is: 4095 for 12-bits, 2047 for 11-bits, 1023 for 10-bits, 511 for 9 bits.)
  *
  * @note At 11dB attenuation the maximum voltage is limited by VDD_A, not the full scale voltage.
  */  
}

void loop() {
  Serial.println(analogRead(36)); //VP
  delay(1000);
}

sábado, 2 de junio de 2018

Proyectos con ESP32 #1: Reproducir Audio Usando el DAC


Este es el primer video de una nueva sección en la que voy a subir proyectos usando los conocimientos que vamos adquiriendo en la serie “ESP32 desde Cero”. En este primer proyecto explico como reproducir el audio de un archivo WAV utilizando uno de los DAC. Todos esto lo logramos con sólo 6 líneas de código.


Código Fuente:

void setup() {
}
void loop() { 
  for (int i = 0; i < 22000; ++i){
    dacWrite(25, rawData[i]);
    delayMicroseconds(38); // ((1/22050)*1000000) - 7
  }
}


viernes, 25 de mayo de 2018

ESP32 desde Cero - Tutorial 3: DAC Conversor Digital a Analógico


En este video-tutorial, les voy a mostrar cómo se utilizar los 2 DAC de 8 bits que tiene disponible el ESP32, vamos a ver como tener un valor entre discreto entre 0 y 3,3V y como generar señales sinusoidales. Como si esto fuera poco, también muestro en el osciloscopio como hacer figuras de Lissajous, modificando dichas señales.



Código Fuente:

void setup() {
}

void loop() { 
  for (int deg = 0; deg < 360; deg = deg + 1){
    dacWrite(25, int(128 + 127 * (sin(deg*PI/180))));
    dacWrite(26, int(128 + 127 * (sin(deg*PI*4/180))));
  }
  //dacWrite(26, 80);
}

domingo, 20 de mayo de 2018

ESP32 desde Cero - Tutorial 2: PWM, Touch Sensor, Entradas y Salidas Digitales


En este tutorial sobre ESP32, les voy a mostrar cómo usar la IDE de Arduino, para utilizar PWM, los Touch Sensors (sensores de tacto) que vienen implementados por hardwar y el uso de entradas/salidas digitales.


Código Fuente:

#define LEDC_CHANNEL_0     0    // use first channel of 16 channels (started from zero)
#define LEDC_TIMER_8_BIT   8    // use 8 bit precission for LEDC timer
#define LEDC_BASE_FREQ     5000 // use 5000 Hz as a LEDC base frequency
#define LED_PIN            5    // // Led Verde

int brillo = 0;    
int sensorT0 = 0;    
int sensorT3 = 0;   

void setup() {
  Serial.begin(115200);
  
  ledcSetup(LEDC_CHANNEL_0, LEDC_BASE_FREQ, LEDC_TIMER_8_BIT); // Setup timer and attach timer to a led pin
  ledcAttachPin(LED_PIN, LEDC_CHANNEL_0);
  
  pinMode(23, INPUT_PULLUP); // Pulsador
  pinMode(18, OUTPUT);       // Led Rojo
}

void loop() {

  sensorT0 = touchRead(T0);
  sensorT3 = touchRead(T3);
  
  if (sensorT0 < 35 and sensorT0 != 0) {
    brillo = brillo + 5;
    if (brillo >= 255) {
      brillo = 255;
    }
  }
  if (sensorT3 < 35 and sensorT3 != 0) {
    brillo = brillo - 5;
    if (brillo <= 0) {
      brillo = 0;
    }
  }
  
  Serial.println("T3=" + String(sensorT3) + " T0=" + String(sensorT0) + " Brillo=" + String(brillo));

  ledcWrite(LEDC_CHANNEL_0, brillo);
  
  digitalWrite(18, digitalRead(23));
  
  delay(50);
}






lunes, 30 de abril de 2018

Computadora de 4 Bits - Capítulo 8 (final): Ejemplos de Programación


En este último capítulo de la serie les voy a mostrar algunos ejemplos de programación: Un contador de 00 a FF, el manejo de un LCD de 16x2, controlar la dirección de un motor paso a paso, el ingreso de datos por teclado numérico matricial y la reproducción de la melodía de “My Darling Clementine”.


sábado, 21 de abril de 2018

Computadora de 4 Bits - Capítulo 7: Microcódigo y Lenguaje Máquina


En este capítulo explico el microcódigo (un microcódigo o microprograma es el nombre de una serie de instrucciones o estructuras de datos implicados en la implementación de lenguaje máquina de nivel más alto en muchos procesadores) y el lenguaje máquina (el lenguaje de máquina o código máquina es el sistema de códigos directamente interpretable por un circuito microprogramable) de la computadora de 4 bits.


sábado, 14 de abril de 2018

viernes, 6 de abril de 2018

Computadora de 4 Bits - Capítulo 5: Unidad Aritmética Lógica (ALU)


En este capítulo explico el funcionamiento de la ALU, es decir la unidad aritmética lógica, como su nombre lo indica es la parte del procesador que se encarga de hacer las operaciones aritméticas (suma, resta, multiplicación, división, etc) y lógicas (AND, OR, NOT, etc).


http://hyperphysics.phy-astr.gsu.edu/hbase/Electronic/nand.html
https://en.wikipedia.org/wiki/Adder_(electronics)

miércoles, 4 de abril de 2018

ESP32 desde Cero - Tutorial 1: Instalación para la IDE de Arduino en Windows


En este primer tutorial sobre ESP32 explico como instalar todo lo necesario para poder programar nuestros ESP32 usando la IDE de Arduino bajo Windows.



sábado, 17 de marzo de 2018

Computadora de 4 Bits - Capítulo 2: Descripción de la Arquitectura


En el segundo capítulo de describo la arquitectura de mi computadora de 4 bits, es decir el diseño conceptual, sus elementos constitutivos y las interconexiones.



sábado, 10 de marzo de 2018

Computadora de 4 Bits – Capítulo 1: Presentación


El proyecto proyecto consiste en el diseño completo de una computadora de 4 bits basándome en integrados sencillos (compuertas lógicas, contadores, flip-flops, decodificadores, etc). Abarcando por completo hasta el último detalle, desde el contador de programas, la unidad de control, la ALU, los registros, puertos de entrada y salida, el juego de instrucciones, el microcódigo, etc.


Características:

·         Arquitectura Harvard (memoria de programas y memoria de datos por separado)
·         Memoria de programas (32 programas de hasta 256 bytes)
·         16 instrucciones regulares de 8 bits (13 implementadas) (RISC) (1 ciclo de reloj por instrucción)
o   4 bits superiores para el código de operación
o   4 bits inferiores para el operando


·         No tiene RAM
·         2 puertos de salida (4 bits cada uno)
·         1 puerto de entrada (4 bits)
·         1 registro de dirección (4 bits)
·         1 registro de uso general (4 bits)
·         ALU de dos operaciones, una aritmética (SUMA) y una lógica (NAND)