Dispensador de granos con ARDUINO

Desarrollé un sistema automatizado de dispensado controlado por Arduino Nano modificado, capaz de entregar cantidades exactas de producto (desde 100g hasta 1000g) con precisión milimétrica. El proyecto integra:

• Electrónica avanzada: Fuente regulada a 5V, sensor HX711 para pesaje de alta precisión, entradas protegidas con optoacopladores y salidas configurables para motores.
• Diseño mecánico profesional: Estructura 3D en SolidWorks con piezas combinadas (corte láser + impresión 3D) y sistema de vibración controlada.
• PCB personalizada: Versión optimizada del ATMega328P (como Arduino pero más eficiente) con opción para motor paso a paso (driver A4988).

1. Tensión de alimentación……………………….…………12VDC
2. Corriente de alimentación………………….……………120mA
3. Entadas digitales 12VDC…………………………….……4
4. Entrada para sensor de Peso………………………………1
5. Salidas TRANSISTORES…………………………4
   • • Tensión DC………………………………………………12V
     • Corriente DC……………………………………………1A
6. Salida para motor paso a paso……………………………….1
7. Entorno de programación………………………..………..Arduino IDE
8. Condiciones ambientales min……………………….….-40°
9. Condiciones ambientales max…………………..……….80°
10. Dimensiones……………………………………………………….125x75mm
11.  Empotrable………………………………….……………………Sí
12. Programación directa (PC-Tarjeta electrónica)…………Sí

//Incluye las librerías
#include "HX711.h"
//#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>

LiquidCrystal_I2C lcd(0x20, 16, 2);

HX711 balanza;

const int zero = 2;
const int add = 14;
const int ok = 3;

int last_add = 0;
int last_less = 0;
int last_ok = 0;
unsigned int umbral = 100;

bool act = false;

#define MOTOR 6
int DT = 5;
int CLK = 4;

int peso_calibracion = 193;  // Es el peso referencial a poner, en mi caso mi celular pesa 185g (SAMSUMG A20)
long escala;

int state_zero = 0;
int last_state_zero = 0;

//Función calibración
void calibration() {  // despues de hacer la calibracion puedes borrar toda la funcion "void calibration()"
  boolean conf = true;
  long adc_lecture;

  // restamos el peso de la base de la balaza
  lcd.setCursor(0, 0);
  lcd.print("Calibrando base");
  lcd.setCursor(4, 1);
  lcd.print("Balanza");
  delay(3000);
  balanza.read();
  balanza.set_scale();  //La escala por defecto es 1
  balanza.tare(20);     //El peso actual es considerado zero.
  lcd.clear();

  //Iniciando calibración
  while (conf == true) {

    lcd.setCursor(1, 0);
    lcd.print("Peso referencial:");
    lcd.setCursor(1, 1);
    lcd.print(peso_calibracion);
    lcd.print(" g        ");
    delay(3000);
    lcd.clear();
    lcd.setCursor(1, 0);
    lcd.print("Ponga el Peso");
    lcd.setCursor(1, 1);
    lcd.print("Referencial");
    delay(3000);

    //Lee el valor del HX711
    adc_lecture = balanza.get_value(100);

    //Calcula la escala con el valor leido dividiendo el peso conocido
    escala = adc_lecture / peso_calibracion;

    //Guarda la escala en la EEPROM
    EEPROM.put(0, escala);
    delay(100);
    lcd.setCursor(1, 0);
    lcd.print("Retire el Peso");
    lcd.setCursor(1, 1);
    lcd.print("referencial");
    delay(3000);
    lcd.clear();
    lcd.setCursor(1, 0);
    lcd.print("READY!!....");
    delay(3000);
    lcd.clear();
    conf = false;  //para salir de while
    lcd.clear();
  }
}

void setup() {

  balanza.begin(DT, CLK);  //asigana los pines para el recibir el trama del pulsos que viene del modulo
  pinMode(zero, INPUT);    //declaramos el pin2 como entrada del pulsador
  pinMode(add, INPUT);
  pinMode(ok, INPUT);
  pinMode(MOTOR, OUTPUT);
  digitalWrite(MOTOR, 0);

  lcd.init();       // Inicializamos el lcd
  lcd.backlight();  // encendemos la luz de fondo del lcd

  EEPROM.get(0, escala);

  if (umbral == 65535 || umbral > 1000) {  // 10000 es un límite razonable para tu aplicación
    umbral = 100;
    EEPROM.get(6, umbral);  // Guarda 0 en la EEPROM
  }

  if (digitalRead(zero) == 1) {  //esta accion solo sirve la primera vez para calibrar la balanza, es decir se presionar ni bien se enciende el sistema
    calibration();
  }
  balanza.set_scale(escala);  // Establecemos la escala
  balanza.tare(20);           //El peso actual de la base es considerado zero.
}

void loop() {
  //EEPROM.get(3, umbral);

  int state_zero = digitalRead(zero);
  float peso;
  peso = balanza.get_units(10);  //Mide el peso de la balanza

  //Muestra el peso
  lcd.setCursor(1, 0);
  lcd.print("Peso: ");
  lcd.print(peso, 0);
  lcd.println(" g        ");
  delay(5);
  lcd.setCursor(1, 1);
  lcd.print("Umbral : ");
  lcd.print(umbral);
  //Botón de zero, esto sirve para restar el peso de un recipiente
  if (state_zero != last_state_zero) {
    if (state_zero == LOW) {
      balanza.tare(10);  //El peso actual es considerado zero.
    }
  }
  last_state_zero = state_zero;

  if (digitalRead(add) != last_add) {
    if (digitalRead(add) == LOW) {
      umbral += 100;
      if (umbral >= 1000) {
        umbral = 100;
      }
      EEPROM.put(6, umbral);
      lcd.setCursor(1, 1);
      lcd.print("Umbral : ");
      lcd.print(umbral);
      lcd.println(" g ");
    }
  }
  last_add = digitalRead(add);

  if (digitalRead(ok) != last_ok) {
    if (digitalRead(ok) == LOW) {
      act = true;
    }
  }
  last_ok = digitalRead(ok);

  if (act == true) {
    digitalWrite(MOTOR, 1);
  }
  if (peso >= (umbral - 6)) {
    digitalWrite(MOTOR, 0);
    act = false;
  }
}