Cálculo de capacitor de filtrado de señal para voltimetro

Scooter, no se a que te referis con la uart hardware, no la escuche nunca en arduino y la busque pero tampoco encontre. podrias explicarte un poco mas??
Son los pines TX y RX del arduino, los mismos pines por donde se carga el sketch al arduino.
Ejemplo de uso:
C:
void setup() {
  Serial.begin(9600); // inicio y configuro el puerto serie por hardware
}

void loop() {
    Serial.print(128); // envio el numero 128 por el puerto serie
    delay(1000); // mato el micro por un segundo     
}
 
Al puerto serie que está en D0 D1 normalmente, ese lleva hardware para hacer la comunicación. Si usas cualquier otropin consumes prácticamente el 100% de la cpu.
Habrán infinitas medidas pero la nueva solo vale un 10% o lo que tu creas
 
Son los pines TX y RX del arduino, los mismos pines por donde se carga el sketch al arduino.
Ejemplo de uso:
C:
void setup() {
  Serial.begin(9600); // inicio y configuro el puerto serie por hardware
}

void loop() {
    Serial.print(128); // envio el numero 128 por el puerto serie
    delay(1000); // mato el micro por un segundo   
}

Hola Fernando123, gracias por responder, Entendido!!

Al puerto serie que está en D0 D1 normalmente, ese lleva hardware para hacer la comunicación. Si usas cualquier otropin consumes prácticamente el 100% de la cpu.
Habrán infinitas medidas pero la nueva solo vale un 10% o lo que tu creas

Perfecto, voy a hacer un for para que cada 10 interrupciones envie un dato, sino voy a enviar demasiada informacion.
Que resolucion me recomendas usar para el flexitimer ?

Gracias a todos! voy a probarlo y muestro los resultados cuando termine
 
Última edición:
Juanma 2468, queria comentarte los resultados con el codigo que propusiste.

El problema está en que no trabajas con interrupciones del timer, sino que usas la instruccion delay(10) en la medición de tensión que lo unico que hace es frenarte tu programa sin poder hacer nada más, eso es nefasto para este tipo de cosas. Si usaras las interrupciones podrias hacer incluso hasta 100 muestras por segundo y aun asi no lo notarias en tu display. El software está bien, pero hay cosas para pulir y agregar en función de lo que Guidino Roberto te comento. Unas mejoras serían estas:
C:
float tension1()
{
       int i, Contador = 0;
       float TensionPromedio,TensionInstantanea,Tension = 0;

       if (TensionPromedio != 0) // Para cuando recien se inicia, el promedio es cero
       {
           for (i=0; i<=Num1; i++)
           {
               TensionInstantanea = (((analogRead(4) * 4.98)/ 1024)/ Req);
               if ((TensionPromedio*0,9<TensionInstantanea)&(TensionPromedio*1,1>TensionInstantanea)) // Descarto los valores que se apartan un 10% por arriba y por abajo del valor promedio
               {
                  Tension = Tension + TensionInstantanea;
                  Contador++;
               }
               else
                  Contador--; // Si descarto un valor, tengo que bajar en uno la variable contador para que el promedio de bien
               delay (10);
           }
       }
       else
       {
           for (i=0; i<=Num1; i++)
           {
            Tension = Tension + (((analogRead(4) * 4.98)/ 1024)/ Req); // Para obtener el primer promedio de tension
            delay (10);
           }
           Contador = Num1;
       }
       TensionPromedio = Tension / Contador;
  
       return TensionPromedio;
}


Utilice completamente esta funcion para leer los valores de tension y utilice el serial del arduino, evitando asi la libreria software serial.
Al comenzar las pruebas con una medicion continua resulta que da valores mas grandes de los que se encuentran en la entrada de tension del arduino y luego van bajando de 0,04V sin estabilizarse en algun valor. Luego probe en el vehiculo y tampoco pude conseguir un valor estable. Se te ocurre alguna otra solucion?

La proxima prueba que quiero realizar es con la libreria flexitimer2
 
Si, adjunto el codigo:

C:
float R1 = 10000;
float R2 = 3300;
float Req = R2/(R1+R2);
int Num1 = 10;   //cantidad de mediciones
float tension1();
char alerta;
int a = 0;
float Prom2 [5];
int j = 0;
float valalerta = 0;
char bat;

void setup()
{ 
  Serial.begin(9600);
}

void loop()
{
        float tensionf = tension1(); //busco el valor promediado de tension

        Prom2[j] = tensionf; //Se crea un promedio de 4 valores promediados de tension
                             //Para tomar un valor de alerta (esta forma quedo del metodo
                             //que utilizaba antes por no poder estabilizar valores)
        
        j = j + 1;

        if (j == 4)
        {
          for (int h; h<=4; h++)
          {
             valalerta = valalerta + Prom2[h];
          }
             valalerta = valalerta / 5;

          for (int w; w<=4; w++)
          {
            Prom2[w]= 0;
          }
         j = 0;
        }

//        Tensiones de bateria:
//
//        12,65 V     100%    BIEN
//        12,45 V     75%     BIEN
//        12,24 V     50%     REGULAR
//        12,06 V     25%     MAL
//        11,89 V     0%      MAL

// se le asigna una letra a cada seccion de tension y proceso en la aplicacion los mismos

        if (valalerta < 12.65)
        {
          bat = 'V';
        }
        if (valalerta < 12.45)
        {
          bat = 'W';
        }
        if (valalerta < 12.24)
        {
          bat = 'X';
        }
        if (valalerta < 12.06)
        {
          bat = 'Y';
        }
        if (valalerta < 11.86)
        {
          bat = 'Z';
        }

//esta seccion es un anti rebote para el valor de alarma
//sino al caer por debajo de un valor fijado, en cada ciclo
//una alarma haciendo miles de notificaciones   
    
        if (bat == 'Z' || bat == 'Y' || bat == 'X') //Bateria baja
        {
          a = a + 1; //antirebote
        }
            else
            {
              a = 0;
            }

        if (a==1) //Si bateria esta baja
        {
          alerta = 'A'; //Aviso con notificacion
          valalerta = 0;
        }
            else
            {
               alerta = 'B'; //No se notifica nada
            }
      
        Serial.print(tensionf);     //envio valor de tension
        Serial.print('L');          //separador
        Serial.print(alerta);       //valor de alerta bateria baja
        Serial.print('L');          //separador
        Serial.println(bat);        //letra para mostrar porcentaje de bateria aprox. dependiendo la tension
}


float tension1()
{
       int i, Cont = 0;
       float TenProm = 0,TenInst = 0,Tension = 0;

       if (TenProm != 0) // Para cuando recien se inicia, el promedio es cero
       {
           for (i=0; i<=Num1; i++)
           {
               TenInst = (((analogRead(4) * 4.98)/ 1024)/ Req);
               if ((TenProm*0,9<TenInst)&(TenProm*1,1>TenInst)) // Descarto los valores que se apartan un 10% por arriba y por abajo del valor promedio
               {
                  Tension = Tension + TenInst;
                  Cont++;
               }
               else
                  Cont--; // Si descarto un valor, tengo que bajar en uno la variable contador para que el promedio de bien
               delay (10);
           }
       }
       else
       {
           for (i=0; i<=Num1; i++)
           {
            Tension = Tension + (((analogRead(4) * 4.98)/ 1024)/ Req); // Para obtener el primer promedio de tension
            delay (10);
           }
           Cont = Num1;
       }
       TenProm = Tension / Cont;
  
       return TenProm;
}
 
Bien, probá este código a ver que tal va y luego nos contas. Si funciona te digo lo que hice. ;)
C:
float R1 = 10000;
float R2 = 3300;
float Req = R2/(R1+R2);
int Num1 = 10;   //cantidad de mediciones
float tension1();
char alerta;
int a = 0;
float Prom2 [5];
int j = 0;
float valalerta = 0;
char bat;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
        float tensionf = tension1(); //busco el valor promediado de tension

        Prom2[j] = tensionf; //Se crea un promedio de 4 valores promediados de tension
                             //Para tomar un valor de alerta (esta forma quedo del metodo
                             //que utilizaba antes por no poder estabilizar valores)
        
        j = j + 1;

        if (j == 4)
        {
          for (int h; h<=4; h++)
          {
             valalerta = valalerta + Prom2[h];
          }
             valalerta = valalerta / 4;
         j = 0;
        }

//        Tensiones de bateria:
//
//        12,65 V     100%    BIEN
//        12,45 V     75%     BIEN
//        12,24 V     50%     REGULAR
//        12,06 V     25%     MAL
//        11,89 V     0%      MAL

// se le asigna una letra a cada seccion de tension y proceso en la aplicacion los mismos

        if (valalerta < 12.65)
        {
          bat = 'V';
        }
        if (valalerta < 12.45)
        {
          bat = 'W';
        }
        if (valalerta < 12.24)
        {
          bat = 'X';
        }
        if (valalerta < 12.06)
        {
          bat = 'Y';
        }
        if (valalerta < 11.86)
        {
          bat = 'Z';
        }

//esta seccion es un anti rebote para el valor de alarma
//sino al caer por debajo de un valor fijado, en cada ciclo
//una alarma haciendo miles de notificaciones   
    
        if (bat == 'Z' || bat == 'Y' || bat == 'X') //Bateria baja
        {
          a = a + 1; //antirebote
        }
            else
            {
              a = 0;
            }

        if (a==1) //Si bateria esta baja
        {
          alerta = 'A'; //Aviso con notificacion
          valalerta = 0;
        }
            else
            {
               alerta = 'B'; //No se notifica nada
            }
      
        Serial.print(tensionf);     //envio valor de tension
        Serial.print('L');          //separador
        Serial.print(alerta);       //valor de alerta bateria baja
        Serial.print('L');          //separador
        Serial.println(bat);        //letra para mostrar porcentaje de bateria aprox. dependiendo la tension
}


float tension1()
{
       int i, Cont = 0;
       float TenProm = 0,TenInst = 0,Tension = 0;

       if (TenProm != 0) // Para cuando recien se inicia, el promedio es cero
       {
           for (i=0; i<=Num1; i++)
           {
               TenInst = (((analogRead(4) * 4.98)/ 1024)/ Req);
               if ((TenProm*0,9<TenInst)&(TenProm*1,1>TenInst)) // Descarto los valores que se apartan un 10% por arriba y por abajo del valor promedio
               {
                  Tension = Tension + TenInst;
                  Cont++;
               }
               else
                  Cont--; // Si descarto un valor, tengo que bajar en uno la variable contador para que el promedio de bien
               delay (10);
           }
       }
       else
       {
           for (i=0; i<=Num1; i++)
           {
            Tension = Tension + (((analogRead(4) * 4.98)/ 1024)/ Req); // Para obtener el primer promedio de tension
            delay (10);
           }
           Cont = Num1;
       }
       TenProm = Tension / Cont;
 
       return TenProm;
}
 
Hola juanma 2468, mil disculpas por la demora en responder.

El error de la caida de tension sigue estando, te adjunto lo que el arduino escribe en el puerto serial de la computadora. Es simplemente para que le des un vistazo al error, estuve mirando la electronica pero consta de dos resistencias y el regulador que esta entregando una tension establa sin problemas, no se me ocurre otro error ya que no es mas que eso jajaja.

Código:
y11.48LALZ
11.69LBLZ
11.88LBLZ
12.02LBLZ
12.14LBLZ
12.25LBLZ
12.33LBLZ
12.43LBLZ
12.48LBLZ
12.54LBLZ
12.60LBLZ
12.64LBLZ
12.68LBLZ
12.72LBLZ
12.73LBLZ
12.76LBLZ
12.77LBLZ
12.79LBLZ
12.80LBLZ
12.81LBLZ
12.81LBLZ
12.80LBLZ
12.82LBLZ
12.82LBLZ
12.81LBLZ
12.81LBLZ
12.80LBLZ
12.81LBLZ
12.81LBLZ
12.79LBLZ
12.81LBLZ
12.80LBLZ
12.80LBLZ
12.80LBLZ
12.79LBLZ
12.80LBLZ
12.78LBLZ
12.78LBLZ
12.78LBLZ
12.76LBLZ
12.77LBLZ
12.76LBLZ
12.74LBLZ
12.74LBLZ
12.71LBLZ
12.72LBLZ
12.71LBLZ
12.71LBLZ
12.71LBLZ
12.69LBLZ
12.69LBLZ
12.68LBLZ
12.68LBLZ
12.68LBLZ
12.66LBLZ
12.67LBLZ
12.66LBLZ
12.65LBLZ
12.66LBLZ
12.63LBLZ
12.64LBLZ
12.63LBLZ
12.62LBLZ
12.62LBLZ
12.61LBLZ
12.60LBLZ
12.59LBLZ
12.57LBLZ
12.58LBLZ
12.56LBLZ
12.56LBLZ
12.56LBLZ
12.54LBLZ
12.55LBLZ
12.54LBLZ
12.54LBLZ
12.53LBLZ
12.52LBLZ
12.53LBLZ
12.51LBLZ
12.51LBLZ
12.51LBLZ
12.50LBLZ
12.51LBLZ
12.49LBLZ
12.49LBLZ
12.48LBLZ
12.46LBLZ
12.46LBLZ
12.44LBLZ
12.43LBLZ
12.43LBLZ
12.41LBLZ
12.42LBLZ
12.41LBLZ
12.39LBLZ
12.39LBLZ
12.37LBLZ
12.38LBLZ
12.37LBLZ
12.35LBLZ
12.36LBLZ
12.35LBLZ
12.35LBLZ
12.33LBLZ
12.32LBLZ
12.32LBLZ
12.31LBLZ
12.30LBLZ
12.29LBLZ
12.28LBLZ
12.28LBLZ
12.26LBLZ
12.27LBLZ
12.25LBLZ
12.24LBLZ
12.24LBLZ
12.22LBLZ
12.22LBLZ
12.21LBLZ
12.20LBLZ
12.21LBLZ
12.20LBLZ
12.20LBLZ
12.19LBLZ
12.18LBLZ
12.18LBLZ
12.15LBLZ
12.16LBLZ
12.14LBLZ
12.14LBLZ
12.14LBLZ
12.11LBLZ
12.12LBLZ
12.11LBLZ
12.10LBLZ
12.10LBLZ
12.09LBLZ
12.10LBLZ
12.09LBLZ
12.08LBLZ
12.08LBLZ
12.07LBLZ
12.08LBLZ
12.06LBLZ
12.05LBLZ
12.04LBLZ
12.03LBLZ
12.04LBLZ
12.02LBLZ
12.02LBLZ
12.02LBLZ
12.00LBLZ
12.02LBLZ
11.99LBLZ
11.99LBLZ
11.98LBLZ
11.97LBLZ
11.97LBLZ
11.95LBLZ
11.95LBLZ
11.95LBLZ
11.92LBLZ
11.93LBLZ
11.91LBLZ
11.91LBLZ
11.90LBLZ
11.88LBLZ
11.89LBLZ
11.88LBLZ
11.88LBLZ
11.87LBLZ
11.86LBLZ
11.86LBLZ
11.85LBLZ
11.85LBLZ
11.85LBLZ
11.84LBLZ
11.84LBLZ
11.82LBLZ
11.82LBLZ
11.81LBLZ
11.80LBLZ
11.80LBLZ
11.78LBLZ
11.78LBLZ
11.78LBLZ
11.76LBLZ
11.76LBLZ
11.74LBLZ
11.74LBLZ
11.73LBLZ
11.71LBLZ
11.71LBLZ
11.70LBLZ
11.70LBLZ
11.68LBLZ
11.67LBLZ
11.67LBLZ
11.65LBLZ
11.65LBLZ
11.64LBLZ
11.63LBLZ
11.63LBLZ
11.61LBLZ
11.61LBLZ
11.61LBLZ
11.60LBLZ
11.61LBLZ
11.59LBLZ
11.59LBLZ
11.58LBLZ
11.56LBLZ
11.56LBLZ
11.55LBLZ
11.54LBLZ
11.54LBLZ
11.54LBLZ
11.54LBLZ
11.52LBLZ
11.53LBLZ
11.52LBLZ
11.50LBLZ
11.50LBLZ
11.49LBLZ
11.49LBLZ
11.49LBLZ
11.48LBLZ
11.48LBLZ
11.46LBLZ
11.47LBLZ
11.45LBLZ
11.43LBLZ
11.43LBLZ
11.42LBLZ
11.42LBLZ
11.41LBLZ
11.39LBLZ
11.39LBLZ
11.37LBLZ
11.37LBLZ
11.35LBLZ
11.34LBLZ
11.35LBLZ
11.33LBLZ
11.32LBLZ
11.32LBLZ
11.30LBLZ
11.30LBLZ
11.28LBLZ
11.28LBLZ
11.28LBLZ
11.27LBLZ
11.28LBLZ
11.26LBLZ
11.26LBLZ
11.25LBLZ
11.23LBLZ
11.24LBLZ
11.22LBLZ
11.22LBLZ
11.21LBLZ
11.19LBLZ
11.19LBLZ
11.18LBLZ
11.17LBLZ
11.17LBLZ
11.14LBLZ
11.15LBLZ
11.13LBLZ
11.12LBLZ
11.12LBLZ
11.10LBLZ
11.10LBLZ
11.09LBLZ
11.06LBLZ
11.05LBLZ
11.04LBLZ
11.04LBLZ
11.03LBLZ
11.02LBLZ
11.01LBLZ
10.99LBLZ
10.99LBLZ
10.98LBLZ
10.97LBLZ
10.96LBLZ
10.95LBLZ
10.95LBLZ
10.93LBLZ
10.92LBLZ
10.92LBLZ
10.90LBLZ
10.90LBLZ
10.89LBLZ
10.88LBLZ
10.88LBLZ
10.86LBLZ
10.86LBLZ
10.84LBLZ
10.83LBLZ
10.83LBLZ
10.82LBLZ
10.81LBLZ
10.80LBLZ
10.78LBLZ
10.77LBLZ
10.75LBLZ
10.75LBLZ
10.73LBLZ
10.71LBLZ
10.71LBLZ
10.69LBLZ
10.69LBLZ
10.68LBLZ
10.67LBLZ
10.67LBLZ
10.65LBLZ
10.65LBLZ
10.63LBLZ
10.63LBLZ
10.62LBLZ
10.60LBLZ
10.61LBLZ
10.60LBLZ
10.59LBLZ
10.58LBLZ
10.56LBLZ
10.56LBLZ
10.55LBLZ
10.54LBLZ
10.53LBLZ
10.52LBLZ
10.51LBLZ
10.50LBLZ
10.48LBLZ
10.48LBLZ
10.46LBLZ
10.46LBLZ
10.44LBLZ
10.42LBLZ
10.42LBLZ
10.40LBLZ
10.40LBLZ
10.37LBLZ
10.36LBLZ
10.36LBLZ
10.34LBLZ
10.33LBLZ
10.32LBLZ
10.31LBLZ
10.31LBLZ
10.29LBLZ
10.28LBLZ
10.26LBLZ
10.24LBLZ
10.25LBLZ
10.22LBLZ
10.22LBLZ
10.20LBLZ
10.19LBLZ
10.18LBLZ
10.16LBLZ
10.16LBLZ
10.15LBLZ
10.14LBLZ
10.14LBLZ
10.12LBLZ
10.11LBLZ
10.10LBLZ
10.08LBLZ
10.08LBLZ
10.05LBLZ
10.06LBLZ
10.04LBLZ
10.03LBLZ
10.03LBLZ
10.01LBLZ
10.02LBLZ
10.00LBLZ
9.98LBLZ
9.99LBLZ
9.97LBLZ
9.97LBLZ
9.96LBLZ
9.95LBLZ
9.95LBLZ
9.92LBLZ
9.92LBLZ
9.91LBLZ
9.90LBLZ
9.90LBLZ
9.88LBLZ
9.88LBLZ
9.87LBLZ
9.86LBLZ
9.87LBLZ
9.84LBLZ
9.85LBLZ
9.83LBLZ
9.82LBLZ
9.82LBLZ
9.80LBLZ
9.80LBLZ
9.79LBLZ
9.79LBLZ
9.79LBLZ
9.78LBLZ
9.78LBLZ
9.76LBLZ
9.76LBLZ
9.76LBLZ
9.74LBLZ
9.74LBLZ
9.72LBLZ
9.72LBLZ
9.72LBLZ
9.70LBLZ
9.70LBLZ
9.69LBLZ
9.69LBLZ
9.69LBLZ
9.67LBLZ
9.68LBLZ
9.66LBLZ
9.66LBLZ
9.65LBLZ
9.64LBLZ
9.64LBLZ
9.63LBLZ
9.63LBLZ
9.62LBLZ
9.60LBLZ
9.61LBLZ
9.59LBLZ
9.60LBLZ
9.59LBLZ
9.57LBLZ
9.58LBLZ
9.56LBLZ
9.57LBLZ
9.57LBLZ
9.56LBLZ
9.56LBLZ
9.54LBLZ
9.54LBLZ
9.54LBLZ
9.52LBLZ
9.53LBLZ
9.51LBLZ
9.52LBLZ
9.51LBLZ
9.51LBLZ
9.51LBLZ
9.50LBLZ
9.50LBLZ
9.49LBLZ
9.48LBLZ
9.47LBLZ
9.46LBLV
9.46LBLV
9.46LBLV
9.44LBLV
9.45LBLV
9.43LBLV
9.44LBLV
9.43LBLV
9.42LBLV
9.43LBLV
9.41LBLV
9.42LBLV

gracias por la ayuda! Espero tu respuesta
 
Hay algunos errores en la función tension() te los he corregido, prueba las modificaciones y comenta los resultados

C:
float tension1()
{
      int i; 
      float TenInst = 0.00 , Tension = 0.00;
      int Cont = 1;
      static float TenProm = 0.00 ;
      

       if (TenProm != 0.00)  // Para cuando recien se inicia, el promedio es cero
       {
           for (i=0; i<=Num1; i++)
           {
               TenInst = (((analogRead(4) * 4.98)/ 1024)/ Req);
               if  (((TenProm*0.9) < TenInst) & ((TenProm*1.1) > TenInst))  // Descarto los valores que se apartan un 10% por arriba y por abajo del valor promedio
               {
                  Tension = Tension + TenInst;
                  Cont++;
               }
              delay (10);
           }
       }
       else
       {
           for (i=0; i<Num1; i++)
           {
            Tension = Tension + (((analogRead(4) * 4.98)/ 1024)/ Req); // Para obtener el primer promedio de tension
            delay (10);
           }
           Cont = Num1;
       }
       TenProm = (TenProm + Tension) / Cont;
       return TenProm;
}
 
Creo que la modificación propuesta por fernando123 no es correcta. Ya que al final de la rutina está haciendo
TenProm = (TenProm + Tension) / Cont; con lo cual hace el promedio de los valores medidos y un valor promedio viejo, y lo divide por una cantidad inferior a la cantidad de terminos que realmente sumo.
De todas formas no dejes de probar el código, también yo me puedo equivocar.
Te propongo el siguiente código modificado en caso de no haber funcionado la propuesta de Fernando123.
C:
float R1 = 10000;
float R2 = 3300;
float Req = R2/(R1+R2);
int Num1 = 10;   //cantidad de mediciones
float tension1();
char alerta;
int a = 0;
float Prom2 [5];
int j = 0;
float aux_valalerta = 0,valalerta = 0;
char bat;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
        float tensionf = tension1(); //busco el valor promediado de tension

        Prom2[j] = tensionf; //Se crea un promedio de 4 valores promediados de tension
                             //Para tomar un valor de alerta (esta forma quedo del metodo
                             //que utilizaba antes por no poder estabilizar valores)
        
        j = j + 1;

        if (j == 4)
        {
          for (int h; h<=4; h++)
          {
             aux_valalerta = aux_valalerta + Prom2[h];
          }
          aux_valalerta = aux_valalerta / 4;
          valalerta = aux_valalerta;
          aux_valalerta = 0;
          j = 0;
        }

//        Tensiones de bateria:
//
//        12,65 V     100%    BIEN
//        12,45 V     75%     BIEN
//        12,24 V     50%     REGULAR
//        12,06 V     25%     MAL
//        11,89 V     0%      MAL

// se le asigna una letra a cada seccion de tension y proceso en la aplicacion los mismos

        if (valalerta < 12.65)
        {
          bat = 'V';
        }
        if (valalerta < 12.45)
        {
          bat = 'W';
        }
        if (valalerta < 12.24)
        {
          bat = 'X';
        }
        if (valalerta < 12.06)
        {
          bat = 'Y';
        }
        if (valalerta < 11.86)
        {
          bat = 'Z';
        }

//esta seccion es un anti rebote para el valor de alarma
//sino al caer por debajo de un valor fijado, en cada ciclo
//una alarma haciendo miles de notificaciones   
    
        if (bat == 'Z' || bat == 'Y' || bat == 'X') //Bateria baja
        {
          a = a + 1; //antirebote
        }
            else
            {
              a = 0;
            }

        if (a==1) //Si bateria esta baja
        {
          alerta = 'A'; //Aviso con notificacion
          valalerta = 0;
        }
            else
            {
               alerta = 'B'; //No se notifica nada
            }
      
        Serial.print(tensionf);     //envio valor de tension
        Serial.print('L');          //separador
        Serial.print(alerta);       //valor de alerta bateria baja
        Serial.print('L');          //separador
        Serial.println(bat);        //letra para mostrar porcentaje de bateria aprox. dependiendo la tension
}


float tension1()
{
       int i, Cont = 0;
       float TenProm = 0,TenInst = 0,Tension = 0;

       if (TenProm != 0) // Para cuando recien se inicia, el promedio es cero
       {
           for (i=0; i<=Num1; i++)
           {
               TenInst = (((analogRead(4) * 4.98)/ 1024)/ Req);
               if ((TenProm*0,9<TenInst)&(TenProm*1,1>TenInst)) // Descarto los valores que se apartan un 10% por arriba y por abajo del valor promedio
               {
                  Tension = Tension + TenInst;
                  Cont++;
               }
               else
                  Cont--; // Si descarto un valor, tengo que bajar en uno la variable contador para que el promedio de bien
               delay (10);
           }
       }
       else
       {
           for (i=0; i<=Num1; i++)
           {
            Tension = Tension + (((analogRead(4) * 4.98)/ 1024)/ Req); // Para obtener el primer promedio de tension
            delay (10);
           }
           Cont = Num1;
       }
       TenProm = Tension / Cont;
 
       return TenProm;
}
 
Creo que la modificación propuesta por fernando123 no es correcta. Ya que al final de la rutina está haciendo
TenProm = (TenProm + Tension) / Cont; con lo cual hace el promedio de los valores medidos y un valor promedio viejo, y lo divide por una cantidad inferior a la cantidad de terminos que realmente sumo.
Si bien no es la mejor forma de hacer y se puede implementar de otra manera, hay un pequeño detalle en el caso de que todas las muestras estén fuera del rango (+-10%) en el código original la salida seria 0 (cero), de la forma que implemente la salida mínima quedaría igual a la media anterior. En el calculo final tenemos
TenProm = TenProm + Tension / (numero de muestras validas + 1)
obs: el +1 esta contemplado con la inicialización de la variable "Cont = 1"

Tambien propongo el siguiente código con algunos comentarios entre las lineas:
C:
float tension1()
{
      int i , Cont = 0;
      float TenInst = 0.00 , Tension = 0.00;
      static float TenProm = 0.00 ;
      // con el static le decimos al compilador que queremos reusar el valor anterior de TenProm en la proxima ves que llamemos a la funcion
      // en el caso de no declararlo como static su valor siempre sera el valor que le asignemos en este caso 0 (cero)
     

       if (TenProm != 0.00)  // Para cuando recien se inicia, el promedio es cero
       {
           for (i=0; i<=Num1; i++)
           {
               TenInst = (((analogRead(4) * 4.98)/ 1024)/ Req);
               if  (((TenProm*0.9) < TenInst) & ((TenProm*1.1) > TenInst))  // Descarto los valores que se apartan un 10% por arriba y por abajo del valor promedio
               {
                  Tension = Tension + TenInst;
                  Cont++;
               }
              delay (10);
           }
       }
       else
       {
           for (i=0; i<Num1; i++)
           {
            Tension = Tension + (((analogRead(4) * 4.98)/ 1024)/ Req); // Para obtener el primer promedio de tension
            delay (10);
           }
           Cont = Num1;
       }
       if (Cont != 0){ //solo entraremos si tenemos como minimo una muestra valida
       TenProm = Tension / Cont;
       }
       return TenProm;
}
 
Hola gente!

Espero que después de tanto tiempo estén dispuestos a ayudarme con el problema de la tensión. Estuve con otra clase de problemas y no tuve tiempo para dedicarme a este, sin mas:

La ultima prueba que realice fue con el código que propuso Fernando123, al intentar realizar la medición en el vehículo no mantuvo un valor estable.
Me resulta raro que el código tenga un sentido lógico correcto y la medición sea tan inexacta, por lo tanto se me ocurre en intentar mejorar un poco el filtrado para el adc con amplificadores operacionales para intentar reducir este porcentaje de mediciones erróneas. Que les parece?
 

pandacba

Rocker Bear
Que vas a filtrar??? un filtro inpide el paso de algo, tenes ruido?
Queres una tensión estable pero la realidad es que no lo es, buscate un tester de aguja y fijate si estas se mueve continuamente, si lo hace es porque la tensión es así.
Por último cual es el fin de hacer esas mediciones?
Al principio pusiste que al promediar te daba un error grande, se te ocurrió tomar la media cuadrática?

Por otro lado jamás intentaste registrar esas variaciones para hacer un estudio del comportamiento de lo que quieres medir
Por otro lado para las velocidades de conversión te has fijado si el micro bajo la capa arduino es capaz de leer a esa velocidad?
Por eso, primeo debe hacerse un análisis, como grabando las lecturas tomadas con un osciloscopio para luego ver como se comporta la señal a medir, recién allí determinar el modo de ser medida.
Un conversor Adc de un micro solo hace eso convierte lo que recibe, pero si no es capaz de seguir la señal por las abruptas variaciones no te sirve y menos bajo la capa arduino.
Que tanto sabes de mediciones eléctricas? no creas que es poner un medidor y ya esta, es analizar la naturaleza de lo que se quiere medir y luego implementar un sistema para su medida.
Mediciones electrónicas es una materia universitaria que requiere quemarse las pestañas, y tener determinados conocimientos de matemáticas y física, las cosas simples no son problemáticas, pero ya vez como se complica y p peor si no se tienen los conocimientos necesarios.
Registra la señal a medir y publicala
 
Última edición:
Arriba