Go Down

Topic: millis y delay, funcionamiento incorrecto [SOLUCIONADO] (Read 474 times) previous topic - next topic

D5uu

Muy buenas a todos :) , estoy frustrado tras una semana tratando de resolver  un problema con Millis ya que la función delay funciona como debe, ahora quiero hacerlo funcionar con millis para que funcione el multiprocesos de arduino, pero tras intentar y buscar el error no me funciona el proyecto.
El proyecto consiste es una resistencia variada LDR (fotoresistencia) y este almacena en un array (NumA y NumB, son dos LDR).
Este debe almacenar en arrays la informacion hasta que el tiempo que se le determine (10000 = 10s).
Hay ejecute los dos pines (control y contro2, que son dos motores, obviamente conectadas a un transistor respectivo para su tipo un 2n2222a)  
Queridos compañeros agradezco su tiempo y lectura, soy demasiado verde en arduino por eso verán demasiadas cosas a reducir del código, que pensaba hacerlo al corregir el error.

Arduino uno

El funcionamiento es el deseado cuando esta con delay en funcionamiento, pero mi objetivo es que funcione con millis.
La desventaja que tiene delay es que tengo que esperar a que cargue el código denuevo (loops) para variar la resistencia y se ejecute, con millis no se ejecuta correctamente, se queda paralizado, y lo que quiero que haga es que en cualquier memento se puede variar los LDR, y cuando pase cierto tiempo se ejecuta toda la arrays.

Muchas gracias por su lectura :).
Code: [Select]
const int control = 9 ;
const int contro2 = 8 ;

const int indicador1 =10;
const int indicador2 =11;
const int indicador3 =12;
const int indicador4 =13;

long Tiempo = 10000;
long TiempoA = 0;
                
long  NumA[] ={0};
long NumB[] ={0};

int Rue = 0;
int Rue1 = 0;

int fin = 0;
int fin1 =0;



void setup()
  {    pinMode(control,  OUTPUT) ;
       pinMode(contro2, OUTPUT);
      
       pinMode(indicador1, OUTPUT);
       pinMode(indicador2, OUTPUT);
       Serial.begin(9800);  
      
  }

void loop()
  {
  
      
      unsigned long Cronometro = millis();
       int long n = analogRead(A1)/4;     // Las lecturas analogicas van hasta 1024 y no hasta 255
       int long m = analogRead(A2)/4;
       Serial.println(n);Serial.print(" LDR NUMERO A- ");
       Serial.println(m);Serial.print(" LDR NUMERO B- ");
        delay(200);
    
    
       if( 220 > n ){        
        NumA[Rue1] = 1;
        ++Rue1;

        }
        
        if(220 < n){
          NumA[Rue1] = 0;
          ++Rue1;
    
        }
      
      
      
       if(220 > m){
          NumB[Rue] = 1;
          ++Rue;
    
      }
        
        if(220 < m){
           NumB[Rue] = 0;
           ++Rue;
        
       }
      delay(Tiempo);
      if (Cronometro - TiempoA < Tiempo){
         TiempoA = Cronometro;
      digitalWrite(indicador1, HIGH);
      }
      else{
         digitalWrite(indicador1, LOW);
      }                                                        
                                                                                
      
    
    
  
          
      if(NumA[fin1] == 1){
        analogWrite (control, 255);
        digitalWrite (indicador4,HIGH);
        fin1=fin1+1;
      }
      else if(NumA[fin1] == 0){
        analogWrite (control, LOW);
        digitalWrite (indicador2,HIGH);
        fin1=fin1+1;
        }
      
        
      if(NumB[fin] == 1){
        analogWrite (contro2, 255);
        digitalWrite (indicador4,HIGH);
        fin=fin+1 ;
      }
      else if(NumB[fin] == 0){
        analogWrite (contro2,LOW);
        digitalWrite (indicador3,HIGH);
        fin=fin+1;
        }
      else{
       digitalWrite (indicador2,LOW);
       digitalWrite (indicador3,LOW);
      }
  }

surbyte

Estaba modificando tu código pero encuentro algunas cosas incompatibles

ejemplo:
Code: [Select]
unsigned long Cronometro = millis();

if (Cronometro - TiempoA < Tiempo){
         TiempoA = Cronometro;
      digitalWrite(indicador1, HIGH);
      }
      else{
         digitalWrite(indicador1, LOW);
      }       

en cada loop cargas Cronometro con el valor de millis(). Hasta ahi bien.
luego suponiendo que no uses el delay y lo reemplaces por millis() que es tu objetivo...
el código dice

Siempre que estemos dentro de 10 seg poner indicador1 en HIGH
pero como a cada momentos actualizas TiempoA con el valor de cronometro ocurre que esa condición se da siempre.

Que quieres hacer? Que el sistema arranque y luego de 10 seg encienda indicador 1 y luego que?
porque a continuación pones que lo apague y entonces no es posible hacer una cosa o la otra.

Otro error al final.

Vas haciendo comparaciones para

Code: [Select]
if(NumB[fin] == 1){
        analogWrite (contro2, 255);
        digitalWrite (indicador4,HIGH);
        fin=fin+1 ;
      }
      else if(NumB[fin] == 0){
        analogWrite (contro2,LOW);
        digitalWrite (indicador3,HIGH);
        fin=fin+1;
        }
      else{
       digitalWrite (indicador2,LOW);
       digitalWrite (indicador3,LOW);
      }

Numb[fin] que cargas con 0 o 1 según se ve antes, de modo que para que un else if == 0 si la única posiblidad es que sea 0
y aun mas contradictorio es que de este if(NumB[fin] == 0){} surge al final un nuevo else que pone indicador2 y 3 a LOW.

Asi que te voy a pedir primero y disculpa por el primer comentario:

1. Las normas dicen que hay que usar signos de puntuación y no escribir como si uno hablara sin puntos y comas. Así que acepta la crítica constructiva.
Edité tu comentario para poder entender bien que quieres decir, pero eso deberías hacerlo tu.

2. Intenta explicar que son indicador1 2 y 3 y cuando deben estar ON/OFF

3. Lo mismo con los arrays. Veo que puede crecer de modo importante en cantidad de elementos pero no queda claro con que objetivo terminas con un NumA[] de N elementos que para peor, no tiene limites, asi que puedes agotar la memoria RAM del Arduino si que llegue a un final.

Luego iremos viendo si hay mas consultas.



D5uu

#2
Sep 20, 2017, 04:49 pm Last Edit: Sep 20, 2017, 06:40 pm by D5uu
Surbyte muchas gracias por la ayuda, mil disculpas por las faltas de signo puntuación  en el mensaje.
deje puesto mal, unas parte del código ya explico,
Code: [Select]
if (Cronometro - TiempoA < Tiempo){
         TiempoA = Cronometro;
      digitalWrite(indicador1, HIGH);
      }
      else{
         digitalWrite(indicador1, LOW);
      }       

if (Cronometro - TiempoA < Tiempo){} hay adentro se posiciona el resto del código
Code: [Select]
if(NumA[fin1] == 1){
        analogWrite (control, 255);
        digitalWrite (indicador4,HIGH);
        fin1=fin1+1;
      }
      else if(NumA[fin1] == 0){
        analogWrite (control, LOW);
        digitalWrite (indicador2,HIGH);
        fin1=fin1+1;
        }
       
       
      if(NumB[fin] == 1){
        analogWrite (contro2, 255);
        digitalWrite (indicador4,HIGH);
        fin=fin+1 ;
      }
      else if(NumB[fin] == 0){
        analogWrite (contro2,LOW);
        digitalWrite (indicador3,HIGH);
        fin=fin+1;
        }
      else{
       digitalWrite (indicador2,LOW);
       digitalWrite (indicador3,LOW);
      }


Asi es,es contradictorio, también el consumo de ram es extenso por lo que, no causaba problemas cuando esta
con delay,hay que colocar una limitación de tiempo en la creación de las variables del array para solucionar el problema de la creación excesiva , al ultimo del código, necesito que  lee cada posiciones de los arrays , tome un camino engorroso para leer los arrays porque es la mas efectiva que se me ocurría, ahora el problema de ello es que estoy repitiendo el mismo código, y el else al final seria absurdo por lo que nunca se ejecutaría esa parte del final del código,

disculpas me he olvidado especificar los indicadores:
indicador1 me sirve para indicar cuando ya paso el tiempo y este se enciende
indicador2 me sirve cuando el arrays esta en 0, caso contrario se debe apagar, el motor1
indicador3 me sirve cuando el arrays esta en 0, caso contrario se debe apagar, el motor2
indicador4 me sirve para indicar que por lo menos uno de los arrays esta en 1


Ahora lo que tengo que solucionar primero, es colocar un contador que controle la creación de cada variable del array, para así evitar un consumo muy grande de la RAM.

surbyte

Bueno lo de los indicadores lo entiendo y no lo entiendo.
Generalmente todos usamos Serial.print para indicar que pasa y no leds para hacerlo pero si te pidieron que fuera asi, quien soy para discutirlo.
Es mucho mas práctico usar el monitor serie para indicar qué hace el programa.

Quote
ambién el consumo de ram es extenso por lo que, no causaba problemas cuando esta
con delay,hay que colocar una limitación de tiempo en la creación de las variables del array para solucionar el problema de la creación excesiva
No estoy de acuerdo. Jamas vi que un delay controle cuanta RAM vas a utilizar.
El limite lo pones tu restringiendo el tamaño comparando hasta donde llegan esos contadores. Será 100 será mas.. eso lo manejas tu y la cantidad de RAM disponible.

Igualmente no entiendo que quieres hacer o que debe hacer tu programa.
Dos LDR ok
La lectura que supere 220 es un 1 y la que no es un 0. Lo alamacenas en un array.

Para que almacenas muchos valores en un array si solo comparas el último? y en función de eso tomas acciónes?


D5uu

Disculpa, me exprese mal,el delay al detener todo, la creación de los arrays se detienen, por lo que si se activar los LDR no recibe información la placa, solo cuando termine el conteo del  delay, en ese momento se crean los valores de los LDR.
hay se activa los motores, por lo que los arrays solo  almacena los dígitos que se alcanza a procesar por el delay.



Para que almacenas muchos valores en un array si solo comparas el último? y en función de eso tomas acciónes?

el propósito del proyecto es que capte la luz , procese esta información, y despues de determinado tiempo (10s) ejecute la orden de rodar los motores, si almacena que el LDR estuvo activo 220 > n, guarda esa informacion, y la expresa despues del determinado tiempo   ( un LDR para cada Motor) cada vez que se activa n se crea 1 en la primer lugar, sigue al segundo puesto, si el segundo puesto no estuvo activo su valor sera 0

D5uu

mi edición actual
Code: [Select]

const int control = 9 ;
const int contro2 = 8 ;

const int indicador1 =10;
const int indicador2 =11;
const int indicador3 =12;
const int indicador4 =13;

unsigned long Tiempo = 10000;
unsigned long TiempoA = 0;



byte uno = 0;
byte dos = 0;


void setup()
  {    pinMode(control,  OUTPUT) ;
       pinMode(contro2, OUTPUT);
       
       pinMode(indicador1,OUTPUT);
       pinMode(indicador2,OUTPUT);
       pinMode(indicador3,OUTPUT);
       pinMode(indicador4,OUTPUT);
       Serial.begin(9600); 
  }

void loop()
  {
        unsigned long Cronometro  = millis();
       int n = analogRead(A1)/ 4;     // Las lecturas analogicas van hasta 1024 y no hasta 255
       int m = analogRead(A2)/ 4;
       Serial.println(n);Serial.print(" LDR NUMERO 1- ");
       Serial.println(m);Serial.print(" LDR NUMERO 2- ");
       Serial.println(uno);
       Serial.println(dos);
     //  Serial.println(TiempoA);
       delay(300);
       
       
       Serial.println(Cronometro - TiempoA);
       if (Cronometro - TiempoA < Tiempo)
       {
           if( 220 > n ){
          uno = 1;
        }
        if(220 > m){
          dos = 1;
        }
        digitalWrite (indicador4,HIGH);
        digitalWrite (indicador1,LOW);
       
       }
       
       else {
        TiempoA = Cronometro;
   
       digitalWrite (indicador4,LOW);
        digitalWrite (indicador1,HIGH);
       
       
        if (uno == 1){
        analogWrite (control,  255) ;
        digitalWrite (indicador3, HIGH);
       
        }
        else if(uno == 0){
        analogWrite (control,  LOW) ;
        digitalWrite (indicador3, LOW);
        }
        if (dos == 1){
        analogWrite (contro2, 255);
        digitalWrite (indicador2,HIGH);
       
         }
        else if (dos == 0){
         analogWrite (contro2, LOW);
         digitalWrite (indicador2,LOW);
       }
   
       }
       
       
       
       
       
       
 
  }

quisiera que me ayudaran por favor, como aplico la misma función de anti-rebote de los botones ,aplicando al  sensor ldr, para cuando se ilumine y se mantenga  solo genere una sola variable y no muchas en el mismo momento .

El segundo y ultimo problema ya para culminar es el uso de arrays correctamente, como debería usarla para almacenar este tipo de datos y que lo pueda leer para que los motores se encienda, si en el  arrays almacena  por ejemplo almacena  1.     1 == HIGH;   -enciende el motor.

Si esta en 1, se le determina un tiempo de encendido, el siguente termino es 0, se apaga el motor por el tiempo que se le determine, así sucesivamente, los LDR generan los valores de n y m. mientras no pasen de los 10s , que se le dio (Millis resuelto), si pasan de los 10s se ejecuta la acción de leer toda la expresión del arrays, para que el motor ejecute la acción de encenderse o apagarse


control = 9 ;                      Motor1          pin 9
contro2 = 8 ;                     Motor2          pin 8

indicador1 =10;                 led 1             pin 10
indicador2 =11;                 led 2             pin 11
indicador3 =12;                 led 3             pin 12
indicador4 =13;                 led 4             pin 13

Tiempo = 10000;         Tiempo que se le da para que almacene los valores del LDR
TiempoA = 0;              Tiempo a cambiar por el actual Tiempo



uno = 0;                                a sustituir por array Datos1
dos = 0;                                a sustituir por array Datos2

Datos1[] = {};                                  primer arrays a querer almacenar
Datos2[] = {};                                  segundo arrays a querer almacenar




Establecido todos los pines exceptuando el pin del LDR
Code: [Select]
void setup()
  {    pinMode(control,  OUTPUT) ;
       pinMode(contro2, OUTPUT);
       
       pinMode(indicador1,OUTPUT);
       pinMode(indicador2,OUTPUT);
       pinMode(indicador3,OUTPUT);
       pinMode(indicador4,OUTPUT);
       Serial.begin(9600); 
  }

 establecido el tiempo a comenzar (millis), estableciendo el pin del LDR , imprimir los valores de las variables que son n,m, uno, dos,TiempoA. Un delay para evitar exceso de texto impreso  del monitor serial.
Code: [Select]
void loop()
  {
        unsigned long Cronometro  = millis();
       int n = analogRead(A1)/ 4;     // Las lecturas analogicas van hasta 1024 y no hasta 255
       int m = analogRead(A2)/ 4;
       Serial.println(n);Serial.print(" LDR NUMERO 1- ");
       Serial.println(m);Serial.print(" LDR NUMERO 2- ");
       Serial.println(uno);
       Serial.println(dos);
     //  Serial.println(TiempoA);
       delay(300);


establesco que "if" (Cronometro - TiempoA es menor a Tiempo ), eso reescribe los valores de las variables uno y dos. el pin 4 se enciende para indicar que paso correctamente los 10s

Code: [Select]
Serial.println(Cronometro - TiempoA);
       if (Cronometro - TiempoA < Tiempo)
       {
           if( 220 > n ){
          uno = 1;
        }
        if(220 > m){
          dos = 1;
        }
        digitalWrite (indicador4,HIGH);
        digitalWrite (indicador1,LOW);
       
       }


entonces "else" lee los valores de las variables uno y dos, ejecuta si se enciende o se apaga, asimismo cada motor tiene un led que indica si un motor esta apagado o encendido, y para indicar que se esta ejecutando esta parte del código se enciende el led indicador 1

Code: [Select]
else {
        TiempoA = Cronometro;
   
       digitalWrite (indicador4,LOW);
        digitalWrite (indicador1,HIGH);
       
       
        if (uno == 1){
        analogWrite (control,  255) ;
        digitalWrite (indicador3, HIGH);    //led 3
       
        }
        else if(uno == 0){
        analogWrite (control,  LOW) ;
        digitalWrite (indicador3, LOW);
        }
        if (dos == 1){
        analogWrite (contro2, 255);
        digitalWrite (indicador2,HIGH);       //led 2
       
         }
        else if (dos == 0){
         analogWrite (contro2, LOW);
         digitalWrite (indicador2,LOW);               
       }

}

D5uu

#6
Sep 24, 2017, 09:58 pm Last Edit: Sep 24, 2017, 10:54 pm by D5uu
Funcionamiento final es el poder poder iluminar con una linterna los LDR, después de los 10 segundo se encienda un led que indique que se esta ejecutando la acción de lectura, una vez leyendo, se encienda los motores dependiendo donde se ilumino, y no se enciendo por el tiempo que se ilumina sino, por la cantidad de veces que recibió la luz. así, poder calibrar el rodaje y el tiempo que rueda para lograr un carrito que pueda completar un laberinto.
no se si se entienda lo que quiero hacer, Agradezco muchos a los user que están leyendo :) .









esta inspirado en un carrito seguidor de luz

D5uu

#7
Oct 03, 2017, 03:29 am Last Edit: Oct 03, 2017, 04:02 am by D5uu
Muy buenas, aquí mi actualización de mi código.



Code: [Select]
const int control = 9 ;
const int contro2 = 8 ;

const int indicador1 =10;
const int indicador2 =11;
const int indicador3 =12;
const int indicador4 =13;

unsigned long Tiempo = 10000;
long TiempoA = 0;

byte Datos1[99] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //esos "0" los agregue solo para testear que
byte Datos2[99] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //la lectura de los arrays es la correcta

int Menu ;

byte uno = 0;
byte dos = 0;

boolean estadoAnte1 ;
boolean estadoAnte2 ;

boolean result1  ;
boolean result2  ;

byte posicion = 0;
byte posicion2 = 0;
byte posicion3 = 0;
byte posicion4 = 0;

byte posicionD = 0;
byte posicionD2 = 0;

int n ;    
int m ;

int stast = false;
int lug = LOW;

void setup()
  {    pinMode(control,  OUTPUT) ;
       pinMode(contro2, OUTPUT);
      
       pinMode(indicador1,OUTPUT);
       pinMode(indicador2,OUTPUT);
       pinMode(indicador3,OUTPUT);
       pinMode(indicador4,OUTPUT);
       Serial.begin(9600);  
      
  }

void loop()
  {
      
     unsigned long   Cronometro  = millis();
     int n = analogRead(A1)/ 4;     // Las lecturas analogicas van hasta 1024 y no hasta 255
     int m = analogRead(A2)/ 4;
     Serial.print(" LDR NUMERO 1- ");Serial.println(n);
     Serial.print(" LDR NUMERO 2- ");Serial.println(m);
     Serial.print(" Datos 1 - "); Serial.println(Datos1 [posicion3] );
     Serial.print(" Datos 2 - ");Serial.println(Datos2 [posicion4] );
     //  Serial.println(TiempoA);
       Serial.print(" El Tiempo Transcurrido - "); Serial.println(Cronometro - TiempoA);
      
       delay(300);
      
      
        
      //  if (Tiempo >(Cronometro - TiempoA)   )
       if (Cronometro - TiempoA > Tiempo   ){
           TiempoA = Cronometro;
           if (stast == false)
               stast = true;
           else
               stast = false;
          
       }
      
      
        
       if (stast == true)
       {      
           funcion1();
      }
      if (stast == false)
      {
           funcion2();
      }

  }



  
         void funcion1()
    {
      
        Serial.println(posicion3);
        Serial.println(posicion4);
        digitalWrite (indicador4,LOW);
        digitalWrite (indicador1,HIGH);
        
        
        if (Datos1[posicion3] == 1){
        analogWrite (control,  255) ;
        digitalWrite (indicador3, HIGH);
        posicion3 ++;
        
        }
        else if(Datos1[posicion3] == 0){
        analogWrite (control,  LOW) ;
        digitalWrite (indicador3, LOW);
        posicion3 ++;
        }
        if (Datos2[posicion4] == 1){
        analogWrite (contro2, 255);
        digitalWrite (indicador2,HIGH);
        posicion4 ++;
         }
        else if (Datos2[posicion4] == 0){
         analogWrite (contro2, LOW);
         digitalWrite (indicador2,LOW);
         posicion4 ++;
       }
      
    }
   void funcion2()
   {

        
        Serial.println(posicion);
        Serial.println(posicion2);
        digitalWrite (indicador1,LOW);
        digitalWrite (indicador4,HIGH);

       if ( 220 > n ){                 //activación si 220 > LDR1
        
          Datos1[posicion] = 1;
          posicion ++;
        }
      //  estadoAnte1 = result1;
        if ( 220 < n ){
        
          Datos1[posicion] = 0;
          posicion ++;
        }
        if ( 220 > m ){                   // activación si 220 > LDR2
          
          Datos2 [posicion2] = 1;
          posicion2 ++;
        }
      //  estadoAnte2 = result2;
        if ( 220 < m ){                  

          Datos2 [posicion2] = 0;
          posicion2 ++;
        }
        //////////////////////////////////////////////////////////////
        if (posicion == 99){
          posicion = 0;
          posicion3 = 0;
        }
        if (posicion2 == 99){
          posicion2 = 0;
          posicion4 = 0;
        }
       }  


estoy muy alegre que ya me falte tan poco, teste TODO, y ya el problema es que la lectura de los LDR sin haber disminuido a 220 envía la señal de que se activa (cuya activación se debe solo si 220 > LDR ). En total, envía al arrays de que es "1" cuando aun no baja de los 220  ("1" si lee que ha estado presente la cantidad de luz indicada anteriormente).

surbyte establecí ya una cantidad fija de 99 Arrays máximos, a la cual por cada ronda provocada por el cambio de millis solo genera alrededor de 26 variables del arrays, y si llega a alcanzar los 99 se reinicia y lo vuelve a sobre escribir con valor "0" .


ahora ya todo el problema esta en la escritura del array . por medio del monitor serial saco a entender los valores que esta recibiendo por medio de los LDR .   :)

surbyte

Me da gusto que hayas progresado con tu propio esfuerzo.

Ahora una consulta : porque el limite es 220? 220x4 = 880 de 1023
No comprendo para que divides x 4 y luego comparas con 220 y no lo dejas como esta sin dividir y solo comparas con 880.
Eso no cambia lo que pasa.

Otra cosa que no comprendo es que tu array dice ser de 99 elementos pero inicializas 17. fue para que no se llene el código o tienes los 99 a 0?

Bueno he hecho algunos cambios que te pido compruebes.
en lugar de 220 ahora no dividimos lo leido del AD y queda como esta asi que las comparaciones son con 880 = 220x4

Algunos else if eliminados porque consultar por una condición y luego hacer un else de la opuesta es lo mismo que hacer

Code: [Select]
if (condicion)
   // true
else
   // false


no como tu haces

Code: [Select]
if (condicion)
   // true
else if (!condicion)
   // false



El código modificado:
Como veo que solo activas o desactivas el elemento del array, mejor que usar byte es usar bool y solo manejas bits con lo que podrias ampliar la capacidad de ambos arrays simplemente cambiando NUMERO_DATOS a otro valor.

Code: [Select]
const int control = 9 ;
const int contro2 = 8 ;

const int indicador1 =10;
const int indicador2 =11;
const int indicador3 =12;
const int indicador4 =13;

unsigned long TIEMPO = 10000;
unsigned long TiempoA = 0;

#define NUMERO_DATOS   99
bool Datos1[NUMERO_DATOS]; //esos "0" los agregue solo para testear que
bool Datos2[NUMERO_DATOS]; //la lectura de los arrays es la correcta

int Menu ;

byte uno = 0;
byte dos = 0;

boolean estadoAnte1 ;
boolean estadoAnte2 ;

boolean result1  ;
boolean result2  ;

byte posicion = 0;
byte posicion2 = 0;
byte posicion3 = 0;
byte posicion4 = 0;

byte posicionD = 0;
byte posicionD2 = 0;

int n ;     
int m ;

bool stast = false;
int lug = LOW;

void setup()
  {    pinMode(control,  OUTPUT) ;
       pinMode(contro2, OUTPUT);
       
       pinMode(indicador1,OUTPUT);
       pinMode(indicador2,OUTPUT);
       pinMode(indicador3,OUTPUT);
       pinMode(indicador4,OUTPUT);
       Serial.begin(9600); 
       memset(Datos1, false, sizeof(Datos1));
       memset(Datos2, false, sizeof(Datos2));
  }

void loop()  {     
   

    int n = analogRead(A1);     // Las lecturas analogicas van hasta 1024 y no hasta 255
    int m = analogRead(A2);
    Serial.print(" LDR NUMERO 1- ");Serial.println(n);
    Serial.print(" LDR NUMERO 2- ");Serial.println(m);
    Serial.print(" Datos 1 - ");    Serial.println(Datos1[posicion3]);
    Serial.print(" Datos 2 - ");    Serial.println(Datos2[posicion4]);
    //  Serial.println(TiempoA);
   
    unsigned long Cronometro = millis();
    Serial.print(" El Tiempo Transcurrido - "); Serial.println(Cronometro - TiempoA);
     
    delay(300);
     
    if (Cronometro - TiempoA > TIEMPO){
       stast = !stast;
       TiempoA = Cronometro;
    }   
     
    if (stast)       
         funcion1();
    else
         funcion2();
}

void funcion1()  {
     
    Serial.println(posicion3);
    Serial.println(posicion4);
    digitalWrite (indicador4,LOW);
    digitalWrite (indicador1,HIGH);

    if (Datos1[posicion3] == 1) {
        analogWrite (control,  255) ;
        digitalWrite (indicador3, HIGH);
        posicion3++;
    }
    else {
        analogWrite (control,  LOW) ;
        digitalWrite (indicador3, LOW);
        posicion3++;
    }
    if (Datos2[posicion4] == 1){
        analogWrite (contro2, 255);
        digitalWrite (indicador2,HIGH);
        posicion4++;
    }
    else {
        analogWrite (contro2, LOW);
        digitalWrite (indicador2,LOW);
        posicion4++;
    } 
}

void funcion2()   {
   
    Serial.println(posicion);
    Serial.println(posicion2);
    digitalWrite (indicador1,LOW);
    digitalWrite (indicador4,HIGH);

    if ( 880 > n ){                 //activación si 880 > LDR1
        Datos1[posicion++] = true;
    }
    else {    //  if ( 880 <= n ){
        Datos1[posicion++] = false;
    }

    if ( 880 > m ){                   // activación si 880 > LDR2
        Datos2[posicion2++] = true;
    }
    else  { // if ( 880 <= m ){                     
        Datos2[posicion2++] = false;
    }
    //////////////////////////////////////////////////////////////
    if (posicion >= NUMERO_DATOS){
        posicion = 0;
        posicion3 = 0;
    }
    if (posicion2 >= NUMERO_DATOS){
        posicion2 = 0;
        posicion4 = 0;
    }



Observemos como se comporta el tema de los valores que dices que no lo hacen correctamente.

D5uu

Buenas :D, ya encontre el problema, al inicio esta
Code: [Select]
const int control = 9 ;
const int contro2 = 8 ;

const int indicador1 =10;
const int indicador2 =11;
const int indicador3 =12;
const int indicador4 =13;

unsigned long TIEMPO = 10000;
unsigned long TiempoA = 0;

#define NUMERO_DATOS   99
bool Datos1[NUMERO_DATOS]; //esos "0" los agregue solo para testear que
bool Datos2[NUMERO_DATOS]; //la lectura de los arrays es la correcta

int Menu ;

byte uno = 0;
byte dos = 0;

boolean estadoAnte1 ;
boolean estadoAnte2 ;

boolean result1  ;
boolean result2  ;

byte posicion = 0;
byte posicion2 = 0;
byte posicion3 = 0;
byte posicion4 = 0;

byte posicionD = 0;
byte posicionD2 = 0;

int n ;     
int m ;

bool stast = false;
int lug = LOW;


la declaración al inicio de los LDR  son  el causante del problema, "n" y "m".


eliminándolo y pasando la declaración de las variables al la funcion2 (también el serialPrint que me muestra los resultados que recibo del los LDR).
 Logre que los resultados dejen de ser erróneos, este error provocaba que los resultados sean positivo aun cuando no se iluminaba la cantidad requerida  para encenderlo.
lo que me deja desconcertante el porque y la razón de ello.  es como que se reiniciaba los valores o lanzaba valores altos?

no encuentro mucha información de memset, lo estoy investigando por lo que no hay mucho en español sobre ello.

la declaración de 99 no es especifica solo es para evitar lo mismo, la excesiva cantidad de memoria.

hay el código con la pequeña modificación  .
Code: [Select]
const int control = 9 ;
const int contro2 = 8 ;

const int indicador1 =10;
const int indicador2 =11;
const int indicador3 =12;
const int indicador4 =13;

unsigned long TIEMPO = 10000;
unsigned long TiempoA = 0;

#define NUMERO_DATOS   99
bool Datos1[NUMERO_DATOS]; //esos "0" los agregue solo para testear que
bool Datos2[NUMERO_DATOS]; //la lectura de los arrays es la correcta

int Menu ;

byte uno = 0;
byte dos = 0;

boolean estadoAnte1 ;
boolean estadoAnte2 ;

boolean result1  ;
boolean result2  ;

byte posicion = 0;
byte posicion2 = 0;
byte posicion3 = 0;
byte posicion4 = 0;

byte posicionD = 0;
byte posicionD2 = 0;


bool stast = false;
int lug = LOW;

void setup()
  {    pinMode(control,  OUTPUT) ;
       pinMode(contro2, OUTPUT);
       
       pinMode(indicador1,OUTPUT);
       pinMode(indicador2,OUTPUT);
       pinMode(indicador3,OUTPUT);
       pinMode(indicador4,OUTPUT);
       Serial.begin(9600); 
       memset(Datos1, false, sizeof(Datos1));
       memset(Datos2, false, sizeof(Datos2));
  }

void loop()  {     
   

   
    Serial.print(" Datos 1 - ");    Serial.println(Datos1[posicion3]);
    Serial.print(" Datos 2 - ");    Serial.println(Datos2[posicion4]);
    //  Serial.println(TiempoA);
   
    unsigned long Cronometro = millis();
    Serial.print(" El Tiempo Transcurrido - "); Serial.println(Cronometro - TiempoA);
     
    delay(300);
     
    if (Cronometro - TiempoA > TIEMPO){
       stast = !stast;
       TiempoA = Cronometro;
    }   
     
    if (stast)       
         funcion1();
    else
         funcion2();
}

void funcion1()  {
     
    Serial.println(posicion3);
    Serial.println(posicion4);
    digitalWrite (indicador4,LOW);
    digitalWrite (indicador1,HIGH);

    if (Datos1[posicion3] == 1) {
        analogWrite (control,  255) ;     
        posicion3++;
    }
    else {
        analogWrite (control,  LOW) ;     
        posicion3++;
    }
    if (Datos2[posicion4] == 1){
        analogWrite (contro2, 255); 
        posicion4++;
    }
    else {
        analogWrite (contro2, LOW);
        posicion4++;
    } 
       posicion2 = 0; 
       posicion = 0;
}

void funcion2()   {
   
    Serial.println(posicion);
    Serial.println(posicion2);
    digitalWrite (indicador1,LOW);
    digitalWrite (indicador4,HIGH);
    int n = analogRead(A1);     // Las lecturas analogicas van hasta 1024 y no hasta 255
    int m = analogRead(A2);
    Serial.print(" LDR NUMERO 1- ");Serial.println(n);
    Serial.print(" LDR NUMERO 2- ");Serial.println(m);
    if ( 880 > n ){                 //activación si 880 > LDR1
        Datos1[posicion++] = true;
        digitalWrite (indicador3, HIGH);
    }
    else {    //  if ( 880 <= n ){
        Datos1[posicion++] = false;
        digitalWrite (indicador3, LOW);
    }

    if ( 880 > m ){                   // activación si 880 > LDR2
        Datos2[posicion2++] = true;
        digitalWrite (indicador2,HIGH);
    }
    else  { // if ( 880 <= m ){                     
        Datos2[posicion2++] = false;
        digitalWrite (indicador2,LOW);
    }
    posicion3 = 0;
    posicion4 = 0;


agradezco mucho de antemano,para arreglar lo ultimo.

                                                     posicion3 = 0 al final de la función 2
                                                     posicion4 = 0 al final de la función 2

                                                     posicion = 0 al final de la función 1
                                                     posicion2 = 0 al final de la función 1
esto es para que los arrays se reinicie cada vez que termine la lectura y volver desde cero todas las escrituras :D .



 Problema resuelto.  :D :D  :D :D









abriré un offtopic (demorare ...) para publicar mi carrito, esquemas codigo y una explicacion a detalle de como funciona, editare un poco el codigo para cambiar los intervalos de tiempo con un potenciometros y un boton para hacer que cambie a modo seguidor de luz (ya esta terminado todo, solo unifico  :) )      .

surbyte

Pero comprendiste la diferencia entre usar byte y bool?

Si solo te interesa el estado para que usar byte que son 8 bits u ocho estados posibles.

La gran diferencia es que pasas de casi 200 bytes de consumo de SRAM a solo 200 bits/8 = 25 bytes

Así que podrías multiplicar x 8 la longitud de tus arrays si fuera necesario.

D5uu

muchas gracias surbyte, si, bool es para almacenar datos binario, en cambio byte  almacena 8 .
Cuando comencé a escribir el código nunca pensaba en limitaciones de la ram .

disculpa las molestias, donde puedo conseguir una pagina que hable referente a memset?
 esta bien  si busco en paginas referente a c++ ?


surbyte

Todas tus dudas siempre las buscas asi en Google: Arduino memset o arduino Lo_que_quieras_encontrar

Go Up