Este tutorial es un extracto del tutorial que cree para el foro de Arduino, si quieres ver el tutorial completo, ver los comentario y/o los añadidos al tutorial visita Como NO leer un botón y como SI debemos hacerlo.

Empecé a crear esta parte del tutorial dando una noción de objetos y clases de C++, pero al final llegué a la conclusión de que es tema para otro tutorial que no sé si llegaré a hacer.

Me limitaré a decir que una clase es una manera de encapsular código para cosas que van a realizar la misma función.

Para leer el botón un botón hemos visto que necesitamos unas variables y que vamos a usar esas variables para leer el estado del botón. Podemos poner otro botón y creamos más variables y realizamos la acción de leerla, otro botón y mas variables/acción de leer. Si ponemos más botones habrá que hacer lo mismo, con lo cual estamos agrandando el código, haciendo que sea ilegible y provocando fallos, ya que nos dedicaremos a hacer copy+paste y no cambiaremos el nombre de las variables bien.

Así que se encápsula en una clase y queda mas escueto y elegante.

/*
 * 6. Usando una clase para botones.
 */

#define APRETADO    0
#define SUELTO      1
#define APRETANDOLO 2
#define SOLTANDOLO  3

class BotonSimple {
  private:
    unsigned char pin;
    unsigned char anterior, valor;
    unsigned char estado;

    unsigned long temporizador;
    unsigned long tiempoRebote;
  public:
    BotonSimple(unsigned char _pin, unsigned long _tiempoRebote);
    void actualizar();
    int  leer();
};

BotonSimple::BotonSimple(unsigned char _pin, unsigned long _tiempoRebote=50) {
  pin = _pin;
  tiempoRebote = _tiempoRebote;
  pinMode(pin, INPUT_PULLUP);
  valor=HIGH; anterior=HIGH; estado=SUELTO;
}

void BotonSimple::actualizar() {
  // NOTA: En el ejemplo original en vez de "pin" leia directamente el pin "2", con lo que el
  // codigo no funciona correctamente con el pin que le hayamos asignado.
  if ( valor==digitalRead(pin) ){
    temporizador=0;
  }
  else
  if ( temporizador==0 ) {
    temporizador = millis();
  }
  else
  if ( millis()-temporizador >= tiempoRebote ) {
    valor = !valor;
  }
  if ( anterior==LOW  && valor==LOW  ) estado = APRETADO;
  if ( anterior==LOW  && valor==HIGH ) estado = SOLTANDOLO;
  if ( anterior==HIGH && valor==LOW  ) estado = APRETANDOLO;
  if ( anterior==HIGH && valor==HIGH ) estado = SUELTO;
  anterior = valor;
}

int BotonSimple::leer() {
  return estado;
}
 

BotonSimple boton(2);

void setup() {
  Serial.begin(9600);
  pinMode(13, OUTPUT);
}
  
void loop() {
  boton.actualizar();
  switch ( boton.leer() ) {
    case SUELTO: digitalWrite(13, LOW); break;
    case APRETANDOLO: Serial.println("Acabas de apretar el boton"); break;
    case APRETADO: digitalWrite(13, HIGH); break;
    case SOLTANDOLO: Serial.println("Acabas de soltar el boton"); break;
    default: break;
  }
}

Este código hace lo mismo que lo anterior, pero hemos usado una clase para encapsular el botón.

Nuestro objeto ahora tiene dos métodos: actualizar, que hace la lectura del botón y que deberemos hacer antes de poder leer su estado; y leer, que al llamarla nos vevolverá el estado del botón (suelto, apretado, apretandolo, soltandolo)

Ahora que lo tenemos encapsulado, si queremos más botones solo tenemos que hacer:

BotonSimple boton1(pin1, tiempoRebote1);
BotonSimple boton2(pin2, tiempoRebote2);
...
BotonSimple botonN(pinN, tiempoReboteN);

pinX será el pin al que asignaremos el botón. tiempoReboteX sera el tiempo de debounce, este parámetro es opcional y si no lo ponemos el tiempo será de 50ms.

Tendremos que comprobar el estado de cada boton en cada ciclo:

void loop() {
  boton1.actualizar();
  boton2.actualizar();
  ...
  botonN.actualizar();
}

Como véis no me he esmerado mucho en la explicación, dado que como dije es un tema más de C++ y programación orientada a objetos que de Arduino en si. Solo básta con saber que el código es el mismo que cuando leiamos el botón sin usar objetos, pero ahora es más cómodo trabajar con él.

Os dejo en attachment la libreria para instalar en Arduino, será útil cuando cree el post para ejemplos de millis y botones.

Aquí os dejo el enlace a la librería en Github: BotonSimple

Este tutorial es un extracto del tutorial que cree para el foro de Arduino, si quieres ver el tutorial completo, ver los comentario y/o los añadidos al tutorial visita Como NO leer un botón y como SI debemos hacerlo.

Ya hemos leido un botón y hemos eliminado el debounce por software, ahorrandonos un condensador. Pero vamos a complicar la cosa.

Un botón puede estar en cuatro estados:

• Suelto que es cuando no lo tocas y solo lo miras. En este estado tendrá un valor, en nuestro caso estará a HIGH tal y como lo enchufamos. Generalemente es el estado que menos nos interesa ya que no haremos nada en él.
• Apretándolo. Justo ese momento en el que el botón pasa de estar suelto a apretado, en nuestro ejemplo pasa del estado HIGH a LOW. Este si es útil, como hemos visto en el apartado anterior.
• Apretado. Aquí ya lo mantenemos pulsado y su valor será LOW. En este estado podemos hacer cosas, pero ya sabes, el loop es rápido y se ejecutará muchas veces cuando lo mantengas pulsado.
• Soltándolo. Justo ese momento en el botón pasa de estar apretado a estar suelto. En nuestro caso es cuando se pasa de LOW a HIGH. También es útil para hacer cosas, dependiendo de lo que queramos hacer. Cuando sale de este estado, se queda de nuevo en suelto

Así que sabiendo esto se lo podemos añadir a nuestro código para determinar en que estado está el botón:

/*
 * 5. Leyendo un boton con antirebote por software y determinando su estado.
 *
 *
 * NOTA: en el ejemplo "anterior" estado guardaba el valor de la variable, como
 * ahora vamos a tener un estado de verdad cambiamos ese nombre de variable a
 * valor para hora usar un estado como estado propiamente dicho.
 */

#define APRETADO    0
#define SUELTO      1
#define APRETANDOLO 2
#define SOLTANDOLO  3
 
const int boton = 2; // Botón asignado en el pin 2.
int   anterior;      // guardamos el estado anterior.
int   valor;         // valor actual del botón.
int   estado;
unsigned long temporizador;
unsigned long tiemporebote = 50;

void setup() {
  Serial.begin(9600);
  pinMode(boton,INPUT_PULLUP);
  pinMode(13,OUTPUT); // Vamos a usar el led de la placa como señalización.
  valor    = HIGH;
  anterior = HIGH;
}
  
void loop() {
  // Si el estado es igual a lo leido, la entrada no ha cambiado lo que
  // significa que no hemos apretado el botón (ni lo hemos soltado); asi que
  // tenemos que parar el temporizador.
  if ( valor==digitalRead(2) ) {
    temporizador = 0;
  }
  // Si el valor distinto significa que hemos pulsado/soltado el botón. Ahora
  // tendremos que comprobar el estado del temporizador, si vale 0, significa que
  // no hemos guardado el tiempo en el que sa ha producido el cambio, así que
  // hemos de guardarlo.
  else
  if ( temporizador == 0 ) {
    // El temporizador no está iniciado, así que hay que guardar
    // el valor de millis en él.
    temporizador = millis();
  }
  else
  // El temporizador está iniciado, hemos de comprobar si el
  // el tiempo que deseamos de rebote ha pasado.
  if ( millis()-temporizador > tiemporebote ) {
    // Si el tiempo ha pasado significa que el estado es lo contrario
    // de lo que había, asi pues, lo cambiamos.
    valor = !valor;
  }

  // Ahora comprobamos el estado. Recordad que si el boton vale "1" estará suelto,
  // "0" y el botón estará apretado. Si pasa de "1" a "0" es que lo estamos aprentando
  // y si es al contrario es que lo estamos soltando.
  if ( anterior==LOW  && valor==LOW  ) estado = APRETADO;
  if ( anterior==LOW  && valor==HIGH ) estado = SOLTANDOLO;
  if ( anterior==HIGH && valor==LOW  ) estado = APRETANDOLO;
  if ( anterior==HIGH && valor==HIGH ) estado = SUELTO;

  // Recuerda que hay que guardar el estado anterior.
  anterior = valor;

  // Ahora vamos a ver que podemos hacer con el estado.
  switch ( estado ) {
    case SUELTO:   digitalWrite(13,LOW);  break; // Apagamos el led.
    case APRETANDOLO: Serial.write("Has apretado el botón"); break; // Mandamos un mensaje.
    case APRETADO: digitalWrite(13,HIGH); break; // Encendemos el led.
    case SOLTANDOLO: Serial.write("Has soltado el botón"); break; // Mandamos un mensaje.
    default: break;
  }
}

Podéis jugar un poco ahora con el arduino. Si mirais el arduino, no está haciendo nada que veamos; pero cuando pulsamos el botón: plas! se enciende el led y envia un mensaje. Si lo mantenéis pulsado el led sigue encendido, pero no hace nada mas. Cuando lo sueltas, el led se apaga! y envia un mensaje.

Vamos a jugar un poco más pero, uff.. que perreria... escribir tanto... venga hagamos una pequeña libreria para leer botones y ahorrarnos código.

Este tutorial es un extracto del tutorial que cree para el foro de Arduino, si quieres ver el tutorial completo, ver los comentario y/o los añadidos al tutorial visita Como NO leer un botón y como SI debemos hacerlo.

Para este tutorial montaremos el siguiente circuito:

Uno de los errores más comunes que comenten los novatos a la hora de leer un botón con Arduino es usar simplemente la función digitalRead, pero ¿por qué? Imaginad este código:

/*
 * 1. Ejemplo de como no leer un botón.
 */
const int boton = 2; // Botón asignado en el pin 2.

void setup() {
  // Vamos a usar el puerto serie para mostrar el estado del botón.
  Serial.begin(9600);
  // Ponemos el pin como una entrada, puesto que vamos a leer
  // un botón. Habilito la resistencia de PULLUP.
  pinMode(boton,INPUT_PULLUP);
}

void loop() {
  // Cuando la entrada se ponga a 0, el botón "debería" estar
  // pulsado.
  if ( digitalRead(boton)==LOW ) {
    Serial.println("Botón pulsado");
  }
}

Cabría pensar que cuando apretamos el botón mostrará la cadena "Botón pulsado" y ya está, pero no, lo que ocurre es que mostrará muchas veces dicha cadena:

Botón pulsado
Botón pulsado
Botón pulsado
Botón pulsado
Botón pulsado
Botón pulsado

No importa lo rápido que apreteis y soltéis el botón, siempre se mostrará el texto varias veces.

Debéis recordar que el loop de Arduino es un bucle infinito que se ejecuta siempre y además muy rápido. En el programa solo lees el pin una vez, pero el programa se ejecuta muchas veces mientras tu pulsas el botón. Ah vale!, le meto un delay:

/*
 * 2. Ejemplo de como no leer un botón, con un delay
 */
const int boton = 2; // Botón asignado en el pin 2.
  
void setup() {
  Serial.begin(9600);
  // Ponemos el pin como una entrada, puesto que vamos a leer
  // un botón. Habilito la resistencia de PULLUP,
  pinMode(boton,INPUT_PULLUP);
}
  
void loop() {
  // Cuando la entrada se ponga a 0, el botón "debería" estar
  // pulsado.
  if ( digitalRead(boton)==LOW ) {
    Serial.println("Botón pulsado");
    delay(1000);
  }
}

Ahora cuando pulsas el botón solo te lo muestra una vez. Pero y ¿si pulsas tres veces seguidas? Anda, sigue mostrándolo solo una vez.

En el foro veréis que desaconsejamos el uso de delay para todo. Delay es una cosa que bloquea el programa, mientras está en él no hace otra ccosa. Por ejemplo, si pones dos botones, cuando pulses uno, hasta que no acabe el delay, no vas a poder leer ni ese ni el otro.

Solo bajando el tiempo del delay podrás obtener el efecto deseado, pero seguirá bloqueando el programa y perjudicará a otras tareas.

Ahora bien, me direis, ¿por qué en vez de mirar que el botón cuando esta apretado no miramos cuando el botón cambía?, es decir, mirar si en vez de estar HIGH o LOW, miramos cuando el botón cambia de HIGH a LOW LOW que será cuando estamos pulsando el botón. Vamos a hacerlo:

/*
 * 3. Ejemplo de como no leer un botón, usando una variable
 * para mantener el estado anterior.
 */
const int boton = 2; // Botón asignado en el pin 2.
int   anterior;      // guardamos el estado anterior.
void setup() {
  Serial.begin(9600);
  // Ponemos el pin como una entrada, puesto que vamos a leer
  // un botón. Habilito la resistencia de PULLUP.
  // más adelante.
  pinMode(boton,INPUT_PULLUP);
  anterior = digitalRead(boton);
}
  
void loop() {
  // Leemos el estado del botón haciendo un digitalRead, este
  // valor lo tendremos que asignar a la variable "anterior" para
  // que recordemos el estado en el que estaba.
  int estado = digitalRead(boton);
  // Igual que anteriores códigos solo mostramos cuando el estado
  // anterior sea alto (botón sin apretar) y el actual sea bajo
  if ( anterior==HIGH && estado==LOW ) {
    Serial.println("Hemos pulsado");
  }
  // Debemos guardar el estado en la variable anterior para poder
  // usarlo en la siguiente pasada del loop.
  anterior=estado;
}

Este código es mucho mejor. Si pulsáis el botón solo se muestra el código una vez, pero... vaya... de vez en cuando muestra varios mensajes ¿qué ocurre? Ocurre una cosa que se llama debouncing o rebote.

En la figura anterior podeis ver el comportamiento. Cuando apretamos el pulsador durante un tiempo T1 los contactos oscilarán de manera que parecerá una secuencia de 0's y 1's. Igualemente cuando lo soltamos ocurre lo mismo (tiempo T2). Los tiempos T1 y T2 son totalemente aleatorios y los valores de 0's y 1's también lo serán.

Dependiendo de lo bueno del pulsador, de los materiales con los que esté hecho, de los gastado que esté, etc, estos rebotes serán más o menos. Este efecto es inevitable, pero es previsible.

Solo hemos añadido un pequeño condesandor de "lenteja" de 100 nF. Con esto consegimos que el condensador absorba el rebote mientras se carga/descarga. Si ahora probamos el código del ejemplo 3, veremos que ahora podemos pulsar tranquilamente que el texto solo se mostrará una vez… aunque no es del todo perfecto.

La otra solución es usar millis y un temporizador. Cuando detectemos que la salida cambia debemos iniciar un temporizador, y solo aceptaremos la entrada como válida cuando transcurrido un tiempo la señal no haya cambiado:

/*
 * 4. Leyendo un boton con antirebote por software.
 */
const int boton = 2; // Botón asignado en el pin 2.
int   anterior;      // guardamos el estado anterior.
int   estado;        // el estado del botón.
unsigned long temporizador;
unsigned long tiemporebote = 50;

void setup() {
  Serial.begin(9600);
  pinMode(boton,INPUT_PULLUP);
  estado = HIGH;
  anterior = HIGH;
}
  
void loop() {
  // Si el estado es igual a lo leido, la entrada no ha cambiado lo que
  // significa que no hemos apretado el botón (ni lo hemos soltado); asi que
  // tenemos que parar el temporizador.
  if ( estado==digitalRead(2) ) {
    temporizador = 0;
  }
  // Si el valor distinto significa que hemos pulsado/soltado el botón. Ahora
  // tendremos que comprobar el estado del temporizador, si vale 0, significa que
  // no hemos guardado el tiempo en el que sa ha producido el cambio, así que
  // hemos de guardarlo.
  else
  if ( temporizador == 0 ) {
    // El temporizador no está iniciado, así que hay que guardar
    // el valor de millis en él.
    temporizador = millis();
  }
  else
  // El temporizador está iniciado, hemos de comprobar si el
  // el tiempo que deseamos de rebote ha pasado.
  if ( millis()-temporizador > tiemporebote ) {
    // Si el tiempo ha pasado significa que el estado es lo contrario
    // de lo que había, asi pues, lo cambiamos.
    estado = !estado;
  }

  // Ya hemos leido el botón, podemos trabajar con él.
  if ( anterior==HIGH && estado==LOW ) Serial.print("Botón pulsado");

  // Recuerda que hay que guardar el estado anterior.
  anterior = estado;
}

Ahora cada vez que pulsamos el interruptor, solo se muestra el mensaje una sola vez.

Anteriormente vimos las partes que componen un sistema de limpiarreja para una central hidroeléctrica, pero nos enfocamos solo en la parte mecánica del sistema. Obviamente para que todo el sistema funcione debe haber una parte de "control" que sea quien controle todo.

Ahora nos centraremos mas en la parte eléctrica del sistema, esta parte esta situada en el cuadro de control del limpiarreja.

Etapa de potencia.

Como vimos para actuar sobre el rastrillo tenemos un motor eléctrico que actua sobre unos piñones que mueven la cremallera dotando de movimiento al rastrillo, por lo que actuando sobre el giro del motor hacemos que el rastrillo suba o baje. Para controlar la posición del rastrillo tenemos unos finales de carrera ubicados en el eje del conjunto, uno para la posición anterior, y otro para la posición inferior.

También vimos que para deshacernos de la basura tenemos la canaleta a la cual debemos echar agua para que la expulse. Dicha agua la sacamos del canal mediante una bomba sumergida.

Estos motores son de potencia y trifásicos (230VAC). En el caso del motor del rastrillo es unos 4 KW y la bomba de agua es de 2.5 KW. Dado el amperaje que van a consumir los motores se hace necesario el uso de contactores.

Usamos tres contactores. Uno de ellos es exclusivo para la bomba de agua, y los otros dos para el rastrillo. Dado que ambos motores son trifasicos, para poder cambiar el sentido de giro del motor del rastrillo debemos usar dos contactores.

Obviamente para proteger los motores se han colocar sus respectivos guardamotores.

Además de los guardamotores para la bomba/rastrillo, existe un tercer guardamotor que protege la parte de mando del cuadro y un cuarto guardamotor para una toma de corriente que existe en el cuadro.

Alimentación del equipo.

La tensión trifasica de 230 VAC no sirve para los relés de control y para la bobina de los contactores, que son todos de 24VAC. Por ello se utiliza un transformador que tiene dos salidas de 20 y 24VAC.

La línea de tensión de 24VAC viene protegida con un automático de 5A

Mando del equipo

Para la interacción con el usuario existe una botonera en la parte superior que nos permite controlar las operaciones básicas del limpiarreja: subir, bajar, realizar un ciclo, parada de emergencia y interruptor de encendido/apagado.

Reles del equipo

Este es el cerebro del sistema, se trata de un conjunto de relés y temporizadores que hacen que el limpiarreja funcione. Tenemos tiempos para cuanto tiempo debe funcionar la bomba, cada cuanto tiempo tiene que realizar un ciclo, etc.

En las siguientes entradas veremos el ciclo de trabajo del limpiarreja y los motivos por los que decidimos que hay que cambiar todo el cuadro.

En las centrales hidroeléctricas hay un problema, y es que al rio suelen caer hojas, ramas e incluso árboles, animales y basura que la humanidad tira de manera inconsciente al rio.

Así que una turbina hidraúlica está expuesta a recibir objetos de tamaño variable que pueden llegar a tapar las entradas de agua, reduciendo su eficacia e incluso llegando a provocar averías. Objetos pequeños como hojas pasarán fácilemente a través de los alabes del distribuidor o las palas de la turbina, pero otros objetos más grandes como las ramas no podrán hacerlo.

Para evitar este problema se utiliza un elemento de protección llamado comunmente limpiarreja, y que esta diseñado para permitir el paso de agua y evitar que objetos grandes lleguen a entrar en la cámara de carga de la turbina.

La reja.

Existen varios tipos de mecanismos para proteger a la turbina de la basura, pero todos ellos se basan en el mismo método: la reja.

Consiste en una reja metálica compuesta de láminas de metal puestas en paralelo y unidas de tal forma que no puedan separarse. Estas láminas están separadas entre si una distancia que impide que los objetos de cierto tamaño puedan entrar a la turbina.

Sin duda, es el elemento más importante de toda la instalación, ya que es la que realmente protege la instalación. El resto de elementos de la instalación son los que actuan para mantener limpia la reja, ya que la reja por si misma solo impide el paso de objetos, pero no sirve para deshacerse de ellos.

El rastrillo.

Aquí es donde entra el rastrillo. Este elemento se encarga de recoger la basura que se queda en la reja.

El rastrillo puede tomar varias formas, pero casi siempre se trata de un conjunto de puas que se introducen entre los espacios de la reja haciendo que los objetos salgan y una parte que actua como "recogedor" que impide que la basura recogida vuelva a caer al rio y, por ende, volver a depositarse en la reja.

Para controlar la posición del rastrillo ya que no queremos que se hunda en el fondo del canal y tampoco que suba eternamente se utilizan dos finales de carrera circuilares colocados en el eje del motor/engranajes.

La canaleta

Pero, ¿qué ocurre cuando la basura ha llegado arriba?, Pues que sale de la reja y por gravedad cae del rastrillo. Así que hay que deshacerse de ella, ya que si no lo hacemos se irá acumulando.

Por eso la basura no cae libremente al suelo, si no que cae a una canaleta, desde la cual ayudada por un chorro de agua vuelve a empujar la basura hacia el rio.

En la próxima entrada veremos el cuadro de control, que es el encargado de que todo este sistema funcione, y veremos como es el funcionamiento del limpiarreja en si.