ESP32-Cam incluye un ejemplo bastante completo de servidor web embebido dentro de la placa. Por si solo puede resultar útil y estaría bien poder modificar la página, personalizarla, quitar opciones o añadir librerias js externas para ampliar su funcionalidad o traducirla. Con solo cambiar la web que incluye el ejemplo tenemos una camada WiFi con un servidor web embebido que nos permite acceder a la misma y sus funcionalidades en remoto. Es una opción muy interesante pero no hay demasiada documentación sobre como hacerlo.

La web se encuentra «escondida» en el código fuente del ejemplo «CameraWebServer» dentro del fichero camera_index.h. La web esta comprimida, para incluirla en el código fuente se ha incluido en forma de un array de bytes (uint8_t) cuyos valores están en hexadecimal.

En le fichero camera_index.h hay dos variables que almacenan la web:

const uint8_t index_ov2640_html_gz[]

const uint8_t index_ov3660_html_gz[]

Que web se usa depende del sensor de la cámara, lo más fácil es probar a reemplazar uno a ver cual devuelve tu placa.

Decodificar la web:

Hay dos maneras de hacerlo, la sencilla y la complicada. La sencilla es tan simple como entrar en la web y click en el botón derecho y «Guardar como…». Tambien se puede usar herramientas como wget o curl.

La complicada requiere ir al código fuente, seleccionar el código hexadecimal del que se compone el array y con él:

• Eliminar todos los espacios, comas y saltos de linea
• Convertir cada bloque de texto «0x**» en un número hezadecimal
• Descomprimir el resultado que esta comprimido unsado gzip

Para facilitar las cosas he usado CybeChef para crear una receta de para decodificar la web la teneis aquí: decodificador . Solo hay que copiar el código hexadecimal que hay en el array y pegarlo en la parte de «input» automáticamente se obtendrá el código dela web en el «output».

Podemos usar esta web como base para nuestros cambios.

Codificar la web:

Una vez programada la web de reemplazo hay que hacer los pasos contrarios:

• Comprimir la web usando el formato gzip
• Convertimos cada carácter a bytes en hexadecimal en formato «0X**»
• Cada carácter hexadecimal tiene que estar separado por una coma, si ademas añadimos un espacio y cada cierto numero de bloques un salto de linea quedara visualmente más atractivo.

También he programado un codificador para facilitar la tarea.

Hay veces que necesitamos reiniciar la placa Arduino desde el propio software. Por ejemplo cuando se produce un error que no podemos gestionar. Sin embargo Arduino no trae ninguna función «reset» para hacerlos. Si recordamos lo que dijimos del watchdog precisamente esa es su función, reiniciar la placa. Podemos aprovechar eso para hacer una función de reset, configuramos el watchdog con el tiempo más corto posible y entramos en un bucle infinito, obligándolo a que pasado el tiempo reinicie la placa. Basta con llamar a la función reset() y la placa se reiniciara sola.

#include <avr/wdt.h> //libreria del watchdog

void reset(){
  wdt_enable(WDTO_15MS);
  while(1){};
}

Puede ser que hayamos sobrescrito el ISR del watchdog o que no queramos incluir la librería del watchdog solo para hacer un reset. La solución es sencilla, imitar lo que hace el watchdog, llamar a la función en la posición 0 de la tabla de vectores de interrupción. Da igual si no sabes lo que es la traducción es que salta la ejecución del código a la posición 0 de memoria. Podemos usar un puntero a función que apunte a esa dirección.

void(* reset) (void) = 0;

Y luego llamar a esa función.

reset();

Es recomendable usar el primer método siempre que se pueda ya que reiniciar la placa es la función del watchdog y seguro que funciona en todas las placas Arduino, la segunda solución depende más del microcontrolador de la placa y aunque deberia de funcionar las placas con microntroladores AVR no es seguro que funcione con otros microcontroladores.

Este texto mejorado y ampliado forma parte de mi libro sobre como mejorar tus programas en Arduino. Puedes echarle un vistazo aquí.

Puedes ver la versión en vídeo en mi canal:

Cuando se empieza con Arduino y se hace algún proyecto con servoa se llega el desesperante momento en que se reinicia la placa Arduino y los servos comienzan a dar bandazos hasta que llegan a la posición inicial que les marca el programa. ¿Como resolver esto?

Lo primero que hay que saber es que la mayoría de los ejemplos para aprender a usar la librería servo son incorrectos. No inicializan los servos y por se vuelvan locos. Veamoslo con un ejemplo sacado de la web de Arduino.

/* Sweep
 by BARRAGAN <http://barraganstudio.com>
 This example code is in the public domain.

 modified 8 Nov 2013
 by Scott Fitzgerald
 http://www.arduino.cc/en/Tutorial/Sweep
*/

#include <Servo.h>

Servo myservo; 

int pos = 0;

void setup() {
  myservo.attach(9);  
}

void loop() {
  for (pos = 0; pos <= 180; pos += 1) { 
    myservo.write(pos);
    delay(15);         
  }
  for (pos = 180; pos >= 0; pos -= 1) {
    myservo.write(pos);
    delay(15);  
  }
}

Lo primero es que el servo se vuelve «loco» porque toma los valores por defecto de la librería servo. Se pueden encontrar en el archivo Servo.h

#define MIN_PULSE_WIDTH       544     // the shortest pulse sent to a servo  
#define MAX_PULSE_WIDTH      2400     // the longest pulse sent to a servo 
#define DEFAULT_PULSE_WIDTH  1500     // default pulse width when servo is attached

Veamos lo que significan. Los servos ajustan su posición en base a la duración de un pulso que se les envía. En este caso se ajusta el pulso para que tenga una duración mínima de 544 microsegundos y una duración máxima de 2400 microsegundos. Si estáis acostumbrados a posicionar los servos usando grados de 0 a 180 el valor de 0 grados corresponde con un pulso de duración 544 y 180 con uno de 2400. Para los valores intermedios se interpola el valor, de tal forma que para G grados el pulso tiene que durar P microsegundos:

(G * (MAX_PULSE_WIDTH – MIN_PULSE_WIDTH) / 180 ) + MIN_PULSE_WIDTH = P

Sacando cuentas podemos ver que DEFAULT_PULSE_WIDTH corresponde más o menos con 90 grados.

Lo que ocurre es lo siguiente:

1. Al ejecutar myservo.attach(9) el servo se mueve hasta los 90 grados
2. Al ejecutar myservo.write(pos) el servo se mueve a la posición indicada, en este caso 0 grados.

No es que el servo se vuelva «loco» es que le decimos que de esos bandazos.

La solución es cambiar el setup para que antes de ejecutar myservo.attach(9) le ponga el valor con el que queremos inicializar el servo.

void setup() {
  myservo.write(pos); //inicializamos la posicion del servo
  myservo.attach(9);  
}

Conservar el valor anterior del servo

Hay casos en que no tenemos un valor por defecto para un servo, tiene que conservar el valor con el que se quedo antes del reinicio. Como no podemos leer el valor del servo (read/readMicroseconds no leen el valor del servo devuelve el último valor pasado a write/writeMicroseconds). ¿Qué podemos hacer? Usar la EEPROM para almacenar los valores de los servos. Podemos almacenar el valor del servo con EEPROM.put() y recuperarlos con EEPROM.get(). Sin embargo esto tiene un problema, la memoria EEPROM del Arduino tiene una vida de unas 100.000 escrituras, que pueden ser poco para algunos casos. Hay algunas posibles soluciones:

• Crear una posición de apagado de tal manera que antes de apagarse los servos vuelvan a esa posición. No sirve para fallos/reinicios repentinos.
• Guardar la posición de los servos cada cierto tiempo. En casos donde los servos cambian rápidamente de posición no sirve.
• Ir cambiando la dirección de memoria EEPROM donde se almacena el estado de los servos. Si cada byte de EEPROM se puede escribir 100000 veces, si rotamos la dirección de byte a lo largo de toda la memoria alargamos esa vida.
• Guardar solo la posición si cambia lo suficiente. Se compara el valor almacenado con el valor del servo si la diferencia es pequeña no se cambia.

Veamos un ejemplo del ultimo caso.

Mover un servo.

void moveServo(Servo servo, byte angle, int addressEEPROM) {
    byte savedAngle = EEPROM.read(addressEEPROM, angle);//recuperamos el valor 
    if(abs(angle - savedAngle) > 10){//si más de 10 grados de diferencia se guarda
        EEPROM.update(addressEEPROM, angle);
    }
    servo.write(angle);
}

Se incian los servos con el valor recuparado de memoria.

void initServo(Servo servo, int addressEEPROM, uint8_t pin) {
    int savedAngle;
    EEPROM.get(addressEEPROM, saveAngle);//recuperamos el valor guardado
    servo.write(savedAngle);
    servo.attach(pin);
}

Una de las cosas que echaba de menos al programar un Arduino era la posibilidad de ver un desemsamblado del código generado. Hay veces que puede ayudarte a entender por qué falla algo o saciar tu curiosidad de cómo funciona. Aunque el IDE de Arduino no trae una opción cómoda para hacerlo es muy sencillo.

Hay que realizar el proceso en dos pasos:

Obtener el volcado binario del sketch de Arduino

Primero vamos a obtener un volcado binario del sketch. Para ello recurrimos a la opción «Exportar Binarios compilados» del menú «Programa».

Una vez exportados podemos acceder a ellos con la opción «Mostrar Carpeta de Programa» del menú «Programa».

Como resultado de la exportación obtenemos dos archivos .hex.

Se corresponden al binario con el bootloader de Arduino o sin el bootloader. Podemos abrirlo con un editor hexadecimal y ver que contiene.

El fichero con el bootloader es el que se copia a la placa Arduino cuando «cargamos» el sketch

Convertir el volcado binario a ensamblador

Para realizar esta parte necesitaremos el programa avr-objdump el cual se puede encontrar en el directorio donde este instalado el IDE de Arduino en la ruta hardware\tools\avr\bin\avr-objdump. Una vez localizado podemos usar el siguiente comando para obtener el desensamblado del binario:

<ruta-avr-objdump>avr-objdump -j .sec1 -d -m avr5 fichero.hex > fichero.asm

Tras ejecutar ese comando la salida se vuelca en el fichero de nombre ejemplo.asm que podemos abrir con cualquier editor de textos.

Como curiosidad las primeras lineas del fichero corresponde a la tabla de vectores de interrupción del microcontrolador, por eso son todo saltos al código que gestiona cada una de las interrupciones.

Este texto mejorado y ampliado forma parte de mi libro sobre como mejorar tus programas en Arduino. Puedes echarle un vistazo aquí.

Puedes ver todo este proceso en vídeo en mi canal de youtube:

Un watchdog es un sistema de seguridad que usan muchos microcontroladores y sistemas embebidos. Su funcionamiento es simple, cada vez que se reinicia el watchdog empieza una cuenta atrás hasta cero, si antes de llegar a cero el watchdog se reinicia la cuenta atrás vuelve a empezar. Si no se reinicia y el contador alcanza el valor 0 el sistema se reinicia automáticamente. Así se evita que se quede colgado.

Con el reinicio se pierden los datos que están en la memoria SRAM por lo que todo dato que queramos conservar ha de guardarse en la EEPROM.

Para usar el watchdog hemos de incluir la librería del fabricante del microcontrolador:

#include <avr/wdt.h>

Para deshabilitar el watchdog se puede usar la función:

wdt_disable();

Empezamos aprendiendo a deshabilitarlo porque es lo primero que hay que hacer para evitar problemas durante el inicio de la placa o puede interferir en el proceso de grabación de un nuevo código en la placa. Cuando se vuelca un nuevo código hay que dar tiempo para que se pueda volcar un nuevo programa o se perderá la posibilidad de grabar nuevos programas. La causa de esto es que cuando se empieza a subir un nuevo código desde el IDE se paraliza la ejecución del programa, por lo que no se reinicia el contador del watchdog si este llega a cero antes de que se termine de subir el código la placa se reinicia y la grabación se corta.

Para activar el watchdog y fijar cuanto tiempo tiene que esperar el watchdog antes de reiniciar la placa se usa la función:

wdt_enable(WDTO_1S);

El parámetro que recibe la función indica el tiempo que esperará el watchdog antes de reiniciar el dispositivo. No puede tomar cualquier valor, tiene que ser una de los siguientes valores predefinidos:

• WDTO_15MS
• WDTO_30MS
• WDTO_60MS
• WDTO_120MS
• WDTO_250MS
• WDTO_500MS
• WDTO_1S
• WDTO_2S
• WDTO_4S
• WDTO_8S

Para evitar que se reinicie la placa hemos de llamar a la siguiente función ante de que pase el tiempo indicado:

wdt_reset();

Tras llamarla la cuenta atrás comienza otra vez.

Un ejemplo de esqueleto de función seria la siguiente:

#include <avr/wdt.h>

setup(){
  wdt_disable();
  //el resto del setup
  delay(3000); //para evitar que no nos da problemas al cargar nuevos programas
  wdt_enable(WDTO_4S); //se activa el watchdog 
}

loop(){
 wdt_reset(); //reiniciar contador del watchdog
 //código del programa
}

Este texto mejorado y ampliado forma parte de mi libro sobre como mejorar tus programas en Arduino. Puedes echarle un vistazo aquí.

También puedes verla versión en vídeo en mi canal de youtube:

El error cuadrático y el R cuadrado se usan como medidas para evaluar el desempeño de un estimador. Es decir cual es el error que comete al estimar un valor. Un ejemplo de estimador seria, por ejemplo, una regresión, ahora si no interesa saber lo bien que estima esa función podemos hacerlo a partir de direrente estimadores.

Para calcularlos se usan dos valores, el valor real y el valor devuelto por nuestro estimador (representado por la Y con «sombrerito»). El error para cada caso es el valor absoluto de la resta de ambos valores:

Se puede entender intuitivamente de forma muy simple, es la diferencia entre el valor que obtenido del estimador y el valor real. Se usa el valor absoluto para que cuando se sumen varios errores no se «cancelen». Si al estimar un valor se equivoca en 3 y al estimar otro en -3 el error total es 6 no 0.

Su calculo en Arduino seria:

double error = abs(y - ey);

Error medio absoluto

No podemos valorar un estimador solo por el error en una estimación, habrá que usar varias y calcular la media del error a lo que se le llama «error medio absoluto«, la suma del error de cada medida partido por el número de muestras:

Para implementarlo en Arduino vamos a usar el mismo «truco» que usamos para calcular diferentes estadisticos en Arduino. Usando la versión acumulada del calculo de la media para no tener que guardar todos los valores:

meanError = meanError + ((error - meanError)/n);

Error cuadrático medio

Otro valor usado es la media del error al cuadrado:

Para implmentarla en Arduino vamos a usar el mismo «truco» que antes para el error medio:

 meanError2 = meanError2 + (((error*error) - meanError2)/n);

El problema de elevar los valores al cuadrado es que cuantificar su diferencia resulta poco intuitivo. Para hacer el valor más entendible se puede usar la raiz cuadrada del error cuadrático medio:

En código para Arduino:

sqrt(meanError2);

Todo esto lo puedes ver implementado en los ficheros error.h y error.cpp de SimpleStatisticsArduino