Problemas con la condicion if y el max_7219

hola este es mi primer post y espero ser mas un aporte que estar molestando jajaja,
tengo un problema, les cuento, estoy trabajando en un proyecto que consiste en 4 entradas de 0-24v o seria 0-1 en binario que hacen una combinación que indicarían que piso esta el ascensor (adjunto imagen)

estoy usando las condiciones if para cada caso de ubicación de piso, lo cual estas combinaciones la estoy llevando a mostrar en dos matriz max7219 8*8, el problema ocurre cuando lo cargo al arduino, la matriz cambia aleatoriamente a los numeros que he programado y no logro arreglar ese problema, ademas de que los led de la matriz parpadean y no mantienen la intensidad del brillo que las configure, cabe mencionar que hice el test para saber si las matriz estan operativas


#include "LedControl.h" 		// incluye libreria LedControl

LedControl lc=LedControl(11,13,10,2);	// crea objeto

byte menos[8]= {				// array que contiene todos los elementos de las
  B00000000,				// filas necesarias por mostrar el digito uno
  B00000000,
  B00000000,
  B01111110,
  B00000000,
  B00000000,
  B00000000,
  B00000000
};

byte cero[8]= {				// array que contiene todos los elementos de las
  B00111000,				// filas necesarias por mostrar el digito cero
  B01000100,
  B01000100,
  B01000100,
  B01000100,
  B01000100,
  B01000100,
  B00111000
};

byte uno[8]= {				// array que contiene todos los elementos de las
  B00010000,				// filas necesarias por mostrar el digito uno
  B00110000,
  B00010000,
  B00010000,
  B00010000,
  B00010000,
  B00010000,
  B00111000
};

byte dos[8]= {				// array que contiene todos los elementos de las
  B00111000,				// filas necesarias por mostrar el digito dos
  B01000100,
  B00000100,
  B00000100,
  B00001000,
  B00010000,
  B00100000,
  B01111100
};

byte tres[8]= {				// array que contiene todos los elementos de las
  B00111000,				// filas necesarias por mostrar el digito tres
  B01000100,
  B00000100,
  B00011000,
  B00000100,
  B00000100,
  B01000100,
  B00111000
};

byte cuatro[8]= {			// array que contiene todos los elementos de las
  B00001000,				// filas necesarias por mostrar el digito cuatro
  B00011000,
  B00101000,
  B01001000,
  B01001000,
  B01111100,
  B00001000,
  B00001000
};

byte cinco[8]= {			// array que contiene todos los elementos de las
  B01111100,				// filas necesarias por mostrar el digito cinco
  B01000000,
  B01000000,
  B01111000,
  B00000100,
  B00000100,
  B01000100,
  B00111000
};

byte seis[8]= {				// array que contiene todos los elementos de las
  B00111000,				// filas necesarias por mostrar el digito seis
  B01000100,
  B01000000,
  B01111000,
  B01000100,
  B01000100,
  B01000100,
  B00111000
};

byte siete[8]= {			// array que contiene todos los elementos de las
  B01111100,				// filas necesarias por mostrar el digito siete
  B00000100,
  B00000100,
  B00001000,
  B00010000,
  B00100000,
  B00100000,
  B00100000
};

byte ocho[8]= {				// array que contiene todos los elementos de las
  B00111000,				// filas necesarias por mostrar el digito ocho
  B01000100,
  B01000100,
  B00111000,
  B01000100,
  B01000100,
  B01000100,
  B00111000
};

byte nueve[8]= {			// array que contiene todos los elementos de las
  B00111000,				// filas necesarias por mostrar el digito nueve
  B01000100,
  B01000100,
  B01000100,
  B00111100,
  B00000100,
  B01000100,
  B00111000
};

int A=2;
int B=3;
int C=4;
int D=5;

void setup() {
  //Matriz 1
  lc.shutdown(0,false);			// enciende la matriz
  lc.setIntensity(0,4);			// establece brillo
  //Matriz 2
  lc.shutdown(1,false);			// enciende la matriz
  lc.setIntensity(1,4);			// establece brillo

  //Estos pines es de las 4 entradas binarias
  pinMode (A, INPUT);
  pinMode (B, INPUT);
  pinMode (C, INPUT);
  pinMode (D, INPUT);
}

void loop(){
  
  //piso -1  
  if(digitalRead(A) == HIGH && digitalRead(B) == LOW && digitalRead(C) == LOW && digitalRead(D) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(1,i,menos[i]);		// establece fila con valor de array cero en misma posicion
    lc.setRow(0,i,uno[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
//piso 1
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(0,i,dos[i]);		// establece fila con valor de array cero en misma posicion
  }
  }

 //piso 2 
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(0,i,dos[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
//piso 3
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(0,i,tres[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
//piso 4
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(0,i,cuatro[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
//piso 5
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(0,i,cinco[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
//piso 6
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(0,i,seis[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
//piso 7
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(0,i,siete[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
//piso 8
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(0,i,ocho[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
 //piso 9 
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(0,i,nueve[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
//piso 10
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(1,i,uno[i]);		// establece fila con valor de array cero en misma posicion
    lc.setRow(0,i,cero[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
//piso 11
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(1,i,uno[i]);		// establece fila con valor de array cero en misma posicion
    lc.setRow(0,i,uno[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
//piso 12
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(1,i,uno[i]);		// establece fila con valor de array cero en misma posicion
    lc.setRow(0,i,dos[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
//piso 13
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(1,i,uno[i]);		// establece fila con valor de array cero en misma posicion
    lc.setRow(0,i,tres[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
// piso 14
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
  for (int i = 0; i < 8; i++)  		// bucle itera 8 veces por el array
  {
    lc.setRow(1,i,uno[i]);		// establece fila con valor de array cero en misma posicion
    lc.setRow(0,i,cuatro[i]);		// establece fila con valor de array cero en misma posicion
  }
  }
}



alguna sugerencia como hacerlo funcionar?

Su publicacion se MUEVE a su ubicacion actual ya que es mas adecuada.

¿A qué están conectadas las entradas?
Si están conectadas a interruptores o relés, ¿tienen resistencias a masa para fijar el estado bajo (o a 5V para fijar el estado alto) cuando los mismos están abiertos?

Las tengo conectadas, a la salida de voltaje 3.3v del mismo arduino(solo para probar si funcionaba el codigo, ya que en la practica ira conectadas a las entradas de 24v) , atraves de un spst de conmutadores dip x4, sin resistencia.adjunto imagen

y link del video de como se vuelve loca la matriz sin darle señal por los INPUT

Esto que supuestamente va a las entradas como esta hecho?
Esquema por favor, a mano alzada, no tiene que ser nada profesional, solo algo que se entienda!
Tienes divisores resistivos, tienes zener con R en serie, eso queremos ver.

Este el el circuito en la practica, donde las entradas INPUT es suministradas por el ascensor

Esta es el circuito, donde las entradas INPUT es suministradas por el arduino en su puerto 3,3v


Este caso es el que me da problemas, ya que en la practica aun no lo hemos probado.

Era lo que imaginaba...

Cuando cierras el contacto pones el pin en alto con los 3.3V (por cierto puedes enviar directamente 5V) pero cuando el contacto está abierto ¿qué nivel hay definido en el pin?
Ninguno, entrada "al aire" leyendo ruido.

Debes poner una resistencia de 10k a masa en cada uno de los 4 pines de entrada.

sigue poniendo números aleatorios.

cuando defines una entrada de este modo debes acompañarla de una R sea a VCC pullup o a GND pulldown?
image

No tienes nada entonces el ruido es consecuencia de dicha ausencia.
Ahora.. ojo, todo bien con lo que estas haciendo con el UNO y no entiendo porque usas 3.3V cuando el UNO trabaja con 5V. Pero ese es otro tema.
Cuidado a la hora de conectarlo a los 24V aunque aun falta.

1 Like

Este es el problema por el que "la matriz cambia aleatoriamente", mira lo que programaste

//piso -1  
  if(digitalRead(A) == HIGH && digitalRead(B) == LOW && digitalRead(C) == LOW && digitalRead(D) == LOW ) {
//piso 1
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
//piso 2 
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
//piso 3
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
//piso 4
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
//piso 5
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
//piso 6
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
//piso 7
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
//piso 8
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
 //piso 9 
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
//piso 10
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
//piso 11
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
//piso 12
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
//piso 13
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {
// piso 14
  if(digitalRead(2) == HIGH && digitalRead(3) == LOW && digitalRead(4) == LOW && digitalRead(5) == LOW ) {

Solo hiciste la combinación de entradas para el "-1" y se repite para todos los pisos, por eso muestra... todos los pisos.
Lo hace tan rápido que parecen números aleatorios pero en realidad es toda la secuencia en un ciclo continuo. :man_facepalming:t2:

Deberías haber hecho así

//piso -1  
  if(digitalRead(A) == HIGH && digitalRead(B) == LOW && digitalRead(C) == LOW && digitalRead(D) == LOW ) {
//piso 1
  if(digitalRead(A) == HIGH && digitalRead(B) == HIGH && digitalRead(4c) == LOW && digitalRead(D) == LOW ) {
//piso 2 
  if(digitalRead(A) == LOW && digitalRead(B) == HIGH && digitalRead(4c) == LOW && digitalRead(D) == LOW ) {
//piso 3
  if(digitalRead(A) == LOW && digitalRead(B) == HIGH && digitalRead(4c) == HIGH && digitalRead(D) == LOW ) {
...etc.
1 Like

Muchas gracias por ayudarme en este caso, gracias a tu código pude encontrar el error, enserio muchas gracias, pero en este proyecto no se ocupa el código binario a decimal, sino es una combinación de voltaje altos y bajos nada mas, pero aun así me ayudaste a solucionarlo, y fui capaz de programarlo bien. Ahora mi otra consulta es que tengo en las entradas 24v que en el Arduino no los acepta ya que excede el limite, tendré que poner una resistencia de 150 ohm para llegar lo mas cercano a 5v a los INPUT?

Tienes varias opciones una de las mejores es usar un optacoplador x cada entrada para evitar problemas.
image
Algo asi por ejemplo, aunque hay muchas variantes. Los 24V accionan un led y este LED actúa sobre un fototransitor aislado y entrega los niveles ALTO, BAJO que corresponda. Puede que sea inversor o no inversor.

Otro metodo es con un zener de 5.1V y una R en serie. Los 24V caerán en la R y el zener entregará aprox 5V en la entrada del Arduino.
image
En este ejemplo
R1 es 1kOhm
R2 es 270 Ohm
R3 es 4.7kOhm (pulldown resistor)

O lo reduces a algo asi de simple

image

Por ultimo un divosor resistivo 24V a 5V.

Con R1 = 22k y R2 = 5.6k obtienes 4.8V a la salida. con eso estarás bien.

1 Like

Todo es binario en un microprocesador y justamente es una combinación de voltajes altos y bajos.

Saludos

PD: Y es cierto, tu aplicación no usa binario codificado a decimal, usa una variación de codificación de Gray a decimal.

1 Like

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.