Instituto Politécnico Nacional
Unidad Profesional Interdisciplinaria de Biotecnología
Unidad de Aprendizaje: Electroquímica II
Sensor Condictimetrico
Integrantes:
Gutiérrez Morales Airy Axel
Hernández Salgado Paola
Profesor:
Velia Ascencio Palmira
Fecha de entrega:
16 de diciembre de 2024
Introducción
El multímetro es un instrumento que permite medir directamente magnitudes eléctricas activas como corrientes
y diferencia de potenciales o pasivas como resistencias, capacidades, pueden realizarse para corriente continua
o alterna.
Su funcionamiento se basa en la utilización de un galvanómetro que se emplea para todas las mediciones, para
medir cada una de las magnitudes eléctricas, el galvanómetro se debe completar con un determinado circuito
eléctrico que dependerá también de dos características del galvanómetro: la resistencia interna (Ri) y la inversa
de la sensibilidad. La cual es la intensidad que, aplicada directamente a los bornes del galvanómetro, hace que
la aguja llegue al fondo de escala.
Para realizar el multímetro se va a ocupar:
• 1 PCB
• 1 chip ATmega328p AU
• 1 pantalla OLED i2c
• 1 ADS1115 ADC
• 1 amplificador ACS712
• 4 interruptores giratorios
• 1 zumbador SMD
• 1 amplificador operacional LMC7101AIM5X
• 1 cristal de 16MHz
• Estuche para multímetro 3D
• 1 interruptor deslizante
• 1 interruptor deslizante doble
• 1 TP4056 IC
• 1 DW01A
• 1 FS8205A
• 1 LiPo 3,7
• 1 convertidor de refuerzo
• 1 rectificador MB8S
• 1 USB-MICRO-B
• 2 pulsadores SMD
• Par de conectores de bala
• 2 diodos FR104W o 1N4148
• Resistencias 0402
• 1 condensador 0402
• 1 condensador 1206 de 22 uF
• 2 condensadores 0603 de 1uF
• 1 condensador 0805 de 10 Uf
• 2 LED 0603
• 1 programador FTDI
Ocupando los siguientes esquemas
Para el interruptor giratorio, la entrada de la sonda se divide en 4 salidas para voltaje, resistencia,
capacitancia e inductancia. La corriente se mide por separado con un interruptor deslizante (S4.1). El primer
bloque de medición es el de voltaje. Teniendo la entrada de las sondas conectadas al rectificador de puente
completo y luego tenemos un capacitor para poder almacenar el voltaje para el modo CA. Luego, ese
voltaje se conecta a algunos divisores y la salida de los divisores al ADC0 y ADC1 del ADS1115, por lo que
de esta manera podemos medir en modo diferencial y también podemos medir voltajes negativos.
Figura 1. Esquemas de conexión de cada elemento del multímetro.
Para la de resistencia y capacitancia D3, D4 y D5 a "LOW", creamos una GND virtual para esos pines. Por
lo tanto, podemos seleccionar entre diferentes divisores de voltaje para seleccionar la escala. Luego
medimos el voltaje con la entrada ADC2 del ADS1115. Conocemos el valor del divisor y el voltaje medido,
por lo que podemos obtener el valor de la resistencia. Es así de fácil. Puede ver más sobre la medición de
resistencia
Ahora, para el modo de capacitancia, primero cargamos el capacitor con uno de los pines D11 o D13,
según el modo. Luego medimos el tiempo que tarda en descargarse al 63,2 % y luego usamos la constante
de tiempo para obtener el valor del capacitor
Para el medidor de inductancia hecho con esos condensadores de 1uF en paralelo que forman una tapa
de 2uF y la bobina que insertamos. Un inductor en paralelo con un condensador se llama circuito LC y
sonará como una campana. Independientemente de la frecuencia o de la fuerza con la que se golpee una
campana, sonará a su frecuencia de resonancia. Golpearemos electrónicamente la campana LC,
esperaremos un poco para que las cosas resuenen y luego tomaremos una medición.
Para aplicar una señal de pulso al circuito [Link] 5 voltios del Arduino desde D6. Cargamos el circuito
durante un tiempo. Luego cambiamos el voltaje de 5 voltios directamente a 0. Ese pulso hará que el circuito
resuene creando una señal sinusoidal amortiguada que oscila a la frecuencia de resonancia. Con el
OPAMP pasamos esa señal a ondas cuadradas y luego con el Arduino en el pin D9 medimos la longitud
del pulso y con ello obtenemos la frecuencia. Con la frecuencia obtenemos el valor del inductor porque ya
conocemos el valor de 2uF del capacitor.
El amperímetro es sencillo. Conectamos la entrada al amplificador ACS712, que está especialmente
diseñado para medir la corriente. Dará una salida analógica según el valor de la corriente y conocemos la
ganancia. En este caso, estoy usando el modelo de 20 A y la ganancia es de 100 mV/A de salida. Por lo
tanto, todo lo que hacemos en el código es medir la salida analógica y, luego, al saber que cada 100 mV
es 1 A, podemos obtener el valor de la corriente.
Finalmente se debe de soldar todo en la PBC
Figura 2. PCB para soldar elementos.
Para la carcasa donde se va a meter el circuito una vez soldado se mandará a hacer una carcasa 3D con el
siguiente modelado.
Figura 2. Modelado de carcasa.
Y finalmente se debe de programar con el siguiente código
/////////////////////////////Library for ADS1115 ADC////////////////////////////////// ////////////////////////OLED 64x124 display with i2c//////////////////////////////////
#include <Adafruit_ADS1015.h> //download here: //OLED screen libraries
[Link] #include <Adafruit_GFX.h> //download here:
Adafruit_ADS1115 ads(0x48); [Link]
#include <Adafruit_SSD1306.h> pinMode(Right_button, INPUT_PULLUP);
#define OLED_RESET 11 pinMode(dischargePin, INPUT);
Adafruit_SSD1306 display(OLED_RESET); pinMode(D12, INPUT);
//Define Inputs Outputs pinMode(chargePin, OUTPUT);
int mode_selector = A3; digitalWrite(Buzzer,LOW);
int Vcc_read = A1; digitalWrite(chargePin,LOW);
int current_switch = A7; digitalWrite(Induct_OUT,LOW);
int Baterry_read = A7; delay(200);
int CapAnalogPin = A0; [Link](SSD1306_SWITCHCAPVCC, 0x3C);
int CapAnalogPin2 = A2; delay(50);
int Buzzer = 2; [Link]();
int D3 = 3; [Link](1);
int D4 = 4; [Link](WHITE);
int D5 = 5; [Link](0,20);
int Induct_OUT = 6; [Link](" ELECTRONOOBS");
int D7 = 7; [Link](" MULTIMETER");
int Right_button = 8; [Link]();
int Induct_IN = 9; delay(500);
int Left_button = 10; [Link]();
int dischargePin = 13; [Link]();
int D12 = 12; }
int chargePin = 11; void loop() {
/////////////////////Variables///////////////////// analogReference(DEFAULT);
int mode = 1; ////////////////////////////MODE DETECTOR//////////////////////////////
float VoltageReadOffset = 0.0; if(analogRead(current_switch) > 512)
float Voltage = 0.0; {
float Volt_ref = 0; mode = 5;
int R2_1 = 2050; }
int R2_2 = 20; else
int R2_3 = 195; {
int Res_Offset = 0; int val = analogRead(mode_selector);
bool conductivity = true; if(val > 750)
//Capacitance mode {
unsigned long startTime; //[Link]("MODE 1");
unsigned long elapsedTime; mode = 1;
float microFarads; }
float nanoFarads; else if(val > 480)
#define resistorValue 10200.00F {
bool cap_scale = false; //[Link]("MODE 2");
//Small scale mode = 2;
const float IN_STRAY_CAP_TO_GND = 56.88; }
const float IN_CAP_TO_GND = IN_STRAY_CAP_TO_GND; else if(val > 360)
const float R_PULLUP = 34.8; {
const int MAX_ADC_VALUE = 1023; //[Link]("MODE 3");
//Inductance mode mode = 3;
double pulse, frequency, Induct_cap, inductance; }
//Current mode else
float Sensibility = 0.113; {
void setup() { //[Link]("MODE 4");
[Link](9600); mode = 4;
[Link](); }
analogReference(DEFAULT); }
pinMode(mode_selector, INPUT); if( mode == 1 )
pinMode(Vcc_read, INPUT); {
pinMode(current_switch, INPUT); pinMode(D12,OUTPUT);
pinMode(A6, INPUT); pinMode(D7,OUTPUT);
pinMode(CapAnalogPin, INPUT); digitalWrite(D12,LOW);
pinMode(CapAnalogPin2, OUTPUT); digitalWrite(D7,LOW);
pinMode(Buzzer, OUTPUT); float adc; // Leemos el ADC, con 16 bits
pinMode(D3, INPUT); adc = ads.readADC_Differential_0_1();
pinMode(D4, INPUT); Voltage = 11 * (adc * 0.1875)/1000 + VoltageReadOffset;
pinMode(D5, INPUT); [Link]();
pinMode(Induct_OUT, OUTPUT); [Link](2);
pinMode(D7, INPUT); [Link](WHITE);
pinMode(Left_button, INPUT_PULLUP); [Link](12,0);
pinMode(Induct_IN, INPUT); [Link](" VOLTAGE");
[Link](2); [Link]("RESISTANCE");
[Link](WHITE);
[Link](0,20); [Link](2);
[Link](Voltage); [Link](WHITE);
[Link]("V"); [Link](0,20);
[Link](); [Link](res);
delay(10); [Link]("KOhms");
} [Link]();
if( mode == 2 ) }
{ else if(res > 20000)
pinMode(D4,INPUT); {
pinMode(D5,INPUT); pinMode(D5,OUTPUT);
pinMode(D3,OUTPUT); digitalWrite(D5,LOW);
digitalWrite(D3,LOW); pinMode(D3,INPUT);
delay(10); pinMode(D4,INPUT);
float adc2; delay(10);
float res; adc2 = ads.readADC_SingleEnded(2);
while(res_loop < 10) Voltage = (adc2 * 0.1875)/1000;
{ res = ((R2_3*5)/Voltage) - R2_3;
adc2 = ads.readADC_SingleEnded(2); if(res < 2000)
Voltage = Voltage + (adc2 * 0.1875)/1000; {
res_loop = res_loop + 1; [Link](res, 2);
} [Link](" KOhms");
Voltage = Voltage/10; */ [Link]();
adc2 = ads.readADC_SingleEnded(2); [Link](2);
Voltage = (adc2 * 0.1875)/1000; [Link](WHITE);
[Link](4,0);
[Link]("RESISTANCE");
res = ((R2_1*5.04 )/Voltage) - R2_1 - Res_Offset; [Link](2);
//3.422V(AMS1117 3.3V) -0.616V (diode) [Link](WHITE);
[Link](0,20);
if(res < 2000) [Link](res);
{ [Link]("KOhms");
[Link](res, 2); [Link]();
[Link](" Ohms"); }
[Link](); else
[Link](2); {
[Link](WHITE); [Link]();
[Link](4,0); [Link](2);
[Link]("RESISTANCE"); [Link](WHITE);
[Link](4,0);
[Link](2); [Link]("RESISTANCE");
[Link](WHITE); [Link](2);
[Link](0,20); [Link](WHITE);
[Link](res); [Link](0,20);
[Link]("Ohms"); [Link]("INSERT");
[Link](); [Link]("RESISTOR");
} [Link]();
else if(res < 20000) }
{ }
pinMode(D3,INPUT); delay(50);
pinMode(D4,OUTPUT); }
pinMode(D5,INPUT); if( mode == 3 )
digitalWrite(D4,LOW); {
delay(10); if(!cap_scale)
{
adc2 = ads.readADC_SingleEnded(2); pinMode(CapAnalogPin,INPUT);
Voltage = (adc2 * 0.1875)/1000; pinMode(CapAnalogPin2, OUTPUT);
res = ((R2_2*5)/Voltage) - R2_2; //3.422V(AMS1117 3.3V) - pinMode(chargePin, OUTPUT);
0.616V (diode) digitalWrite(CapAnalogPin2, LOW);
[Link](res, 2); digitalWrite(chargePin, HIGH);
[Link](" KOhms"); startTime = micros();
[Link](); while(analogRead(CapAnalogPin) < 648){}
[Link](2); elapsedTime= micros() - startTime;
[Link](WHITE); microFarads = ((float)elapsedTime / resistorValue) - 0.01097;
[Link](4,0); if (microFarads > 1)
{ int digVal;
[Link](microFarads); do
[Link](" uF"); {
delay(500); digVal = digitalRead(CapAnalogPin2);
[Link](); unsigned long u2 = micros();
[Link](2); t = u2 > u1 ? u2 - u1 : u1 - u2;
[Link](WHITE); }
[Link](10,0); while ((digVal < 1) && (t < 400000L));
[Link]("CAPACITOR"); pinMode(CapAnalogPin2, INPUT);
[Link](2); val = analogRead(CapAnalogPin2);
[Link](WHITE); digitalWrite(CapAnalogPin, HIGH);
[Link](0,20); int dischargeTime = (int)(t / 1000L) * 5;
[Link](microFarads); delay(dischargeTime);
[Link]("uF"); pinMode(CapAnalogPin2, OUTPUT);
[Link](); digitalWrite(CapAnalogPin2, LOW);
} digitalWrite(CapAnalogPin, LOW);
else float capacitance = -(float)t / R_PULLUP / log(1.0 - (float)val /
{ (float)MAX_ADC_VALUE)
/*nanoFarads = microFarads * 1000.0; if (capacitance > 1000.0)
[Link](nanoFarads); {
[Link](" nF"); /*[Link](capacitance / 1000.0, 2);
delay(500); */ [Link](" uF");*/
cap_scale = true; //We change the scale to MIN - 1uF cap_scale = false;
} }
digitalWrite(chargePin, LOW); else
pinMode(dischargePin, OUTPUT); {
digitalWrite(dischargePin, LOW); [Link](capacitance);
while(analogRead(CapAnalogPin) > 0){} [Link](" nF");
pinMode(dischargePin, INPUT); [Link]();
} [Link](2);
if(cap_scale) [Link](WHITE);
{ [Link](10,0);
pinMode(dischargePin,INPUT); [Link]("CAPACITOR");
pinMode(chargePin,INPUT); [Link](2);
pinMode(CapAnalogPin2,OUTPUT); [Link](WHITE);
pinMode(CapAnalogPin, INPUT); [Link](0,20);
digitalWrite(CapAnalogPin2, HIGH); [Link](capacitance);
int val = analogRead(CapAnalogPin); [Link]("nF");
digitalWrite(CapAnalogPin2, LOW); [Link]();
if (val < 1000) }
{ }
pinMode(CapAnalogPin, OUTPUT); while (micros() % 1000 != 0);
float capacitance = (float)val * IN_CAP_TO_GND / }
(float)(MAX_ADC_VALUE - val); }
[Link](capacitance,0); if( mode == 4 )
[Link](" pF"); {
[Link](); [Link]();
[Link](2); [Link](2);
[Link](WHITE); [Link](WHITE);
[Link](10,0); [Link](3,0);
[Link]("CAPACITOR") [Link]("INDUCTANCE");
[Link](2); [Link]();
[Link](WHITE); digitalWrite(Induct_OUT, HIGH);
[Link](0,20); delay(5);
[Link](capacitance); digitalWrite(Induct_OUT,LOW);
[Link]("pF"); delayMicroseconds(100);
[Link](); pulse = pulseIn(Induct_IN,HIGH,5000);
delay(400); if(pulse > 0.1)
} {
else Induct_cap = 2.E-6;
{ frequency = 1.E6/(2*pulse);
pinMode(CapAnalogPin, OUTPUT); inductance =
delay(1); 1./(Induct_cap*frequency*frequency*4.*3.14159*3.14159);
pinMode(CapAnalogPin2, INPUT_PULLUP); inductance *= 1E6;
unsigned long u1 = micros(); [Link]( inductance );
unsigned long t; [Link]("uH");
[Link](2); Sens_volt = Sens_volt/100;
[Link](WHITE); [Link](Sens_volt);
[Link](0,20); float I = -0.004 + ((Sens_volt - 2.5075)/Sensibility);
[Link](inductance); [Link](I,3);
[Link]("uH"); [Link](" A");
[Link](); [Link]();
delay(100); [Link](2);
} [Link](WHITE);
} [Link](10,0);
if( mode == 5 ) [Link](" CURRENT");
{ [Link](2);
int read_loop = 0; [Link](WHITE);
float Sens_volt = 0; [Link](0,20);
while(read_loop < 100) [Link](I,3);
{ [Link]("A");
float adc3; // Leemos el ADC, con 16 bits [Link]();
adc3 = ads.readADC_SingleEnded(3); delay(50);
Sens_volt = Sens_volt + ( (adc3 * 0.1875)/1000 ); }
read_loop = read_loop + 1; }
}
Siendo guiados para la elaboración del electrodo “ELECTRONOOBS”.
Nota: Cada uno de los componentes se pueden encontrar en Steren
Cálculos
Una vez que se llevó a cabo la instrumentación del multímetro, se acabó la concentración de ion cloro que
existe en un pozo de agua siendo que esta es de 0.01 a 0.3 ppm, al ser que estaban en ppm las pasamos a
mol/L siendo que se realizó la siguiente conversión:
𝑚𝑔 𝑔 𝑚𝑜𝑙 𝑚𝑜𝑙
(0.01 )( )( ) = 2.81𝑥10−7
𝐿 1000 𝑚𝑔 35.5 𝑔 𝐿
𝑚𝑔 𝑔 𝑚𝑜𝑙 𝑚𝑜𝑙
(0.3 )( )( ) = 8.45𝑥10−6
𝐿 1000 𝑚𝑔 35.5 𝑔 𝐿
Teniendo en consideración que los 35.5 g corresponde al peso molecular del ion cloro.
𝑚𝑜𝑙 𝑚𝑜𝑙
Una vez obtenido el resultado de la conversión, se determinó el intervalo de 2.81𝑥10−7 𝐿
a 8.45𝑥10−6 𝐿
para obtener la conductancia mediante la siguiente formula.
𝑀 ∑[𝜆𝑁𝑎+ + 𝜆𝐶𝑙− ]
𝐿=
1000𝜃
Donde:
𝑚𝑜𝑙
M= concentración ( )
𝐿
𝑆𝑐𝑚 2
λNa+ (conductancia a dilución infinita de Sodio) = 50 ( 𝑚𝑜𝑙 )
𝑆𝑐𝑚 2
λCl- (conductancia a dilución infinita de Cloro) = 76 ( 𝑚𝑜𝑙 )
𝑆
θ= 1(𝑐𝑚)
Remplazando en la ecuación el rango de intervalos establecidos anteriormente se obtiene los siguientes
valores.
Aclarando que dichos valores de dilución infinita se obtuvieron de la página web “Técnicas conductimetricas”
Tabla 1. “Valores obtenidos”
M (concentración) L (conductancia)
𝟐. 𝟖𝟏𝒙𝟏𝟎−𝟕 3.54𝑥10−8
𝟏. 𝟐𝟖𝒙𝟏𝟎−𝟔 1.61𝑥10−7
𝟐. 𝟐𝟖𝒙𝟏𝟎−𝟔 2.87𝑥10−7
𝟑. 𝟐𝟖𝒙𝟏𝟎−𝟔 4.13𝑥10−7
𝟒. 𝟐𝟖𝒙𝟏𝟎−𝟔 5.39𝑥10−7
𝟓. 𝟐𝟖𝒙𝟏𝟎−𝟔 6.65𝑥10−7
𝟔. 𝟐𝟖𝒙𝟏𝟎−𝟔 7.91406𝑥10 −7
𝟕. 𝟐𝟖𝒙𝟏𝟎−𝟔 9.17406𝑥10 −7
𝟖. 𝟒𝟎𝒙𝟏𝟎−𝟔 1.0583𝑥10−6
Grafica 1. Representación gráfica de las concentraciones
Figura 3. Grafico representativo
Conclusión
La importancia de los sensores conductimétricas radica en su alta capacidad para medir de forma
precisa, rápida y barata la concentración de iones en fluidos biológicos y soluciones especializadas,
siendo de gran aplicación en diversos campos como lo es la industria, la agricultura, al cuidado del
medio ambiente y en temas de salud. Entrando en especifico en temas de salud, como futuros
ingenieros biomédicos, debemos comprender que su importancia radica en el monitoreo de los
electrolitos en soluciones como la sangre, la orina y en tratamientos médicos como hemodiálisis,
siendo un tema con gran impacto para la sociedad y la salud de estos.
Segmento de la fuente consultada.
Figura 4. Parte del texto de referencia
Referencias
• ELECTRONOOBS. (s.f.). Arduino 5 in 1 [Link]://[Link]/eng_arduino_tut112.php
• Monografí[Link]. (s.f.). Técnicas conductimétricas. Monografí[Link].
[Link]