No te puedo decir nada más porque tu código está incompleto y no puedo adivinar lo que sigue.
El proyecto si me funcionó. Cuando no detecta papel, el Arduino activa el pulso de la válvula, y cuando detecta el sensor el papel, se desactiva.
Me realiza el conteo de variables.
Solamente observo que cuando el Arduino activa la señal del relevador o cuando presiono algunos botones (ingreso voltaje en pines de entrada) el LCD muestra unos símbolos raros. O no muestra nada, pero el Arduino sigue funcionando.
Estas son mis I/O:
const int diez = 32; //+10
const int cincuenta = 34; //+50
const int cien = 36; //+100
const int arranque = 22; //Arranque pin 22
const int sensor = 42; //Sensor pin 42
const int paro = 24; //Paro pin 24
const int reset = 26; //Reset pin 26
const int pulso = 48; // Salida Relevador, Válvula SMC. Pin 8.
¿Cómo puedo evitar que el LCD muestre símbolos raros?
Gracias de antemano.
Por lo visto algún relé esta provocando ruido eléctrico.
Tienes varias soluciones posibles, depende de done lo mires.
Por un lado identificar los relés y sus accionamientos, son de AC o DC, espero respuesta.
Por otro lado que puedes hacer desde el arduino y su alimentación para bloquear el ruido.
Desde el arduino puedes usar un choque de ferrite algo asi
y de ese modo bloquear todo ruido de modo común. Si el LCD se alimenta desde el arduino eso debería bloquear todo el problema.
Tal vez con eso resuelvas todo.
Puede ser eso, pero también puede ser que en los diferentes estado de máquina (Seleccion, proceso, pausa y finalizado) esté enviando mensajes simultáneos al LCD, y no sabe que poner.
La alimentación viene de un módulo de 24 a 5 V (OKY3502-1). No entiendo exactamente donde debo colocar el núcleo de ferrite.
No, porque si está ejecutando un "estado" no puede ejecutar otro.
Como la máquina va a enviar diferentes estados y tu no puedes discriminarlos?
Eso se explica simplemente como que algo se te ha pasado por alto en tu código.
Al menos haz un análisis de que envía, lo registras y ves en todo caso si dos o mas estados se manifiestan simultáneamente. Si fuera el caso, un LCD de 2 líneas es insuficiente.
Estas hace tiempo con este tema y cuando veo que un tema lleva mucho tiempo me pongo a ver que pasó. Dudo que quienes te han guiado lo hayan hecho mal porque siempre somos los mismos los que opinamos y aconsejamos.
Entonces o tu has menospreciado el problema o hay cosas que se te escapan.
Pregunta simple requiere respuesta simple:
@MaximoEsfuerzo te ha pedido sistemáticamente que publiques todo el código, lo que se ve es todo el código?
Vamos a trabajar conjuntamente sobre algo y todo lo que se haga será común a quienes respondamos. okay.
Podemos hacer una simulación sea en wokwi u otro simulador.
Así que para hacerlo cuéntanos si tus entradas +10 +50 +100 etc. cuanto tiempo están activas? hay mas señales?
He visto muchas variaciones del código, cómo es posible?
Finalmente no veo en tus códigos que leas los pines 6, 7 y 8
Ejemplo que es lo que leo en #16, donde lees los pines 6 a 8? Solo el pin de paro.
En #6 trabajas con un solo pin que es 8, asi que de nuevo, no comprendo.
Resumiendo.
Hasta el mensaje #22 veniamos con otras asignaciones ahora tienes
const int diez = 32; //+10
const int cincuenta = 34; //+50
const int cien = 36; //+100
const int arranque = 22; //Arranque pin 22
const int sensor = 42; //Sensor pin 42
const int paro = 24; //Paro pin 24
const int reset = 26; //Reset pin 26
const int pulso = 48; // Salida Relevador, Válvula SMC. Pin 8.
Con cuenta gotas, luego del pedido de @MaximoEsfuerzo ahi se leen los pines.
Por eso orden.
Gracias por la aclaración.
Trataré de tener más orden.
La secuencia funciona correctamente. Estoy teniendo ruido eléctrico por parte de la máquina 220V que tiene una tarjeta que baja a 24V DC.
De ahí tomé el siguiente módulo OKY3502-1 para sacar 5V.
El problema de voltaje empieza cuando el relevador activa a la 3era o 4ta vez, el LCD muestra caracteres raros y a veces para la bomba de vacío (que actualmente se encuentra desde el control original de la máquina).
El control que yo implementé con arduino es el siguiente.
Los botones +10, +50 y +100 se suman a una variable al presionar el botón correspondiente.
Al arrancar, se activa el relay para activar una válvula de 24V; deja pasar el papel y es detectado por un sensor infrarojo de 5V.
Después de que lee el sensor, descuenta 1 valor y suma a otra variable. Ejemplo
Meta: 99
Cuenta: 1
Y así sucesivamente hasta pasar las 100 piezas.
La secuencia funciona a la perfección.
Pongo en copia el código.
#include <LiquidCrystal.h>
LiquidCrystal lcd (7, 6, 5, 4, 3, 2); // cambié pin 12 por 7 & pin 11 por 6
enum {Seleccion, Proceso, Finalizado,Pausado};
unsigned char Estado;
//Estados de la máquina = 4
//Stg1 Menú para ingresar META.
//Stg2 Arranque
//Stg3 Paro solicitado por usuario, pero aún queda número en META.
//Stg4 Finalizado. No queda número en cuenta y regresamos a Stg1.
//Variables para Dobladora
int meta=0;
int meta2=0;
int cuenta=0;
//int M=0;
const int pin1 = 1;
const int pin13 = 13;
const int diez = 32; //+10
const int cincuenta = 34; //+50
const int cien = 36; //+100
const int arranque = 22; //Arranque pin 22
const int sensor = 42; //Sensor pin 42
const int paro = 24; //Paro pin 24
const int reset = 26; //Reset pin 26
const int pulso = 48; // Salida Relevador, Válvula SMC. Pin 8.
unsigned long lastDebounceTime22 = 0; // última vez que el pin cambió
unsigned long debounceDelay22 = 50; // debounce time; aumenta si la salida parpadea
unsigned long lastDebounceTime24 = 0; // última vez que el pin cambió
unsigned long debounceDelay24 = 50; // debounce time; aumenta si la salida parpadea
unsigned long lastDebounceTime26 = 0; // última vez que el pin cambió
unsigned long debounceDelay26 = 50; // debounce time; aumenta si la salida parpadea
unsigned long lastDebounceTime32 = 0; // última vez que el pin cambió
unsigned long debounceDelay32 = 50; // debounce time; aumenta si la salida parpadea
unsigned long lastDebounceTime34 = 0; // última vez que el pin cambió
unsigned long debounceDelay34 = 50; // debounce time; aumenta si la salida parpadea
unsigned long lastDebounceTime36 = 0; // última vez que el pin cambió
unsigned long debounceDelay36 = 50; // debounce time; aumenta si la salida parpadea
//int ledState22 = HIGH; // the current state of the output pin 32
int buttonState22 = LOW; // the current reading from the input pin 32
int lastButtonState22 = LOW; // the previous reading from the input pin 32
//int ledState24 = HIGH; // the current state of the output pin 32
int buttonState24 = LOW; // the current reading from the input pin 32
int lastButtonState24 = LOW; // the previous reading from the input pin 32
//int ledState26 = HIGH; // the current state of the output pin 32
int buttonState26 = LOW; // the current reading from the input pin 32
int lastButtonState26 = LOW; // the previous reading from the input pin 32
//int ledState32 = HIGH; // the current state of the output pin 32
int buttonState32 = LOW; // the current reading from the input pin 32
int lastButtonState32 = LOW; // the previous reading from the input pin 32
//int ledState34 = HIGH; // the current state of the output pin 32
int buttonState34 = LOW; // the current reading from the input pin 34
int lastButtonState34 = LOW; // the previous reading from the input pin 34
//int ledState36 = HIGH; // the current state of the output pin 32
int buttonState36 = LOW; // the current reading from the input pin 34
int lastButtonState36 = LOW; // the previous reading from the input pin 34
int anterior24 = LOW;
int anterior26 = LOW;
int anterior42 = LOW;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
lcd.begin(16,2);
pinMode(diez, INPUT); //Pin 32 +10
pinMode(cincuenta, INPUT); //Pin 34 +50
pinMode(cien, INPUT); //Pin 36 +100
pinMode(sensor, INPUT); // Sensor de detección de hoja.
pinMode(pulso, OUTPUT); // Salida Relevador, Solenoide SMC. pin 8.
pinMode(pin13, OUTPUT); // pin 13.
pinMode(pin1, OUTPUT); // pin 1.
}
void loop() {
digitalWrite(pin13,LOW);
digitalWrite(pin1,LOW);
int reading22 = digitalRead(arranque);
int reading42 = digitalRead(sensor);
int reading24 = digitalRead(paro);
int reading26 = digitalRead(reset);
int reading32 = digitalRead(diez);
int reading34 = digitalRead(cincuenta);
int reading36 = digitalRead(cien);
// put your main code here, to run repeatedly:
if (Estado==Seleccion){
Serial.print("Etapa: ");
Serial.print(Estado);
Serial.print("Estado del sensor: ");
Serial.println(reading42);
}
if (Estado==Proceso){
Serial.print("Meta: ");
Serial.print(meta);
Serial.println(" Proceso");
}
if (Estado==Finalizado){
Serial.print("Etapa ");
Serial.print(Estado);
Serial.println(" Finalizado");
}
//delay(300);
switch (Estado) {
case Seleccion:
//+10 PIN 32
if (reading32 != lastButtonState32) {
// reset the debouncing timer
lastDebounceTime32 = millis();
}
if ((millis() - lastDebounceTime32) > debounceDelay32) {
if (reading32 != buttonState32) {
buttonState32 = reading32;
if (buttonState32 == HIGH) {
//ledState34 = !ledState34;
meta=meta+10; //variable dobladora
}
}
}
//+50 PIN 34
if (reading34 != lastButtonState34) {
// reset the debouncing timer
lastDebounceTime34 = millis();
}
if ((millis() - lastDebounceTime34) > debounceDelay34) {
if (reading34 != buttonState34) {
buttonState34 = reading34;
if (buttonState34 == HIGH) {
//ledState34 = !ledState34;
meta=meta+50; //variable dobladora
}
}
}
//+100 PIN 36
if (reading36 != lastButtonState36) {
// reset the debouncing timer
lastDebounceTime36 = millis();
}
if ((millis() - lastDebounceTime36) > debounceDelay36) {
if (reading36 != buttonState36) {
buttonState36 = reading36;
if (buttonState36 == HIGH) {
//ledState36 = !ledState36;
meta=meta+100; //variable dobladora
}
}
}
//Arranque PIN 22
if (reading22 != lastButtonState22) {
// reset the debouncing timer
lastDebounceTime22 = millis();
}
if ((millis() - lastDebounceTime22) > debounceDelay22) {
if (reading22 != buttonState22) {
buttonState22 = reading22;
if (buttonState22 == HIGH) {
if (meta!=0) {
//ledState22 = !ledState22;
meta2=meta;
Estado=Proceso;
lcd.clear();
lcd.setCursor(3,0);
lcd.print("ARRANQUE");
delay(1000);
lcd.clear();
// Avance al siguiente estado
}
}
}
}
//RESET PIN 26
if (reading26 != lastButtonState26) {
// reset the debouncing timer
lastDebounceTime26 = millis();
}
if ((millis() - lastDebounceTime26) > debounceDelay26) {
if (reading26 != buttonState26) {
buttonState26 = reading26;
if (buttonState26 == HIGH) {
//ledState26 = !ledState26;
lcd.clear();
meta=0; //variable dobladora
}
}
}
lcd.setCursor(0,0);
lcd.print("META:");
// se imprime la variable
lcd.setCursor(12,0);
lcd.print(meta);
lcd.setCursor(0,1);
lcd.print("Cuenta:");
//lcd.print(porcentaje); se imprime la variable
// se imprime la variable
lcd.setCursor(12,1);
lcd.print(cuenta);
lastButtonState22 = reading22;
lastButtonState24 = reading24;
lastButtonState26 = reading26;
lastButtonState32 = reading32;
lastButtonState34 = reading34;
lastButtonState36 = reading36;
break; //termina Stg1
case Proceso:
lcd.clear();
lcd.setCursor(0,0);
lcd.print("META:");
// se imprime la variable
lcd.setCursor(12,0);
lcd.print(meta);
lcd.setCursor(0,1);
lcd.print("Cuenta:");
//lcd.print(porcentaje); se imprime la variable
// se imprime la variable
lcd.setCursor(12,1);
lcd.print(cuenta);
if (meta != 0) {
if (reading42==LOW) { //Señal del sensor pin 42
digitalWrite(pulso,HIGH);
}
if (reading42==HIGH) { //Señal del sensor pin 42
digitalWrite(pulso,LOW);
anterior42=reading42;
}
if (anterior42!=reading42 and reading42==LOW){ //Paro y arranque
lcd.clear();
meta=meta-1;
cuenta=cuenta+1;
anterior42=LOW;
}
if (reading24==HIGH){ //Paro
Estado=Pausado;
}
if (meta==0){ //Termina ciclo
Estado=Finalizado;
}
}
break; //termina Proceso
case Finalizado:
cuenta=0;
lcd.clear();
lcd.setCursor(0,0);
lcd.print("IMPRESOS AGLEZCA");
digitalWrite(pulso,LOW);
delay(1000);
lcd.clear();
meta=meta2;
Estado=Proceso;
break; //termina Finalizado
case Pausado:
lcd.clear();
lcd.setCursor(6,0);
lcd.print("PAUSA");
digitalWrite(pulso,LOW);
if (reading26==HIGH){ //RESET
lcd.clear();
meta=0;
meta2=0;
cuenta=0;
digitalWrite(pulso,LOW);
Estado=Seleccion;
}
if (reading22==HIGH) {
Estado=Proceso;
}
break; //termina Pausado
} // cierre de Switch Estado
} // cierre de void Loop
Creo que el tema del ruido lo eliminaré alimentando el Arduino desde otra fuente y aislar el voltaje del relevador con un relevador de estado sólido o una placa de amortiguación (Circuito RLC, lo he leído en otros foros).
Por cierto, coloqué diferentes capacitores, pero nada me funcionó..
Seguiré leyendo y haciendo pruebas.
Gracias por las respuestas.
Jorge.
Entre bornes de la válvula de 24V debes poner un diodo en antiparalelo o sea.. cátodo al borne positivo y ánodo al borne negativo de la válvula.
Cuando la válvula este funcionando, mide con el tester o determina cual borne esta a +24 y cual esta a prácticamente 0V. Ahí lo montas en paralelo como expliqué al comienzo.
Coloca un 1n4007 pero si te quedas corto o le pasa algo, usa un 1N5408
Por qué
if (Estado==Seleccion){
Serial.print("Etapa: ");
Serial.print(Estado);
Serial.print("Estado del sensor: ");
Serial.println(reading42);
}
if (Estado==Proceso){
Serial.print("Meta: ");
Serial.print(meta);
Serial.println(" Proceso");
}
if (Estado==Finalizado){
Serial.print("Etapa ");
Serial.print(Estado);
Serial.println(" Finalizado");
}
no está dentro de los case correspondientes de
switch (Estado) {
?
Para tener sentido, la variable Estado tendría que ser del mismo tipo que el enum (que por cierto no tiene tipo).
Tus case son demasiado pesados y propensos a errores de ámbito, pon lo que está dentro de cada uno en funciones (rutinas) que llamas desde los case.
switch (x) {
case a:
bla;
bla;
bla;
...
break;
case ...
}
por
void bla_bla_bla() {
bla;
bla;
bla;
...
}
...
switch (x) {
case a:
bla_bla_bla();
break;
case ...
Así es más ordenado y fácil de depurar.
Acá tienes algo un poco mejor organizado. Prueba a ver si funciona.
Usa la librería Bounce2 disponible en el gestor de librerías del IDE.
#include <LiquidCrystal.h>
#include <Bounce2.h> // Asegúrate de instalar esta librería desde el gestor de librerías
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);
// Definición de Estados
enum {Seleccion, Proceso, Finalizado, Pausado};
unsigned char Estado = Seleccion;
// Variables para Dobladora
int meta = 0;
int meta2 = 0;
int cuenta = 0;
// Pines
const int pin1 = 1;
const int pin13 = 13; // LED integrado usualmente
const int btnDiez = 32; // +10
const int btnCincuenta = 34; // +50
const int btnCien = 36; // +100
const int btnArranque = 22; // Arranque
const int btnParo = 24; // Paro
const int btnReset = 26; // Reset
const int sensor = 42; // Sensor
const int pulso = 48; // Salida Relevador/Valvula
// Creación de objetos Bounce
Bounce dbDiez = Bounce();
Bounce dbCincuenta = Bounce();
Bounce dbCien = Bounce();
Bounce dbArranque = Bounce();
Bounce dbParo = Bounce();
Bounce dbReset = Bounce();
Bounce dbSensor = Bounce();
// Intervalo de rebote en milisegundos
const int DEBOUNCE_INTERVAL = 25; // 25ms es buen estándar para botones humanos
const int SENSOR_INTERVAL = 5; // Menor tiempo para el sensor para no perder hojas rápidas
void setup() {
Serial.begin(9600);
Serial.println("Iniciando.");
lcd.begin(16, 2);
pinMode(pin13, OUTPUT);
pinMode(pin1, OUTPUT);
pinMode(pulso, OUTPUT);
// Configuración de botones con Bounce2
// Usamos attach(pin, INPUT) asumiendo que tienes resistencias pull-down externas.
// Si no tienes resistencias, usa INPUT_PULLUP y cambia la lógica.
dbDiez.attach(btnDiez, INPUT);
dbDiez.interval(DEBOUNCE_INTERVAL);
dbCincuenta.attach(btnCincuenta, INPUT);
dbCincuenta.interval(DEBOUNCE_INTERVAL);
dbCien.attach(btnCien, INPUT);
dbCien.interval(DEBOUNCE_INTERVAL);
dbArranque.attach(btnArranque, INPUT);
dbArranque.interval(DEBOUNCE_INTERVAL);
dbParo.attach(btnParo, INPUT);
dbParo.interval(DEBOUNCE_INTERVAL);
dbReset.attach(btnReset, INPUT);
dbReset.interval(DEBOUNCE_INTERVAL);
dbSensor.attach(sensor, INPUT);
dbSensor.interval(SENSOR_INTERVAL); // El sensor suele necesitar respuesta más rápida
// Mensaje inicial
lcd.clear();
lcd.print("LISTO");
delay(1000);
lcd.clear();
}
void loop() {
// 1. Actualizar todos los botones/sensores al inicio del loop
dbDiez.update();
dbCincuenta.update();
dbCien.update();
dbArranque.update();
dbParo.update();
dbReset.update();
dbSensor.update();
digitalWrite(pin13, LOW);
digitalWrite(pin1, LOW);
// Máquina de estados
switch (Estado) {
case Seleccion:
// --- Lógica de Botones (Usando .rose() que significa que pasó de LOW a HIGH) ---
if (dbDiez.rose()) {
meta += 10;
}
if (dbCincuenta.rose()) {
meta += 50;
}
if (dbCien.rose()) {
meta += 100;
}
if (dbReset.rose()) {
meta = 0;
lcd.clear();
}
if (dbArranque.rose()) {
if (meta > 0) {
meta2 = meta;
cuenta = 0; // Reiniciamos cuenta al arrancar
Estado = Proceso;
lcd.clear();
lcd.setCursor(3, 0);
lcd.print("ARRANQUE");
delay(1000);
lcd.clear();
}
}
// --- Actualización LCD ---
// (Se imprime siempre, idealmente solo debería imprimirse si cambia el valor para evitar parpadeo)
lcd.setCursor(0, 0);
lcd.print("META: "); // Espacios para limpiar residuos
lcd.setCursor(6, 0);
lcd.print(meta);
lcd.setCursor(0, 1);
lcd.print("Cuenta: ");
lcd.setCursor(8, 1);
lcd.print(cuenta);
break;
case Proceso:
// Imprimir info
lcd.setCursor(0, 0);
lcd.print("META: ");
lcd.print(meta);
lcd.setCursor(0, 1);
lcd.print("Cuenta: ");
lcd.print(cuenta);
// --- Lógica de Control ---
if (meta > 0) {
// Control de Válvula basado en estado actual del sensor
if (dbSensor.read() == LOW) {
digitalWrite(pulso, HIGH);
Serial.println(("PRENDO"));
} else {
digitalWrite(pulso, LOW);
Serial.println(("APAGO"));
}
// Conteo: Detectar Flanco de Bajada (Falling Edge) HIGH -> LOW
// Según tu código original: "if (anterior42!=reading42 and reading42==LOW)"
if (dbSensor.fell()) {
meta--;
cuenta++;
}
// Paro de emergencia
if (dbParo.read() == HIGH) { // Si se mantiene presionado o se presiona
Estado = Pausado;
digitalWrite(pulso, LOW); // Apagar válvula por seguridad
lcd.clear();
}
} else {
// Meta llegó a 0
Estado = Finalizado;
digitalWrite(pulso, LOW);
}
break;
case Finalizado:
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("IMPRESOS AGLEZCA");
digitalWrite(pulso, LOW);
delay(2000); // Damos tiempo para leer
lcd.clear();
// Reinicio automático según tu lógica original
// meta = meta2; // Si quieres que se repita la meta anterior automáticamente
// cuenta = 0;
// Estado = Proceso;
// NOTA: Normalmente iría a Selección, pero tu código original volvía a Proceso.
// Lo dejaré regresando a SELECCION para que sea más seguro, si quieres automático descomenta arriba.
meta = 0;
cuenta = 0;
Estado = Seleccion;
break;
case Pausado:
lcd.setCursor(6, 0);
lcd.print("PAUSA");
digitalWrite(pulso, LOW);
if (dbReset.rose()) {
lcd.clear();
meta = 0;
meta2 = 0;
cuenta = 0;
Estado = Seleccion;
Serial.println("Seleccion");
}
if (dbArranque.rose()) {
Serial.println("Proceso");
lcd.clear();
Estado = Proceso;
}
break;
}
}
No entiendo como funciona lo del sensor.
Cuando inicia el arranque, hay un sensor infrarojo que detecta la entrada del papel:
- Si no detecta papel, activa el relevador de la válvula de 24V que permite el paso de un flujo negativo (vacío).
- Un rotor permite el ingreso de la 1er hoja hasta abajo de la pila de alimentación.
- En cuanto el sensor detecta el paso de la 1er hoja, la válvula corta el suministro de vacío.
- Se repite el ciclo de trabajo.
- Cada que pasa 1 hoja por el sensor, una variable va sumando las hojas, y otra va restando de la Meta Total.
if (anterior42!=reading42 and reading42==LOW){ //Paro y arranque
lcd.clear();
meta=meta-1;
cuenta=cuenta+1;
anterior42=LOW;
}
Les explico más detalladamente.
-
Este es el rotor que le da ingreso al papel. Tiene una manguera de vacío que está conectada a una válvula de 24V.
-
El sensor es infrarojo, para detectar el paso de papel.
Al revisar la secuencia que les compartí, podrán ver que si el sensor no detecta hoja, pide la activación de la válvula para dejar pasar papel.
Una vez que pasa el papel, el sensor detecta y hace la suma hacia el conteo, y la resta hacia la meta.
Después de aislar los voltajes, se ve mucho mejor claridad en el LCD
Descubrí que el módulo Mosfet OKY3458 que se había instalado anteriormente para pasar la señal del sensor 5V a los 24V de la Tarjeta original de la máquina, me estaba generando ruido mediante los cables de alimentación del OKY3502-1 al módulo Mosfet.
Así que desconecté los cables del Mosfet (yo no utilizo esta tarjeta para nada), y le conecté un capacitor cerámico de 0.001 uF.
Mejoró bastante el comportamiento del LCD.
Aún así, cuando presiono el botón de paro, para pausar temporalmente el paso de papel, o después de muchos ciclos (hasta la 3er vuelta), el LCD baja la claridad o muestra a medias los mensajes.
Y ya después de muchos ciclos, termina por enviar lo siguiente:
Sigo creyendo que es un tema de ruido eléctrico.
Sin embargo, al colocar un eliminador de 24V a 3A por separado, no he logrado eliminar por completo los efectos en el LCD.
He colocado capacitores por todos lados.
- 2400uF en la alimentación de los 24V
- 1000uF en la salida a 5V.
- 1 cerámico de 0.001 uF en el relevador a 5 V.
- 1 cerámico de 0.001 uF en las conexiones del Mosfet.
Mejoró considerablemente el comportamiento del LCD, pero aún no puedo dejar este sistema trabajando, hasta garantizar que el LCD sea visible la mayor parte del tiempo.
Ese capacitor, así como lo has montado, inyecta más ruido que lo que filtra.
Suéldalo a la placa y quítale esas dos hermosas antenas (la verde y la amarilla).
Lo mismo para el electrolítico.
Desarma esas maravillosas bobinas que has hecho con los cables rojo, negro, negro/gris y cualquier otro rulo que haya, que también inyectan ruido.
Y acomoda un poco los cables, ese "plato de tallarines" es una antena gigante para los ruidos eléctricos. 
Estaba por decir exactamente lo mismo que @MaximoEsfuerzo, bellas y hermosas antenas para que todo se comporte como describes.
Aprende a usar plaquetas de desarrollo. Conexiones cortas. Los capacitores de desacople deben ser de 0.1uF no de 0.001uF.
Te dejo esto para que te sirva de guía.
Muchas gracias a los dos. Haré la placa de circuito impreso, y revisaré cómo se comporta el LCD.
Les agradezco nuevamente y les deseo un año nuevo próspero de abundante gozo y paz.
Saludos Cordiales.
Jorge.