Problema con la realización varias funciones en serie.

Hola, estoy en otra fase del proyecto del otro día, y me he bloqueado.. os comento el proyecto es el siguiente:

  • Usango una placa Arduino Mega, detectar el nivel de la semilla en nueve cajones mediante 9 sensores IR de obstáculos colocados a un nivel determinado. El comportamiento es el siguiente; si hay semilla (el sensor detecta obstáculo) y una luz amarilla permanece apagada. Por el contrario en cuanto un cajón disminuye su nivel de semilla y el sensor IR no detecta nada, se enciende el led del correspondiente cajón cuyo nivel es bajo.

He realizado una función por cada cajón. Empecé probando con una y funcionaba a la perfección, pero cuando he puesto las 9, una vez realiza la primera acción se queda "bloqueado", no responde a nada. No me importa que no midan los sensores simultáneamente y creo que según lo tengo puesto no le estoy pidiendo que los lea de seguido ¿no?.

Aquí os dejo el código:

//////////VARIABLES SENSORES//////////
//Nivel en cajón semilla
int cajon_1 = 2; //nivel de semilla del cajón asociado al pin 2
int cajon_2 = 3; //nivel de semilla del cajón asociado al pin
int cajon_3 = 4; //nivel de semilla del cajón asociado al pin
int cajon_4 = 5; //nivel de semilla del cajón asociado al pin
int cajon_5 = 6; //nivel de semilla del cajón asociado al pin
int cajon_6 = 7; //nivel de semilla del cajón asociado al pin
int cajon_7 = 8; //nivel de semilla del cajón asociado al pin
int cajon_8 = 9; //nivel de semilla del cajón asociado al pin
int cajon_9 = 10; //nivel de semilla del cajón asociado al pin

//Variables lectura
int valor_1 = 0; //Valor del cajón 1
int valor_2 = 0; 
int valor_3 = 0;
int valor_4 = 0;
int valor_5 = 0;
int valor_6 = 0;
int valor_7 = 0;
int valor_8 = 0;
int valor_9 = 0;
//////////FIN SENSORES//////////
//////////FIN VARIABLES SENSORES//////////

//////////BALIZAS/////////
int led_amarillo_1 = 22; //Led amarillo
int led_amarillo_2 = 23; //Led amarillo
int led_amarillo_3 = 24; //Led amarillo
int led_amarillo_4 = 25; //Led amarillo
int led_amarillo_5 = 26; //Led amarillo
int led_amarillo_6 = 27; //Led amarillo
int led_amarillo_7 = 28; //Led amarillo
int led_amarillo_8 = 29; //Led amarillo
int led_amarillo_9 = 30; //Led amarillo
//////////FIN BALIZAS/////////


void setup()
{
  //PINES INPUT
  pinMode(cajon_1, INPUT); 
  pinMode(cajon_2, INPUT);
  pinMode(cajon_3, INPUT);
  pinMode(cajon_4, INPUT);
  pinMode(cajon_5, INPUT);  
  pinMode(cajon_6, INPUT);
  pinMode(cajon_7, INPUT);
  pinMode(cajon_8, INPUT);
  pinMode(cajon_9, INPUT); 

 //PINES OUTPUT
  pinMode (led_amarillo_1, OUTPUT); //Led amarillo
  pinMode (led_amarillo_2, OUTPUT); //Led amarillo
  pinMode (led_amarillo_3, OUTPUT); //Led amarillo
  pinMode (led_amarillo_4, OUTPUT); //Led amarillo
  pinMode (led_amarillo_5, OUTPUT); //Led amarillo
  pinMode (led_amarillo_6, OUTPUT); //Led amarillo
  pinMode (led_amarillo_7, OUTPUT); //Led amarillo
  pinMode (led_amarillo_8, OUTPUT); //Led amarillo
  pinMode (led_amarillo_9, OUTPUT); //Led amarillo
  }

void loop()
{
nivel_semilla_1();
delay(100); 
nivel_semilla_2();
delay(100); 
nivel_semilla_3();
delay(100); 
nivel_semilla_4();
delay(100); 
nivel_semilla_5();
delay(100); 
nivel_semilla_6();
delay(100); 
nivel_semilla_7();
delay(100); 
nivel_semilla_8();
delay(100); 
nivel_semilla_9(); 
delay(100);             
}

//FUNCION NIVEL DE SEMILLA
//1
void nivel_semilla_1()
{   
  valor_1=digitalRead(cajon_1);  // Realiza la lectura Digital del pin 
  if(valor_1!=1)  
  {
    digitalWrite(led_amarillo_1, LOW);
    while(digitalRead(cajon_1)!=1) {
      delay(100);
      } 
  } 
  else {
    digitalWrite(led_amarillo_1,HIGH);   
  }
}  

//2
void nivel_semilla_2()
{   
  valor_2=digitalRead(cajon_2);  // Realiza la lectura Digital del pin 
  if(valor_2!=1)  
  {
    digitalWrite(led_amarillo_2, LOW);
    while(digitalRead(cajon_2)!=1) {
      delay(100);
      } 
  } 
  else {
    digitalWrite(led_amarillo_2,HIGH);   
  }
}  

//3
void nivel_semilla_3()
{   
  valor_3=digitalRead(cajon_3);  // Realiza la lectura Digital del pin 
  if(valor_3!=1)  
  {
    digitalWrite(led_amarillo_3, LOW);
    while(digitalRead(cajon_3)!=1) {
      delay(100);
      } 
  } 
  else {
    digitalWrite(led_amarillo_3,HIGH);   
  }
}  

//4
void nivel_semilla_4()
{   
  valor_4=digitalRead(cajon_4);  // Realiza la lectura Digital del pin 
  if(valor_4!=1)  
  {
    digitalWrite(led_amarillo_4, LOW);
    while(digitalRead(cajon_4)!=1) {
      delay(100);
      } 
  } 
  else {
    digitalWrite(led_amarillo_4,HIGH);   
  }
}  

//5
void nivel_semilla_5()
{   
  valor_5=digitalRead(cajon_5);  // Realiza la lectura Digital del pin 
  if(valor_5!=1)  
  {
    digitalWrite(led_amarillo_5, LOW);
    while(digitalRead(cajon_5)!=1) {
      delay(100);
      } 
  } 
  else {
    digitalWrite(led_amarillo_5,HIGH);   
  }
}  

//6
void nivel_semilla_6()
{   
  valor_6=digitalRead(cajon_6);  // Realiza la lectura Digital del pin 
  if(valor_6!=1)  
  {
    digitalWrite(led_amarillo_6, LOW);
    while(digitalRead(cajon_6)!=1) {
      delay(100);
      } 
  } 
  else {
    digitalWrite(led_amarillo_6,HIGH);   
  }
}  

//7
void nivel_semilla_7()
{   
  valor_7=digitalRead(cajon_7);  // Realiza la lectura Digital del pin 
  if(valor_7!=1)  
  {
    digitalWrite(led_amarillo_7, LOW);
    while(digitalRead(cajon_7)!=1) {
      delay(100);
      } 
  } 
  else {
    digitalWrite(led_amarillo_7,HIGH);   
  }
}  

//8
void nivel_semilla_8()
{   
  valor_8=digitalRead(cajon_8);  // Realiza la lectura Digital del pin 
  if(valor_8!=1)  
  {
    digitalWrite(led_amarillo_8, LOW);
    while(digitalRead(cajon_8)!=1) {
      delay(100);
      } 
  } 
  else {
    digitalWrite(led_amarillo_8,HIGH);   
  }
}  

//9
void nivel_semilla_9()
{   
  valor_9=digitalRead(cajon_9);  // Realiza la lectura Digital del pin
  if(valor_9!=1)  
  {
    digitalWrite(led_amarillo_9, LOW);
    while(digitalRead(cajon_9)!=1) {
      delay(100);
      } 
  } 
  else {
    digitalWrite(led_amarillo_9,HIGH);   
  }
}

Muchas gracias de antemano y un saludo,
Carlos

Los programas hechos con delay no se pueden unir (mira mi firma)
Tienes que lograr que cada programa funcione con Milis . Ejemplo.

Fijate que cuando lees un sensor, si está en 0, enciende el LED y por el while se queda esperando que el sensor pase a 1 y hasta que no cambie se queda ahí haciendo nada.
El delay() no tiene sentido. Está de más. En un lazo que de por si no hace nada le haces hacer nada... :wink:

Edito: Yo sacaría ese while.

Saludos

He modificado y simplificado tu código.
A ver como resulta:

//////////VARIABLES SENSORES//////////
//Nivel en cajón semilla
const byte cajon[9] = {2,3,4,5,6,7,8,9,10}; // nivel de semilla del cajón asociado al pin

//Variables lectura
int valor[9];

/////////BALIZAS/////////
const byte led_amarillo[9] = {22, 23, 24, 25, 26, 27, 28, 29, 30}; //Led amarillo 

void setup() {
  //PINES INPUT
  for (int i=0; i<9; i++) {
      pinMode(cajon[i], INPUT);
      pinMode (led_amarillo[i], OUTPUT); // Led amarillo
  }

 //PINES OUTPUT
  
  }

void loop() {
  for (int i=0; i<9; i++) {
      valor[i] = digitalRead(cajon[i]);  // Realiza la lectura Digital del pin
      if (valor[i]) 
          digitalWrite(led_amarillo[i], HIGH);
      else 
          digitalWrite(led_amarillo[i], LOW);   
  }
}

Aclaro, es algo que surge de lo que tu has puesto.
No tiene delay() asi que por favor no los agregues, porque esta vigilando los 8 semilleros a toda velocidad.
Si consideras que es muy rapido podemos considerar como modificarlo.
Puede mejorarse aún mas, haciendo que solo cambie leds cuando haya cambios y no siempre como lo hace ahora.
Ejemplo de esto, es que si un cajon esta en 1 en este código se pone 1 y mil veces nuevamente en 1 lo que es innecesario.
En cambio si chequeamos el valor nuevo vs el anterior y vemos si hay cambio solo podriamos cambiar cuando efectivamente hay cambio.

Perfecto, funciona a las mil maravillas. El tema de que solo realice el cambio comparando si hay cambios en la lectura ¿podría ser así a lo que te refieres no? Muchas gracias por la ayuda.

//////////VARIABLES SENSORES//////////
//Nivel en cajón semilla
const byte cajon[9] = {2,3,4,5,6,7,8,9,10}; // nivel de semilla del cajón asociado al pin

//Variables lectura
int valor[9];
int valorAnterior[9];
/////////BALIZAS/////////
const byte led_amarillo[9] = {22, 23, 24, 25, 26, 27, 28, 29, 30}; //Led amarillo

void setup() {
  //PINES INPUT
  for (int i=0; i<9; i++) {
      pinMode(cajon[i], INPUT);
      pinMode (led_amarillo[i], OUTPUT); // Led amarillo
  }

 //PINES OUTPUT
 
  }

void loop() {
  for (int i=0; i<9; i++) {
      valor[i] = digitalRead(cajon[i]);  // Realiza la lectura Digital del pin    
 if (valor[i] != valorAnterior[9]) ¨{
          digitalWrite(led_amarillo[i], HIGH);
}
      else {
          digitalWrite(led_amarillo[i], LOW);   
}
  }
}

Es por ahi pero no esta bien.
Si comparas valor debes hacer con valorAnterior y en cada cambio debes guarda el valor en valorAnterior
*_</em> <em><em>*void loop() {   for (int i=0; i<9; i++) {       valorAnterior[i] = valor[i];      // Guardo el valor anterior       valor[i] = digitalRead(cajon[i]);  // Realiza la lectura Digital del pin       if (valor[i] != valorAnterior[i])) {           if (valor[i])               digitalWrite(led_amarillo[i], HIGH);           else               digitalWrite(led_amarillo[i], LOW);        }   } }*</em></em> <em>_*
Con lo cual se debe asegurar que el valorAnterior[] sea el opuesto al estado normal del semillero.
Esto es para que en la primer barrida SI o SI se establezcan condiciones para los led_amarillo[]
Eso se logra poniendo valorAnterior[] en todos sus elementos a 1.
Una sugerencia sería
*_</em> <em><em>*void setup() {   //PINES INPUT   for (int i=0; i<9; i++) {       pinMode(cajon[i], INPUT);       pinMode (led_amarillo[i], OUTPUT); // Led amarillo       valorAnterior[i] = 1;   } // continua el setup*</em></em> <em>_*

Vale perfecto, ya está operativo. Un millón de gracias, cada día voy aprendiendo algo nuevo y rellenando los huecos que no sé jejejeje. Dejo el código completo por si le es de utilidad a alguien en algún proyecto:

/*El siguiente código, realiza la lectura del nivel de semilla en los 9 cajones de la máquina de sembrar. Si la semilla
 * supera el umbral del sensor, el led indicativo de tal cajón permanecerá apagado. Por el contrario, si el nivel de 
 * semilla cae por debajo del nivel del sensor, se encenderá un led indicativo de ese cajón.
 */

//////////VARIABLES SENSORES//////////
//Nivel en cajón semilla
const byte cajon[9] = {2,3,4,5,6,7,8,9,10}; // nivel de semilla del cajón asociado al pin

//Variables lectura
int valor[9];
int valorAnterior[9];
/////////BALIZAS/////////
const byte led_amarillo[9] = {14, 15, 16, 17, 18, 19, 20, 21, 22}; //Led amarillo

void setup() {
  //PINES INPUT
  for (int i=0; i<9; i++) {
      pinMode(cajon[i], INPUT);
      pinMode (led_amarillo[i], OUTPUT); // Led amarillo
      valorAnterior[i] = 1;
  }
}

void loop() {
  for (int i=0; i<9; i++) {
      valorAnterior[i] = valor[i];       // Guardo el valor anterior
      valor[i] = digitalRead(cajon[i]);  // Realiza la lectura Digital del pin
      if (valor[i] != valorAnterior[i]) {
          if (valor[i]){
              digitalWrite(led_amarillo[i], HIGH);
          }
          else{
              digitalWrite(led_amarillo[i], LOW); 
          }  
      }
  }
}

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