No consigo medir micro Amperios

Buenas a todos,

estoy intentando medir microamperios con arduino, mediante la lectura del voltaje, el calculo de la resistencia y por tanto el de la intensidad, es decir la ley de Ohm, tengo el siguiente código hecho, pero el valor de la corriente en microamperios no cambia cuando el voltaje o la resistencia sí lo hacen:

float lectura;
float volt;
float corr;
float res;
float i= 0.001;

void setup() {
 // put your setup code here, to run once:
 Serial.begin(9600);
 pinMode(A0,INPUT);
}

void loop() {
 // put your main code here, to run repeatedly:
 lectura = analogRead(A0);
 volt = lectura /1023 * 5.0;
 res= (volt / i);
 corr = volt/res;
 //corri= corr *100000;
 //Serial.println(corr,5);
 Serial.println(corr,20);
  //Serial.println(corr,20);
delay (2000);
}

Destacar que la intensidad que aplico para medir la resistencia es de 1 mili Amperio... de verdad estoy hecho un lío y no sé por qué no funciona, ruego una ayudita.

Gracias a todos.

Estas haciendo mal el cálculo.
Fijate

res= (volt / i);
corr = volt/res;

calculas la resistencia en base a i que es constante
y luego la corriente en base a esa resistencia.
Obviamente te va a dar el valor de i.

Tienes que eliminar el calculo de resistencia porque es un valor conocido y constante (y es el que tienes que usar para calcular la corriente).

Saludos

PD: por favor pon el código como corresponde (ver Normas del foro, punto 7), es para tu beneficio

Además esto no tiene sentido

Serial.println(corr,20);

mas allá de otros errores en los tipos de variables empleados.
Una variable del tipo float, double tiene una mantisa de 7 digitos en todos los Arduinos salvo en el DUE donde tiene 8 bytes y ahi se se gana en precisión.
20 no tiene ningun sentido.

  int   Pin_de_medicion = 5; // Pin analogico 5
  int   R1 = 10580; // Cambiar por el valor de la resistencia conocida
  long  lectura; // Lectura en el pin analogico 5
  float Tension_de_trabajo = 5.10; // VCC 
  float Voltaje_R2; // Valor que calculamos
  float Resistencia; // Valor que calculamos
  float intensidad;
  
 // float gain= 6147;

  void setup()
{
  Serial.begin(9600);
Serial.println("Medición de resistencia:");
  Serial.println();
}

  void loop()
{
  // Leemos el valor en el pin A5
  lectura=0;
  for(int i=0;i<5;i++){
    lectura+=analogRead(Pin_de_medicion);
  }
  lectura=trunc(lectura/5);
  
  // Colculamos el voltaje en la resistencia desconocida
  Voltaje_R2=(Tension_de_trabajo/1023.0)*lectura;
  
  // Lo imprimimos en el Monitor Serie
  
  //Serial.print("Voltaje en R2: ");
  //Serial.print(Voltaje_R2,2);
  //Serial.println(" Voltios");
  
  //Calculamos la resistencia desconocida con las fórmulas
  // (V1/R1=V2/R2) y (V1=+5V-V2)
  Resistencia=R1*Voltaje_R2/(Tension_de_trabajo-Voltaje_R2);//+ gain;
  
  //Serial.print("La resistencia tiene ");
  //Serial.print(Resistencia,2);
  //Serial.println(" Ohm.");
 intensidad=(Voltaje_R2/Resistencia);
 //intensidad2= intensidad*20/20;
  Serial.print ((intensidad*1000000)*0.9-0.4,2);
   Serial.println();
  delay(1000);
}

Ante todo muchas gracias a todos.

Finalmente conseguí medir microamperios de manera muy precisa modificando un código encontrado en internet para medir resistencias.

Expongo el código por si puede servir a más gente.

Ahora mi pregunta es como desarrollar un GUI para el programa y que no sea todo por puerto serial, ¿dónde debo dirigirme o si alguien me puede echar una mano?

Gracias.

Moderador
Por favor edita tu post inicial usando etiquetas para el código, pensé en haberte enviado un privado pero revisando veo que no lo hice asi que tampoco puedo llamarte la atención al respecto pero si pedirte que corrijas tu falta.
Gracias

Vaya distracción la mía. Te había modificado el código para resolver tu problema y no lo envié.
Ten cuidado con los tipos de variable que usas.

Voltaje_R2=(Tension_de_trabajo/1023.0)*lectura;

lectura es entero y los demás son float. Por lo visto no tienes problemas, pero es bueno hacer a adecuación de los tipos de variables utilizadas.

Otra cosa es que la tensión de referencia que pones 5.1V nunca es la misma.
Existe una función que devuelve exactamente el valor de tensión que esta usando tu dispositivo y de ese modo mides mucho mas preciso. Te la dejo aquí y reemplaza Tensión_de_trabajo con este valor que es del tipo long.

Esta es una función hermosa que te dirá siempre el valor de Vref que estas usando sin tener que estar midiendo con tu tester.

uint32_t readVcc() {
  // Read 1.1V reference against AVcc
  // set the reference to Vcc and the measurement to the internal 1.1V reference
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
  ADMUX = _BV(MUX5) | _BV(MUX0);
#elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
  ADMUX = _BV(MUX3) | _BV(MUX2);
#else
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#endif

  delay(2); // Wait for Vref to settle
  ADCSRA |= _BV(ADSC); // Start conversion
  while (bit_is_set(ADCSRA, ADSC)); // measuring

  uint8_t low  = ADCL; // must read ADCL first - it then locks ADCH
  uint8_t high = ADCH; // unlocks both

  uint32_t result = (high << 8) | low;

  result = 1089952UL / result; // calibrated value
  return result; // Vcc in millivolts
}

Devuelve todo como un unsigned long o uint32_t no te asustes por la terminología.
Esto requiere de solo una medición. La medición es usando un buen tester cuanto mas preciso mejor pero de lo contrario usa el que tengas, el arduino siempre estará por debajo de un tester común. 10 bits son menos que 2000 cuetntas de un tester que lee hasta 1999 mientras arduino UNO/NANO/PRO Micro/Mega solo puede hasta 1024. Un DUE/ESP32/STM32/Teensy ya leen 12 bits. En general todos los ARM leen 12 bits o sea 4096 pasos. Con lo cual superas a un tester standard.
Poniendo el arduino en modo 1.1V usando AnalogReference() en 1.1 según lo indica el link. Mides entre GND y Vref y leeras supongamos 1.093 o si tienes un mejor tester 1.0926 entonces conviertes eso a uint32_t o sea unsigned long 1092600UL y modificas ese valor calibrado que indica la rutina que vale

result = 1089952UL / result;

El resultado será por ejemplo 5096 mV o sea tus aproximados 5.1
Todo lo que pongo son valores imaginados… debes calcular y medir los tuyos.

Si tienes dudas y lees inglés mira este hilo, donde discuten el tema. Solo lo pongo como referencia porque no encontraba la rutina link

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