Contador de billetes

Autores

-Sergio Antón Berenguer

-Andrés Korotkov Vorobey

-Iván Fernández Ruiz

-Jesús Pérez Madera

Objetivo y motivación

El objetivo de este proyecto ha sido crear un sistema capaz de agilizar los cálculos a la hora de realizar las transacciones de la vida diaria, en lo que a billetes se refiere. Los dispositivos empleados actualmente tienen un coste muy elevado y además tardan en contar los billetes, nos preguntamos si seríamos capaces de replicar ese funcionamiento por un coste mucho menor al mismo tiempo que el cálculo se realiza de forma instantánea, mediante el uso de un sensor ultrasónico. Dicho sensor es capaz de medir en tiempo lo que tarda una onda ultrasónico al ir y volver rebotando contra una superficie, de esta forma, con los cálculos necesarios, podríamos traducir ese tiempo en distancia, que teniendo una altura de referencia y el grosor de un billete promedio resultaría en el total de los billetes colocados sobre la superficie.

Materiales

–Arduino Uno

Es el microcontrolador principal del proyecto, encargado de recibir datos del sensor, y los botones, y entonces actuar en consecuencia.

-Sensor ultrasónico

Mide la distancia al primer billete del fajo según el tiempo que tarda la onda en ir y volver.

-Pantalla LCD

Muestra los resultados obtenidos tras realizar la medición.

-Botones

Usados para configurar la entrada y dar comienzo a la medición.

–Servomotor

Debido a que se requiere medir sobre una superficie plana para que la onda del sensor ultrasónico no encuentre problemas en ir y volver, se ha usado el servomotor para aplastar los billetes y que no haya contratiempos en la medición.

–Pila de 9V

Suministra al sistema de energía para que este funcione correctamente

–Otros materiales

Caja de madera, pintura, placa protoboard.

COMPONENTE	PRECIO
Arduino	20€~
Sensor ultrasónico	2,4€~
Pantalla LCD	7€~
Botones	0,10€~
Servomotor	2€~
Pila de 9V	1,40€~
Pintura gris	9,29€
Caja de madera	30€~
Placa protoboard	4€~

Hardware

A continuación, mostramos el hardware del proyecto en dos formatos distintos: TinkerCad y el circuito físico real. En ellos se puede observar las piezas anteriormente mencionadas. En esta versión de TinkerCad, se pueden apreciar las conexiones de una forma más sencilla y limpia, ideal para hacer pruebas antes de empezar con los componentes reales.

Este proyecto está basado en una placa Arduino Uno, siendo este el componente principal del proyecto debido a que se encarga del manejo de señales de entrada y salida, con varios componentes electrónicos. 

El siguiente componente más importante sería el sensor ultrasónico HC-SR04 pues es el que mide las distancias gracias a sus ondas — como su nombre ya indica — ultrasónicas, con las que se envían y reciben con sus pines.

La pantalla LCD 16×2, que no es esencial pero es importante, nos permite mostrar la cantidad de billetes en este caso junto con su valor, utiliza solo 4 bits para mostrar información pues no nos hace falta más, y el usar 8 conexiones solo para mostrar caracteres por pantalla nos era excesivo. La pantalla además usa un potenciómetro para poder cambiar el contraste de la pantalla.

El servomotor que su función es aplastar los billetes para facilitar una mejor lectura y eliminar posibles espacios que surjan al apilar los billetes los cuales podrían provocar errores en la lectura de la distancia.

Y, por último, tenemos dos botones que nos sirven para elegir la cantidad que representan los billetes y hacer la medición del montículo de billetes, respectivamente.

Ahora, mostramos imágenes de la caja real. La primera es la parte frontal de la caja, donde podemos ver la pantalla y los botones, así como la zona inferior en la que se introducirán los billetes.

En esta otra imagen podemos ver el interior de la caja con todos los componentes fijados en sus posiciones necesarias. En la parte inferior se encuentra el servomotor que aplasta los billetes, en el medio el sensor, en los laterales la placa Arduino y la protoboard, y en la parte superior la pantalla y los botones.

Software

A continuación se muestra el código que maneja el conteo de billetes.

#include <LiquidCrystal.h>
#include <Servo.h>

#define SUBIR 160
#define BAJAR 50


// Pines de la LCD: RS, E, D4, D5, D6, D7
LiquidCrystal lcd(7, 13, 5, 4, 3, 2); 
Servo miServo;
//Constantes Billetes
const float alturaReferencia = 7.1; // en cm
const float grosorBillete = 0.34;   // en cm

const int trigPin = 9;
const int echoPin = 10;
const int buttonPin1 = A0;
const int buttonPin2 = A1;
const int noteValues[] = {5, 10, 20, 50, 100, 200, 500};
const int size = 7;
int actualNoteValue = noteValues[0];
int cont = 0;


float medirDistanciaModa(int muestras = 10) {
  const int MAX_MEDIDAS = 20;
  long lecturas[MAX_MEDIDAS];
  int frecuencia[MAX_MEDIDAS] = {0};
  int count = min(muestras, MAX_MEDIDAS);

  // Tomar las lecturas
  for (int i = 0; i < count; i++) {
    digitalWrite(trigPin, LOW);
    delayMicroseconds(2);
    digitalWrite(trigPin, HIGH);
    delayMicroseconds(10);
    digitalWrite(trigPin, LOW);
    long duracion = pulseIn(echoPin, HIGH);
    lecturas[i] = duracion;
    delay(50);
  }

  // Calcular la moda
  const long tolerancia = 100; // tolerancia en microsegundos
  int maxFrecuencia = 0;
  long moda = lecturas[0];

  for (int i = 0; i < count; i++) {
    for (int j = 0; j < count; j++) {
      if (abs(lecturas[i] - lecturas[j]) <= tolerancia) {
        frecuencia[i]++;
      }
    }
    if (frecuencia[i] > maxFrecuencia) {
      maxFrecuencia = frecuencia[i];
      moda = lecturas[i];
    }
  }
  // Convertir a distancia en cm
  return moda * 0.034 / 2.0;
}

void moverServo(int grados){
  miServo.write(grados);
  delay(15);
}

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(buttonPin1, INPUT_PULLUP);
  pinMode(buttonPin2, INPUT_PULLUP);
  miServo.attach(11);
  moverServo(SUBIR);
  lcd.begin(16, 2); // Inicializar la pantalla de 16x2
  lcd.setCursor(0, 0);
  lcd.print("Pulse boton 1");
}

void loop() {
  bool button1 = digitalRead(buttonPin1) == HIGH;
  bool button2 = digitalRead(buttonPin2) == HIGH;
  long duracion;
  float distancia;

  if(button1 && button2){
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Pulse boton 1");
    delay(1000);
  }else if(button1){
    lcd.clear();
    actualNoteValue = noteValues[cont];
    cont = (cont+1)%size;
    lcd.setCursor(0, 0);
    lcd.print("Valor de billete: ");
    lcd.setCursor(0, 1);
    lcd.print(actualNoteValue);
  }else if(button2){

    cont = 0;
    lcd.clear();

    moverServo(BAJAR);
    delay(200);
    // Medir tiempo de retorno
    distancia = medirDistanciaModa();

    float alturaFajo = alturaReferencia - distancia;
    int numBilletes = alturaFajo / grosorBillete;
    lcd.setCursor(0, 0);
    lcd.print("Billetes: ");
    lcd.print(numBilletes);
    lcd.setCursor(0, 1);
    lcd.print("Valor: ");
    lcd.print(numBilletes*actualNoteValue);

    moverServo(SUBIR);
  }
  delay(150);
}

Principalmente, tenemos la función medirDistanciaModa la cual es la que se encarga de tomar las lecturas con el sensor ultrasónico, y calcular la moda con una tolerancia de 100 microsegundos para mayor precisión. Luego, teniendo en cuenta el tiempo que tarda la onda emitida en ir y volver en microsegundos, se multiplica por 0.034 que es la velocidad del sonido en el aire, en cm por microsegundo, y se divide entre dos, ya que solo nos interesa la distancia de ida. De esta forma podemos obtener la altura del montón de billetes que dividido entre el grosor por billete obtenemos el número total de billetes.

Luego, nuestro sistema cuenta con dos botones. Si se pulsa el botón 1 se actualiza el valor de los billetes introducidos para calcular el valor total y se muestra por pantalla, que como podéis observar se hace ciclando los valores en un array. Si se pulsa el botón 2, primero se baja el servomotor para aplastar los billetes, y luego haciendo uso de la función que he explicado antes muestra por pantalla el número de billetes introducidos y su valor, y entonces vuelve a subir el servo. Si se pulsan los dos botones a la vez simplemente se reinicia la pantalla.

Problemas encontrados

En un inicio, no sabíamos muy bien cómo podríamos realizar nuestro cuenta billetes, ya que las máquinas originales serían bastante complicadas de replicar. Cuanto decidimos usar el ultrasónico, cometimos el error de no revisar bien la precisión del mismo, lo que nos ha llevado a tener que contar fajos de billetes en lugar de billetes sueltos, ya que la precisión del sensor es de +-3 milímetros. Otro problema con el sensor es que es muy sensible, cualquier ruido o interferencia en el sonido ambiente podría llegar a interferir en la medición de los billetes. Una caja bastante cerrada es suficiente para solucionarlo

Diagrama de flujo

También tenemos un simple diagrama de flujo, en el que podemos ver el funcionamiento que veremos a continuación en unos vídeos. Al inicio, tenemos que elegir con el botón 1 (izquierda) qué tipo de billete vamos a contar. Después, con el botón 2(derecha) empezaremos el proceso de contar billetes. Primero el servomotor bajará aplastando ligeramente los billetes para un mejor conteo. Después, el sensor realizará varias medidas y se nos mostrará por pantalla aquella que se haya repetido más. 

Resultado final

Tenemos estos vídeos en los que hacemos una serie de demostraciones con distintos fajos de billetes.

Posibles mejoras

Para conseguir mejorar nuestro proyecto y que este fuera más preciso, existen varias posibilidades que podrían aumentar la eficacia del cuenta billetes. Una mejora viable sería mejorar el aplastado de los billetes utilizando dos servomotores para poder aplastar de manera más uniforme y que no aplastase con menos fuerza en uno de los lados. Otra mejora, y posiblemente la más cara, es utilizar un ultrasónico industrial que puede llegar a tener precisiones de entre 0,025 y 0,1 mm. El principal problema con esta solución es que un ultrasónico de estas características puede llegar a costar más de 400 euros, una cantidad que se nos iba de presupuesto, y la cual tampoco conseguiría abaratar. La última mejora a destacar sería más bien una modificación total del proyecto, cambiando la forma en la que se calcula el número de billetes contándolos de uno en uno a partir de una especie de rodillo que desplace los billetes de uno en uno.