Medicion de Temperatura auto de los 50´s

Sdos reapareciendo despues de muchos lios, espero que todos esten bien sobre todo de salud, estoy trabajando en un velocimetro con un sensor hall, para autos y motos, recien empeze la fase de investigacion, asi que cualquier hilo me seria de gran ayuda. Gracias

Bienvenido de vuelta.
Basicamente tiene que contar pulsos, generalmente se hace con interrupciones, asi que buscar Arduino RPM y luego lo adaptas a tu necesidad.

Sdos, si estaba viendo un post de pincho... donde el debate estuvo muy intenso, lastima se quedo sin terminar, al igual que mi control de combustible, pero me estoy organizando para continuar jaja. Surbyte le escribi por MP a ver que cree de lo que le comento. Sdos y estaremos en contacto.


Sdos, sigo yo con las mediciones para autos, ahora estoy haciendo un prototipo en una pantalla LCD 20 x4, que muestre, Temperatura, Voltage de la Bateria y Presion de Aceite, como ven en la imagen ya esta leyendo Temp y voltage, la temp esta a cero porque la lectura la esta haciendo desde los 5v de arduino osea no esta conectado a un pulmon real el de prueba lo regale a un amigo ahora toca comprar otro, cuando lo termine totalmente subire el codigo para su ayuda en revisarlo y optimizarlo. sdos

Un comentario. Luce muy bien pero... no te dejes llevar por los decimales y solo usa para temperatura 1 decimal y lo mismo para tensión.
Ver 12.3V de bateria es suficiente y en cambio 12.35, 12.36 estará basculando siempre lo que te va a generar comentarios.
Luego veremos como estabilizar las lecturas. Mira esta página de Luis Llamas Mediana

Sdos en eso mismo ando, vi un post donde mostrabas una forma de limitar a un decimal y estoy en eso ahora mismo. sdos

Tienes 2 modos o mas de hacerlo:

  1. suponiendo que tienes un valor float
    Lo multiplicas x 10, y tomas su valor entero, luego lo divides x 10 y vuelves a float.
    entonces 4.344V
    x 10 = 43.44 y si lo pasas a entero te queda 43
    Si luego lo divides x 10 te queda 4.3

Aclaro, si solo usaras

Serial.println(valor, 1); // sería suficiente
  1. Con Strings
String stringTension = String(4.344 , 1);  // usando un float y 1 lugar decimaldecimal places
  1. existe una forma de convertir los datos que requiere tmb algunos pasos.
char buffer[6] , str[4];
dtostrf(4.344, 3, 1, str);
sprintf(buffer, "%s", str);
Serial.print(buffer);

me fui por la mas facil,

Serial.println(valor, 1); // sería suficiente

ahi va todo el codigo todavia sin pulir mucho, vere que crees. sdos

#include <math.h>
#include <LiquidCrystal.h>
#include <Wire.h> 
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int VOLT_SENSOR = A1;
float v1 = 4.00;    // valor real de la alimentacion de Arduino, Vcc
float r1 = 100000; // 100k
float r2 = 10000; // 10K

const int Rc=2000; //se ponen dos resistencias de 1k en serie con los 5v de arduino esta es la resistencia maxima a temp ambiente.
const int Vcc=5;
const int SensorPIN=A0;
const int zumbador=15;
float celcius=0;
float voltios=0;
float A=1.759045004e-3;
float B=1.562590388e-4;
float C=8.271117805e-7;
float K=2.5;

byte customChar[] = {
  B01110,
  B01010,
  B01110,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};

byte bar1[8] =  // the 8 arrays that form each segment of the custom numbers
{
B11100,
B11110,
B11110,
B11110,
B11110,
B11110,
B11110,
B11100
};
byte bar2[8] =
{
B00111,
B01111,
B01111,
B01111,
B01111,
B01111,
B01111,
B00111
};
byte bar3[8] =
{
B11111,
B11111,
B00000,
B00000,
B00000,
B00000,
B11111,
B11111
};
byte bar4[8] =
{
B11110,
B11100,
B00000,
B00000,
B00000,
B00000,
B11000,
B11100
};
byte bar5[8] =
{
B01111,
B00111,
B00000,
B00000,
B00000,
B00000,
B00011,
B00111
};
byte bar6[8] =
{
B00000,
B00000,
B00000,
B00000,
B00000,
B00000,
B11111,
B11111
};
byte bar7[8] =
{
B00000,
B00000,
B00000,
B00000,
B00000,
B00000,
B00111,
B01111
};
byte bar8[8] =
{
B11111,
B11111,
B00000,
B00000,
B00000,
B00000,
B00000,
B00000
};
void setup()
{

float measureV=MeasureV(30, getVoltage);

float measureT=MeasureT(30, getTemperature);

lcd.createChar(1,bar1); // assignes each segment a write number
lcd.createChar(2,bar2);
lcd.createChar(3,bar3);
lcd.createChar(4,bar4);
lcd.createChar(5,bar5);
lcd.createChar(6,bar6);
lcd.createChar(7,bar7);
lcd.createChar(8,bar8);
lcd.begin(20, 4);

}
void custom0(int col)
{ // uses segments to build the number 0
lcd.setCursor(col, 0);
lcd.write(2);
lcd.write(8);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(2);
lcd.write(6);
lcd.write(1);
}
void custom1(int col)
{
lcd.setCursor(col,0);
lcd.write(32);
lcd.write(32);
lcd.write(1);
lcd.setCursor(col,1);
lcd.write(32);
lcd.write(32);
lcd.write(1);
}
void custom2(int col)
{
lcd.setCursor(col,0);
lcd.write(5);
lcd.write(3);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(2);
lcd.write(6);
lcd.write(6);
}
void custom3(int col)
{
lcd.setCursor(col,0);
lcd.write(5);
lcd.write(3);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(7);
lcd.write(6);
lcd.write(1);
}
void custom4(int col)
{
lcd.setCursor(col,0);
lcd.write(2);
lcd.write(6);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(32);
lcd.write(32);
lcd.write(1);
}
void custom5(int col)
{
lcd.setCursor(col,0);
lcd.write(2);
lcd.write(3);
lcd.write(4);
lcd.setCursor(col, 1);
lcd.write(7);
lcd.write(6);
lcd.write(1);
}
void custom6(int col)
{
lcd.setCursor(col,0);
lcd.write(2);
lcd.write(3);
lcd.write(4);
lcd.setCursor(col, 1);
lcd.write(2);
lcd.write(6);
lcd.write(1);
}
void custom7(int col)
{
lcd.setCursor(col,0);
lcd.write(2);
lcd.write(8);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(32);
lcd.write(32);
lcd.write(1);
}
void custom8(int col)
{
lcd.setCursor(col, 0);
lcd.write(2);
lcd.write(3);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(2);
lcd.write(6);
lcd.write(1);
}
void custom9(int col)
{
lcd.setCursor(col, 0);
lcd.write(2);
lcd.write(3);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(7);
lcd.write(6);
lcd.write(1);
}

void printNumber(int value, int col) {
if (value == 0) {
custom0(col);
} if (value == 1) {
custom1(col);
} if (value == 2) {
custom2(col);
} if (value == 3) {
custom3(col);
} if (value == 4) {
custom4(col);
} if (value == 5) {
custom5(col);
} if (value == 6) {
custom6(col);
} if (value == 7) {
custom7(col);
} if (value == 8) {
custom8(col);
} if (value == 9) {
custom9(col);
}
}

void displayTemperature(int measureT){
int  c, d, u, number;// PARA LOS MILLARES AGREGAR UNA m, Y ACTIVAR EL CODIGO DE ABAJO
number = measureT;
//if (number > 999) {
//m = (number - (number % 1000)) / 1000;
//number = number % 1000;
//} else {
//m = 0;
//}
if (number > 99) {
c = (number - (number % 100)) / 100;
number = number % 100;
} else {
c = 0;
}
if (number > 9) {
d = (number - (number % 10)) / 10;
number = number % 10;
} else {
d = 0;
}
u = number;
lcd.setCursor(4, 0);
lcd.print("Temp: ");
//printNumber(m, 6);
printNumber(c, 9);
printNumber(d, 12);
printNumber(u, 15);
lcd.setCursor(19,0);
lcd.print("C");
lcd.setCursor(15,3);
lcd.print("VOLTS");
//lcd.setCursor(10,3);
//lcd.print( Voltage);
lcd.setCursor(4,3);
lcd.print("ATM");
lcd.setCursor(2,3);
lcd.print("6");
lcd.setCursor(8,3);
lcd.print("|");
}
void displayLectura(float measureV) {
float Voltage=(measureV);
lcd.setCursor(10,3);
lcd.print(Voltage,1);
}

void loop()
{

displayTemperature(getTemperature());   
displayLectura(getVoltage());
delay(1000);
}

float MeasureT( int samplesNumber, float(*funct)())
                             {
                             float sum;
                             for (int i=0; i<samplesNumber; i++)
                             {
                             sum +=funct();
                             }
                             return sum/samplesNumber;
                             }
                           
                             float getTemperature()
                             {
                             float raw= analogRead(SensorPIN);
                             float V= raw/1024*Vcc;
                             float R=(Rc*V)/(Vcc-V);
                             float logR=log(R);
                             float R_th=1.0/(A+B*logR+C*logR*logR*logR);
                             float kelvin=R_th-V*V/(K*R)*1000;
                             float celcius=kelvin-273.15;
                             return celcius;      
                             }
                            
float MeasureV( int samplesNumber, float(*funct)())
                               {
                               float sum;
                               for (int i=0; i<samplesNumber; i++)
                               {
                               sum +=funct();
                               }
                               return sum/samplesNumber;
                               }
                           
                               float getVoltage()
                               {
                               //| Read sensor.
                               long sensorRead = analogRead(VOLT_SENSOR);
                               //| Convert reading to voltage. analogRead returns a value in the
                               float volts = (sensorRead * v1)/ 1024.0;
                               //| Output voltage of the sensor is a lineal function of the
                               float voltios = volts / (r2 / (r1 + r2));
                               //| Return the computed temperature.
                               return voltios;
                               }

Te paso algo para simplificar el código de los dígitos grandes, a ver si te sirve

byte digits[10][6] = {
  {2,8,1,2,6,1,},     // 0
  {32,32,1,32,32,1},  // 1
  {5,3,1,2,6,6},      // 2
  {5,4,1,7,6,1},      // 3
  {2,6,1,32,32,1},    // 4
  {2,3,4,7,6,1},      // 5
  {2,3,4,2,6,1},      // 6
  {2,8,1,32,32,1},    // 7
  {2,3,1,2,6,1},      // 8
  {2,3,1,2,7,1}       // 9
  };
  
void printNumber(int value, int col){
  lcd.setCursor(col,0);
  lcd.write(digits[value][0]);
  lcd.write(digits[value][1]);
  lcd.write(digits[value][2]);
  lcd.setCursor(col,1);
  lcd.write(digits[value][3]);
  lcd.write(digits[value][4]);
  lcd.write(digits[value][5]);
  }

Verificá si el caracter 223 del display no es el mismo que creaste como caracter 0, o sea "°".
Si es así te quedaría un caracter disponible para otro uso. :wink:

Saludos

Intenta usar Auto Format (del IDE) para que se pueda leer fácilmente).
Te he hecho algunos cambios. Espero que no te resulten complicados de entender.
Son para que vayas simplificando cosas y aprendiendo herramientas que te ayudarán a hacer mejores tus códigos.
Hay todavia algo para mejorar en la parte de visualización pero tuve un dia complicado.

#include <math.h>
#include <LiquidCrystal.h>
#include <Wire.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int VOLT_SENSOR = A1;
float v1 = 4.00;    // valor real de la alimentacion de Arduino, Vcc
const float r1 = 100000; // 100k
const float r2 = 10000; // 10K

const int Rc = 2000; //se ponen dos resistencias de 1k en serie con los 5v de arduino esta es la resistencia maxima a temp ambiente.
float Vcc = 5.0;
const int SensorPIN = A0;
const int zumbador = 15;
float celcius = 0;
float voltios = 0;
const float A = 1.759045004e-3;
const float B = 1.562590388e-4;
const float C = 8.271117805e-7;
const float K = 2.5;
byte customChar[] = {
  B01110,
  B01010,
  B01110,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};

byte bar1[8] =  // the 8 arrays that form each segment of the custom numbers
{
  B11100,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11100
};
byte bar2[8] =
{
  B00111,
  B01111,
  B01111,
  B01111,
  B01111,
  B01111,
  B01111,
  B00111
};
byte bar3[8] =
{
  B11111,
  B11111,
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111
};
byte bar4[8] =
{
  B11110,
  B11100,
  B00000,
  B00000,
  B00000,
  B00000,
  B11000,
  B11100
};
byte bar5[8] =
{
  B01111,
  B00111,
  B00000,
  B00000,
  B00000,
  B00000,
  B00011,
  B00111
};
byte bar6[8] =
{
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B11111
};
byte bar7[8] = {
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00111,
  B01111
};
byte bar8[8] = {
  B11111,
  B11111,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};
struct _CustomData {
  byte col0[3];
  byte col1[3];
};

_CustomData customData[10] = {{{ 2 ,8, 1},{ 2, 6, 1}},
                              {{32,32, 1},{32,32, 1}},
                              {{ 5, 3, 1},{ 2, 6, 6}},
                              {{ 5, 3, 1},{ 7, 6, 1}},
                              {{ 2, 6, 1},{32,32, 1}},
                              {{ 2, 3, 4},{ 7, 6, 1}},
                              {{ 2, 3, 4},{ 2, 6, 1}},
                              {{ 2, 8, 1},{32,32, 1}},
                              {{ 2, 3, 1},{ 2, 6, 1}},
                              {{ 2, 3, 1},{ 7, 6, 1}}
                             };
                         
void setup() {
  float measureV = MeasureV(30, getVoltage);
  float measureT = MeasureT(30, getTemperature);
  lcd.createChar(1, bar1); // assignes each segment a write number
  lcd.createChar(2, bar2);
  lcd.createChar(3, bar3);
  lcd.createChar(4, bar4);
  lcd.createChar(5, bar5);
  lcd.createChar(6, bar6);
  lcd.createChar(7, bar7);
  lcd.createChar(8, bar8);
  lcd.begin(20, 4);
}

void printNumber(int value, int col) {
  // uses segments to build the number 0
  lcd.setCursor(col, 0);
  lcd.write(customData[value].col0[0]);
  lcd.write(customData[value].col0[1]);
  lcd.write(customData[value].col0[2]);
  lcd.setCursor(col, 1);
  lcd.write(customData[value].col1[0]);
  lcd.write(customData[value].col1[1]);
  lcd.write(customData[value].col1[2]);
 }

void displayTemperature(int measureT) {
  int  c, d, u, number;// PARA LOS MILLARES AGREGAR UNA m, Y ACTIVAR EL CODIGO DE ABAJO
  number = measureT;
  if (number > 99) {
      c = (number - (number % 100)) / 100;
      number = number % 100;
  } else {
    c = 0;
  }
  if (number > 9) {
    d = (number - (number % 10)) / 10;
    number = number % 10;
  } else {
    d = 0;
  }
  u = number;
  lcd.setCursor(4, 0);
  lcd.print("Temp: ");
  //printNumber(m, 6);
  
  printNumber(c, 9);
  printNumber(d, 12);
  printNumber(u, 15);
  lcd.setCursor(19, 0);
  lcd.print("C");
  lcd.setCursor(15, 3);
  lcd.print("VOLTS");
  //lcd.setCursor(10,3);
  //lcd.print( Voltage);
  lcd.setCursor(4, 3);
  lcd.print("ATM");
  lcd.setCursor(2, 3);
  lcd.print("6");
  lcd.setCursor(8, 3);
  lcd.print("|");
}

void displayLectura(float measureV) {
  float Voltage = (measureV);
  lcd.setCursor(10, 3);
  lcd.print(Voltage, 1);
}

void loop() {
  displayTemperature(getTemperature());
  displayLectura(getVoltage());
  delay(1000);
}

float MeasureT( int samplesNumber, float(*funct)()) {
  float sum;
  for (int i = 0; i < samplesNumber; i++)  {
      sum += funct();
  }
  return sum / samplesNumber;
}

/*
  Nota: este código asume que "1.1V” son exactamente 1.1V. Debes medir VCC con tu mejor multimetro (tester) 
  y luego corregir la constante para lograr el mejor resultado. Mucho mejor que decir que es 5.00 cuando es 4.985.
  Este método funciona muy bien.
 */
 
long readVcc() {
  long result;
  // Read 1.1V reference against AVcc
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  delay(2); // Wait for Vref to settle
  ADCSRA |= _BV(ADSC); // Convert
  while (bit_is_set(ADCSRA,ADSC));
  result = ADCL;
  result |= ADCH<<8;
  result = 1126400L / result; // Back-calculate AVcc in mV
  return result;
}

float getTemperature() {
  unsigned int raw = analogRead(SensorPIN);
  Vcc = (float) readVcc()/1000.0; // valor de la tensión de referencia medida internamente.
  float V = raw / 1024 * Vcc;
  float R = (Rc * V) / (Vcc - V);
  float logR = log(R);
  float R_th = 1.0 / (A + B * logR + C * logR * logR * logR);
  float kelvin = R_th - V * V / (K * R) * 1000;
  float celcius = kelvin - 273.15;
  return celcius;
}

float MeasureV( int samplesNumber, float(*funct)()) {
  float sum  = 0.0;
  for (int i = 0; i < samplesNumber; i++)   {
       sum += funct();
  }
  return sum / samplesNumber;
}

float getVoltage() {
  //| Read sensor.
  unsigned int sensorRead = analogRead(VOLT_SENSOR);
  //| Convert reading to voltage. analogRead returns a value in the
  float volts = (sensorRead * v1) / 1024.0;
  //| Output voltage of the sensor is a lineal function of the
  float voltios = volts / (r2 / (r1 + r2));
  //| Return the computed temperature.
  return voltios;
}

Hay dos o tres cosas importantes.
todo lo que no se modifica es constante entonces muchos de tus valores A,B,C,K para calcular el NTC los puse con const para no consumir RAM.

Definí una estructura ver link para aprender mas.
La estructura tiene 2 bytes de 3 elementos cada uno. Si te fijas tu customchar se simplifica en 3 valores para col0 y 3 para col1
Asi que yo puse esos 3 valores en cada caso. La forma en que se definen los valores es especial y eso puedo darte dolores de cabeza pero aprende que es asi y listo.
Este caso por ejemplo

void custom0(int col)
{ // uses segments to build the number 0
lcd.setCursor(col, 0);
lcd.write(2);
lcd.write(8);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(2);
lcd.write(6);
lcd.write(1);
}

lo he simplificado usando la estructura como

{{ 2 ,8, 1},{ 2, 6, 1}},

como verás, los primeros 3 digitos se agrupan entre llaves {} luego una , porque la estructura tiene dos variables o mejor dicho, dos arrays variables de 3 elementos cada uno.
Imagina que col0[0] tendra el 2 col0[1] = 8 colo0[2] = 1 y lo mismo con col1
No es dificil.

La segunda gran modificación tiene que ver con Vcc. He conservado tu variable Vcc que la inicializo en 5.0 volts pero luego usando la referencia interan del Arduino UNO (espero que uses un UNO) leemos precisamente el valor de tensión que tiene tu arduino.
Ese valor deberás medirlo con un buen tester, voltimetro, cuanto mas preciso mejor y ajustar el valor que he indicado en readVcc()

Bueno, con eso cierro los cambios propuestos.

Sdos y gracias por responder, verifico los cambios propuestos por los dos y les comento en el dia de hoy, con esto me propuse implementar un filtro por software, no estoy seguro de que cumpla el objetivo, cuando puedan echenle un ojo. agradecido por la ayuda.

float measureV = MeasureV(30, getVoltage);
  float measureT = MeasureT(30, getTemperature);

no se si funciona como filtro para atenuar las consecuencias del ruido

Sdos, ya implemente el codigo que me reviso Surbyte, y me gusta como funciona, ahora el valor medido de Vcc es de 4.59, tengase en cuenta que estoy prototipando todavia y hay falsos, y la alimentacion es por el USB de la pc, si este fuera el valor real segun entendi, debiera ponerlo en:

long readVcc( 4.59) {

sera asi. Sdos

No. No es así.
La función no tiene parámetro para ingresarle,

long readVcc() {

En cambio si devuelve un dato en mV.
Pero debes calcular cual es el valor de referencia que tienes que no es 1.1V y esta expresado en microvoltios. No me preguntes por qué.
El valor a cambiar es 1126400L y cómo lo haces?

Los pasos son:

  1. Fijas la tensión de referencia a Vcc.
  2. Mides el valor de la referencia interna
  3. Calculas el valor de Vcc.

Que medimos?

Vcc * (ADC-valor_medido) / 1023

que como sabemos es 1.1 volts, o sea
Vcc * (ADC-valor_medido) / 1023 = 1.1V
Despejo Vcc

Vcc = 1.1 * 1023 /( ADC-measurement)

Calcula Vcc (en mV); 1125300 = 1.110231000

Si esto no lo comprendes, usa esta librería y sigue sus ejemplos que se basan en lo mismo pero tal vez sean mas simples de entender.

Sdos, ante todo una disculpa, ayer despues de ver el codigo, lo implemente sin mas, y no pense detenidamente y por eso puse esa tonteria, me llama la atencion que me especificas que debo estar usando un uno, no por cuestiones de tamaño para la implementacion final en el pcb, tengase en cuenta que es un reloj para un auto, estoy usando un nano, no se si eso varia en algo el codigo propuesto. Sdos y Gracias

Sdos, hoy puse una bateria de 12v y con 2 filtros y un 7805 le di la entrada al circuito, por lo tanto en mi vin del arduino nano, tengo 5.05 volts, y en el pin 5v del mismo tengo 5.05 volts
eso mejora mucho la estabilidad de el voltage para el proyecto, estoy tratando de entender el codigo para la referencia interna del arduino con la libreria que me aconsejo, hasta ahora nada pero trato, trato, y lo lograre. Bien despues de leer sobre el tema del ADC sigo un poco enredado, ya medi el pin ref. de mi arduino nano y me da 5.03 volts, ese debe ser mi voltage de referencia. lo que no logro aterrizarlo en la formula porque

aqui el dato que me faltaba es measurement osea la medida tomada a mi referencia, bien y ADC que valor tiene?. Perdon por el bloqueo mental. sdos

Sdos, sigo con el tema de la formula para Vcc, pregunto, ADC es el voltage que tengo en el pin analogico? y a esto le resto la medicion tomada en la entrada Vin de arduino?. me hace falta entender esto, me sucedio que la bateria con que estaba haciendo las pruebas se cayo en potencia y me tenia las lecturas locas, y no encontraba la razon, si esta formula estuviera implementada las lecturas se hubieran mantenido estables?. sdos y gracias

Sdos, me doy por vencido, aunque he leído y releído el tema, y he buscado info por otras partes, aunque parece que entiendo, no logro aterrizar el código a la vida real, quiero decir me confunde el tema.
Vcc es el valor que yo mido con mi tester en la entrada del nano?.
El valor de referencia lo tomo del pin aref, o es el valor en la entrada?
El valor ADC es 1126400L?
Cuando trato de sacar los cálculos me da un valor de 0.000999 y cuando lo implementó en el código no Lee nada del sensor de temp, los display se quedan fijos en ooo. En fin estoy bloqueado. Sdos y disculpen la ignorancia,
Sigo yo con lo mismo aver si mido Vcc osea en el pin 5v del arduino nano y me da 3.89, luego mido en el pin ref del mismo arduino y me da 3.89 igual, la formula como quedaria.
vcc=1.1*1023/(3.89-3.89)y esto expresado en milivolts se mantiene con 1125300?
al implementar este codigo no tengo que llamar a analogReference?
de ser asi seria EXTERNAL porque estoy trabajando con una bateria?