Hola gente , quería conectar un teclado matrical a una balanza hecha por mí con corte automático, quiero usar un teclado para poder cambiar el peso establecido de corte pero al ser nuevo en esto estoy perdido si alguien me puede brindar un ejemplo de cómo sería se lo agradecería mucho , desde ya muchas gracias
En este foro y en la web hay cientos de ejemplos con teclados matriciales. Es mas en Wokwi tienes algo como esto que es un ejemplo del que empiezas y puedes modificar a tu gusto permitiendo simular y desarrollar lo que desees.
Se podrá simular hasta la balanza ?
Averigualo pero lo dudo. Vi que hay un ejemplo con el HX711 pero con un ATtiny85 si mal recuerdo. Lo probé y funciona.
De todos modos no comprendo, no hace falta simular todo, con parte ya tenes un gran avance en tu proyecto.
Ahhh buenísimo gracias por siempre estar a todo lo que pregunto u responder siempre con una buena respuesta , cualquier duda público el código muchas gracias
Consulta se puede modificar esos pesos establecido con el teclado matrical , no me das un pequeño ejemplo de cómo sería , porque estuve buscando y todo son para claves , si me ayudas con un ejemplo te lo agradecería gracias
if (peso >= 25.00 || digitalRead(Rele)== HIGH)
{ //SI LA BOLSA PESA + DE 25KG CORTA
digitalWrite(Rele, HIGH); // SE APAGA EL RELE
digitalWrite (led, HIGH); // SE PRENDE LED ROJO
digitalWrite (led1, LOW); // SE APAGA LED VERDE
}
if (peso < 24.90){ //SI EL PESO ES - DE 25KG SIGUE CARGANDO
digitalWrite (Rele,LOW); // SE PRENDE RELE
digitalWrite(led , LOW); //SE PRENDE LED ROJO QUE FALTA PESO
digitalWrite(led1 , 1); //SI ESTA EN 25KG SE APAGA LUZ VERDE
}
Evidentemente hiciste caso omiso al link que te adjuntó @Surbyte en #2 sino no dirías que todo lo que encuentras es para ingresar claves.
De todos modos, ingresar una clave, un número en una calculadora o la magnitud de un peso en la balanza llevan prácticamente el mismo trabajo, si entiendes uno resuelves los otros.
hola estoy probando pero me quede trabado adjunto el código , gracias
#include <Keypad.h>
#include <Wire.h> // libreria de comunicacion por I2C
#include <LiquidCrystal_I2C.h> // libreria para LCD por I2C
//teclado metrical//
const byte filas = 4;
const byte columnas = 4;
byte pinesFilas[] = {9,8,7,6};
byte pinesColumnas[] = {5,4,3,2};
char teclas[4][4] = {{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}};
Keypad teclado1 = Keypad( makeKeymap(teclas), pinesFilas, pinesColumnas, filas, columnas);
//fin del teclado//
LiquidCrystal_I2C lcd (0x27,20,4); //PANTALLA DE LCD
#include "HX711.h"
#define DEBUG_HX711
// Parámetro para calibrar el peso y el sensor
//
#define CALIBRACION 94969.00 // LA CALIBRACION SE SACA DE OTRO PROGRAMA DE HX711 CON UN PESO CONOCIDO 94812.00
//#define CALIBRACION 143900 // Celda Ponis
//#define CALIBRACION 124000 // celda arduino 20kg
// Pin de datos y de reloj
byte pinData = 4;
byte pinClk = 3;
const int Rele = 9;
float peso = 0; // SE USA PARA DAR UNA FUNCION SI EL PESO ES MENOR O MAYOR O IGUAL DA UNA ORDEN
//byte led = 3;
byte led1 = 4;
// Objeto HX711
HX711 bascula
void setup() {
Serial.begin(9600);
Serial.println("Teclado 4x4 con Biblioteca Keypad");
Serial.println();
}
void loop() {
//Verifica si alguna tecla fue presionada
char tecla_presionada = teclado1.getKey();
#ifdef DEBUG_HX711
float peso = bascula.get_units(8); // cantidad de veces que pesa (), digitos que se muestran 3. antes tenia en 0 la cantidad de pesadas
#endif
lcd.setCursor(4, 0);
lcd.print(peso, 4); // cantidad de caracteres que se muestran del float
lcd.setCursor(9, 0);
lcd.print (" Gr");
lcd.setCursor (0, 2);
lcd.print (" MEZCLA ");
if (peso >= tecla_presionada || digitalRead(Rele)== HIGH){ //SI LA BOLSA PESA + DE 25KG CORTA
digitalWrite(Rele, HIGH); // SE APAGA EL RELE
// digitalWrite (led, HIGH); // SE PRENDE LED ROJO
digitalWrite (led1, LOW); // SE APAGA LED VERDE
}
if (peso < 24.00){ //SI EL PESO ES - DE 25KG SIGUE CARGANDO
digitalWrite (Rele,LOW); // SE PRENDE RELE
// digitalWrite(led , LOW); //SE PRENDE LED ROJO QUE FALTA PESO
digitalWrite(led1 , 1); //SI ESTA EN 25KG SE APAGA LUZ VERDE
}
Las teclas presionadas son ASCII asi que debes convertirlas en números para poder compararlos
en esta parte de código aunque siempre sería algo como 2 kilos contra 2 y eso no tiene mucho sentido.
if (peso >= tecla_presionada
Lo que realmente haces es comparar un valor de peso supongamos 3.43 contra "3" si presionaras el número 3 del teclado
El código de la calculadora sin embargo crea el camino para convertir las pulsaciones de teclas en valores enteros o decimales.
Eso es lo que obviaste que debes incluir y por eso no funcionana nada.
Ahh buenísimo pero voy más o menos en el camino , lo que yo quiero usar el teclado es solo para cambiar el peso de corte del relay ejemplo en ves de que corte en 25kg quiero poner con el peso que necesito
Pero no borres todo lo que tenias de la calculadora.
Usa la parte de calculadora que transforma las pulsaciones en números.
Observa el código y quédate con eso. Esa porción de código te dara luego la tara, o el corte o lo que quieras.
Yo solo quiero el peso de corte nada más por eso ponía , tecla presionada donde antes estaba los 25kg , entonces al poner ahí yo preciono los número que necesito , cuando llegue a los Kg necesario corte el relay
Lo que intentas no es correcto.
Piensa que cuando pulsas una tecla es similar a recibir un dato por serial, llega caracter a caracter, entonces tienes que "armar" el numero que estás tecleando.
Por eso @Surbyte te dice que te bases en la forma en que en la calculadora ingresan los números.
1 Like
Tu presionas 3 y no tienes el numero 3 sino "3" que es un caracter.
Luego presionas 4 y recibes "4" pero el 3 se perdio a menos quelo acumules
Luego presionas . y solo tendras .
Se comprende?
hola @Surbyte mira llegue hacer este código ,gracias a otro que había acá en el forum , quería saber si hay algún programa para probar todo el código , con el sensor hx711 y las biblioteca adjunto el codigo , en arduino compila bien
#include "HX711.h"
#define DEBUG_HX711
#define CALIBRACION 94969.00 // LA CALIBRACION SE SACA DE OTRO PROGRAMA DE HX711 CON UN PESO CONOCIDO 94812.00
#include <Keypad.h>
#include <Wire.h> //Libreria wire i2c
#include <LiquidCrystal_I2C.h> // libreria liquid cristal
// Incluimos direccion 0x27, y elegimos un display de 2x16
LiquidCrystal_I2C lcd(0x27, 16, 2);
HX711 bascula;
byte pinData = A4;
byte pinClk = A5;
const byte Filas = 4; //KeyPad de 4 filas
const byte Cols = 4; //y 4 columnas
byte Pins_Filas[] = {9, 8, 7, 6}; //Pines Arduino para las filas.
byte Pins_Cols[] = {5, 4, 3, 2}; // Pines Arduino para las columnas.
float peso = 0; // peso del sensor hx711
char pulsacion;
String PIN_Tecleado = ""; // teclas digitadas
float pesoMinEstablecido = 0.0; // cadena de datos digitados a travez del teclado. Cero por defecto
float pesoMaxEstablecido = 1.0; // Uno por defecto
boolean enMaximo = false; // Indica si se está determinando peso mínimo o máximo.
boolean pesoestablecido = false; // Indica si ya se definieron los límites.
boolean puntoEscrito = false; // Indica si ya se ha escrito el punto decimal.
boolean limitesMostrados = false; // Esto evita que, repetidamente, se escriba al LCD los limites ya definidos.
const byte ledMin = 12; // LED del peso mínimo
const byte ledMax = 13; // LED del peso máximo
char cadena[17]; //para poder hacer la conversion a número
char Teclas [Filas][Cols] = {
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'.', '0', '#', 'D'}
};
Keypad Teclado1 = Keypad(makeKeymap(Teclas), Pins_Filas, Pins_Cols, Filas, Cols);
void setup() {
pinMode(ledMin, OUTPUT);
pinMode(ledMax, OUTPUT);
//pinMode(boton, INPUT);
Serial.begin(9600);
delay(100);
lcd.backlight(); // Encendemos el back light
lcd.setCursor(2, 0);
lcd.print("INGRESE PESO MIN");
#ifdef DEBUG_HX711
#endif
// Iniciar sensor
bascula.begin(pinData, pinClk);
// Aplicar la calibración
bascula.set_scale(CALIBRACION);
// Iniciar la tara
// No tiene que haber nada sobre la balanza
bascula.tare();
}
void loop() {
#ifdef DEBUG_HX711
float peso = bascula.get_units(8); // cantidad de veces que pesa (), digitos que se muestran 3. antes tenia en 0 la cantidad de pesadas
#endif
pulsacion = Teclado1.getKey();
switch (pulsacion) {
case '.': // Punto decimal
if (puntoEscrito) { // No hace nada si ya se había escrito un punto previamente
break;
} else {
puntoEscrito = true;
}
case '0' ... '9': // o dígitos,
if (!pesoestablecido) { // No hace nada si ya se habían establecido los dos límites
delay(30);
//digitalWrite( pinled, LOW); //Si se presiona algun numero durante el arranque se detiene la balanza
// lcd.clear();
PIN_Tecleado += pulsacion; // los agregamos a la cadena
// lcd.setCursor(2, 0);
// lcd.print("DIGITAR PESO");
lcd.setCursor(1, 1);
lcd.print(PIN_Tecleado );
}
break;
case 'B': // Lo tomaremos como enter para guardar el dato
if (!pesoestablecido) { // No hace nada si ya se habían establecido los dos límites
delay(30);
lcd.clear();
PIN_Tecleado.toCharArray( cadena, 17);
if (!enMaximo) {
pesoMinEstablecido = atof (cadena);
//Serial.println(pesoMinEstablecido);
} else {
pesoMaxEstablecido = atof (cadena);
//Serial.println(pesoMaxEstablecido);
}
lcd.setCursor(0, 0);
lcd.print("peso, 4 ");
lcd.setCursor(7, 0);
lcd.print(pesoestablecido);
lcd.print("Kg");
if (enMaximo) {
pesoestablecido = true;
puntoEscrito = true;
} else {
puntoEscrito = false;
lcd.clear();
lcd.setCursor(2, 0);
lcd.print("DIGITAR PESO MAX");
enMaximo = true;
}
}
PIN_Tecleado = ""; // Tiene sentido vaciar este "búfer" después de establecer un peso.
break;
break;*/
case 'C': // lo tomaremos como borrar todo
delay(30);
lcd.clear();
// Volver todo a sus valores iniciales
pesoMinEstablecido = 0.0;
pesoMaxEstablecido = 1.0;
enMaximo = false;
pesoestablecido = false;
puntoEscrito = false;
limitesMostrados = false;
PIN_Tecleado = "";
lcd.setCursor(2, 0);
lcd.print("DIGITAR PESO MIN");
break;
}
if (pesoestablecido && !limitesMostrados) {
limitesMostrados = true;
// No sé exactamente cómo lidiar con pantallas LCD.
// Aquí la idea es que muestre, en patalla, los límites (pesos) establecidos.
}
if (peso () > 0) {
peso = bascula.parseFloat();
if (peso < pesoMinEstablecido) { // Cuando está por debajo del mínimo
digitalWrite(ledMin, HIGH);
digitalWrite(ledMax, LOW);
// Serial.println(pesoEstablecido);
delay(100);
}
if ((peso >= pesoMinEstablecido) && (peso < pesoMaxEstablecido)) { // Cuando está en el rango aceptable
digitalWrite(ledMin, LOW);
digitalWrite(ledMax, LOW);
// Serial.println(pesoEstablecido);
delay(100);
}
if( peso >= pesoMaxEstablecido) { // Cuando está por encima del máximo
digitalWrite(ledMax, HIGH);
digitalWrite(ledMin, LOW);
// Serial.println(pesoEstablecido);
delay(100);
}
}
}
Lee el post#2, ahi esta tu respuesta.
hola ahi logre hacerlo pero tengo un problema no logro que me ande el sensor hx711 me quede ahi colgado dejo el link
(hx711_test.ino - Wokwi Arduino and ESP32 Simulator)
espero tu respuesta muchas gracias
Tenes algo mal en tu código.
#include <Arduino.h>
#include "HX711.h"
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
#include <Keypad.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
// HX711 circuit wiring
byte Data = A2;
byte PinesSCK = A1;
#define DEBUG_HX711
#define CALIBRACION 94969.00 // LA CALIBRACION SE SACA DE OTRO PROGRAMA DE HX711 CON UN PESO CONOCIDO 94812.00
HX711 bascula;
float peso =0;
/////////////////////telclado//////////////
const byte Filas = 4;
const byte Columnas= 4;
byte PinesFilas[] = {9,8,7,6}; //pines filas
byte PinesColumnas[] = {5,4,3,2}; // pines columnas
char pulsacion;
String PIN_Tecleado = ""; // teclas digitadas
float pesoMinEstablecido = 0.0; // cadena de datos digitados a travez del teclado. Cero por defecto
float pesoMaxEstablecido = 1.0; // Uno por defecto
boolean enMaximo = false; // Indica si se está determinando peso mínimo o máximo.
boolean establecido = false; // Indica si ya se definieron los límites.
boolean puntoEscrito = false; // Indica si ya se ha escrito el punto decimal.
boolean limitesMostrados = false; // Esto evita que, repetidamente, se escriba al LCD los limites ya definidos.
float numero = 0; // datos de peso del puerto serie
const byte ledMin = 12; // LED del peso mínimo
const byte ledMax = 13; // LED del peso máximo
char cadena[17];
char Teclas [Filas][Columnas] = {
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'.', '0', '#', 'D'}
};
Keypad Teclado1 = Keypad(makeKeymap(Teclas), PinesFilas, PinesColumnas, Filas, Columnas);
void setup() {
#ifdef DEBUG_HX711
#endif
// Iniciar sensor
bascula.begin(Data, PinesSCK);
// Aplicar la calibración
bascula.set_scale(420);
// Iniciar la tara
// No tiene que haber nada sobre la balanza
bascula.tare();
Serial.begin(9600);
delay(100);
lcd.begin(16,2);// Iniciamos el lcd
lcd.backlight(); // Encendemos el back light
lcd.setCursor(0, 0);
lcd.print(" pon peso corte");
}
void loop(){
lcd.setCursor(0, 0);
lcd.print("PESO : ");
lcd.setCursor(7, 0);
lcd.print(bascula.get_units(10),2);
lcd.print("Kg");
delay(1000);
}
La balanza simulada funciona
Tal vez no te entendí.
Probé ahora tu código de otro modo y toma datos pero... no relfeja lo que se simula como peso.
No le presté mucha atención porque es tarde.
Le puse peso de corte 45.5kg y luego medi valores y me daba negativos.
Con 11.4kg me da -0.9Kg en el display..
No se que es lo esperable?
La idea es que ingrese un peso de corte si está menos de 24.90 que siga prendido el relay , y cuando ingresé pesomaximo , cuando la balanza llegue a 25.20kg se apague el relay ,uso el teclado para colocar esos peso en vez de dejarlo establecido , no puedo hacer que cuando ya tenga ingresado los datos que me pide cuando comienza ,me funcione la balanza , adjunto de vuelta el codigo
@Surbyte hola me podrás ayudar gracias