Medicion de Temperatura auto de los 50´s

Sdos a todos los del foro, en esta seccion quiero compartir un proyecto que realize y que ya tiene un año de prueba con resultados excelentes, la idea surge de la necesidad de medir temperatura en un auto de los años 50 con arduino, display 7 segmentos y usando el sensor original del auto. posteare el codigo y la vista PCB de fritzing, y los planos para imprimir en PCB, asi como algunas fotos de relojes de temp trabajando. Sdos y Gracias.
PD: La vista en protoboard se las debo con la premura no la hice.


Este es el reloj funcionando ya, como se puede ver a la izquierda esta el sensor de temperatura del auto. este es una resistencia variable NTC por lo tanto se tomaron muestras de su valor a diferentes temperaturas para ver la variacion no lineal, y se calculo mediante formula como se vera en el codigo.
Cabe destacar que cada sensor tendra su calculo independiente para lograr la fidelidad de la lectura.

#include <math.h>
//
// Temperatura de carro

// Construcción de un medidor de temperatura para autos con Arduino
// 20.03.2019

//

const int SEGMENTS = 7;  
const int SEG_PINS[SEGMENTS] = {4, 8, 11, 9, 2, 5, 12};
const int DP_PIN = 10;
const int DIGITS = 3;
const int DIG_PINS[DIGITS] = {3, 6 , 7,};
const int SYMBOL_COUNT = 10;

//const int SYMBOLS[SYMBOL_COUNT][SEGMENTS] = {//CATODO COMUN CAMBIAR LOW,HIGH
        // {1, 1, 1, 1, 1, 1, 0}, //| 0
        // {0, 1, 1, 0, 0, 0, 0}, //| 1
         //{1, 1, 0, 1, 1, 0, 1}, //| 2
        // {1, 1, 1, 1, 0, 0, 1}, //| 3
        // {0, 1, 1, 0, 0, 1, 1}, //| 4
       //  {1, 0, 1, 1, 0, 1, 1}, //| 5
        // {1, 0, 1, 1, 1, 1, 1}, //| 6
        // {1, 1, 1, 0, 0, 0, 0}, //| 7
        // {1, 1, 1, 1, 1, 1, 1}, //| 8
        // {1, 1, 1, 1, 0, 1, 1}, //| 9
        

const int SYMBOLS[SYMBOL_COUNT][SEGMENTS] = {//ANODO COMUN CAMBIAR LOW,HIGH
       {0, 0, 0, 0, 0, 0, 1}, //| 0
       {1, 0, 0, 1, 1, 1, 1}, //| 1
       {0, 0, 1, 0, 0, 1, 0}, //| 2
       {0, 0, 0, 0, 1, 1, 0}, //| 3
       {1, 0, 0, 1, 1, 0, 0}, //| 4
       {0, 1, 0, 0, 1, 0, 0}, //| 5
       {0, 1, 0, 0, 0, 0, 0}, //| 6
       {0, 0, 0, 1, 1, 1, 1}, //| 7
       {0, 0, 0, 0, 0, 0, 0}, //| 8
       {0, 0, 0, 0, 1, 0, 0}, //| 9
  
};

const int ITERATIONS = 50;
const int DELAY = 4;
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 A=1.759045004e-3;
float B=1.562590388e-4;
float C=8.271117805e-7;
float K=2.5;

void setup() 
{

float measureN=MeasureN(30, getTemperature);

pinMode(zumbador,OUTPUT);
for (int i = 0; i < SEGMENTS; i++) {
pinMode(SEG_PINS[i], OUTPUT);
}
pinMode(DP_PIN, OUTPUT);
for (int i = 0; i < DIGITS; i++) {
pinMode(DIG_PINS[i], OUTPUT);

}
}
 
void loop() {                 
            displayTemperature(getTemperature());   
            pitaTemp(vigilaTemp());
            }
      
                      
                             float MeasureN( 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 vigilaTemp()
                             {
                             int alarma=0;
                             if (alarma >= 95){
                             digitalWrite(zumbador,HIGH);
                             }else{
                              digitalWrite(zumbador,LOW);
                             }
                             }
                            
                             void pitaTemp(int measureN) 
                             {  
                             int alarma=int(measureN);             
                             }
                            
                             void displayTemperature(int measureN) {
                             int int_part = int(measureN);
                             int digits[3];
                              
                             digits[0] = int_part % 1000/100;   
                             digits[1] = int_part % 100/10;          
                             digits[2] =int_part  % 100%10;        
                                                      
                             if (digits[2] == 10) {
                             digits[2] = 0;
                             digits[1]++;
                             if (digits[1] == 10) {
                             digits[1] = 0;
                             digits[0]++;                                            
                             }
                             }                                    
                                                                                 
                             for (int i = 0; i < ITERATIONS; i++) {
                             displaySymbol(0, digits[0], 0);
                             delay(DELAY);
                             displaySymbol(1, digits[1], 0);
                             delay(DELAY);
                             displaySymbol(2, digits[2], 0);
                             delay(DELAY);
                             }
                             }                            
                             void displaySymbol(int digit, int symbol, int dp) {
                             //| Check arguments are between ranges.
                             if (digit < 0 || digit >= DIGITS) {
                             return;
                             }
                             if (symbol < 0 || symbol > SYMBOL_COUNT) {
                             return;
                             }                              
                             for (int i = 0; i < DIGITS; i++) {
                             if (i == digit) {
                             digitalWrite(DIG_PINS[i], HIGH);
                             }
                             else {
                             digitalWrite(DIG_PINS[i], LOW);
                             }
                             }                           
                             for (int i = 0; i < SEGMENTS; i++) {
                             digitalWrite(SEG_PINS[i], SYMBOLS[symbol][i] ? HIGH : LOW);
                             }                           
                            if (dp) {
                            digitalWrite(DP_PIN, LOW);
                             }
                            else {
                            digitalWrite(DP_PIN, HIGH);
                             }    
                                                
                             }
                       

TEMPERATURA_CARRO_MEDIA.ino (6,4 KB)


esta es la imagen del PCB diseñado en Fritzing y le s doy ahora los planos en PDF
TEMPERATURA CARRO_etch_copper_bottom.pdf (19,3 KB)
TEMPERATURA CARRO_etch_mask_bottom.pdf (9,0 KB)
TEMPERATURA CARRO_etch_silk_top.pdf (1,2 KB)
Sdos y Gracias

Buen trabajo!!!
No es por criticar sino para aportar algo que no veo, el esquema electrónico.
El 3er pdf (silik) esta vacío.

Sdos, algo que pasa cuando nos metemos de lleno en algo y no tenemos la constumbre de ir documentando todo el proceso, es la falta de organizacion, en este caso todo lo iba haciendo en protoboard, prueba y error, luego ya lo pase a vista PCB en fritzing, lo imprimi, lo transferi a PCB lo monte y ahora al querer publicarlo para compartirlo veo cuan falta esta de organizacion, lo siento tratare de hacer lo que falta y publicarlo. Sdos y Gracias

Esta imagen es de otro reloj de temperatura, basicamente es el mismo, solo que esta ves el amigo queria que se controlara el electroventilador desde el mismo reloj, puesto a la obra modifique el codigo anterior, y por el pin donde sonaba la alarma de temperatura alta lo que hice fue activar un relay de 12 volt, para lo cual utilice un Mosfet de una motherboard de PC, y listo el electro se activa a los 84 grados y se apaga a los 80 grados, cabe añadir que este reloj esta funcionando asi, hace aproximadamente 1 año sin problemas.


ahora pongo una imagen de un voltimetro, tambien para auto, el objetivo es monitorear la carga de la bateria, no he logrado hacer un amperimetro pues las baterias de los autos tienen un amperaje muy grande de aproximadamente 100 A y no he logrado idear algun proyecto para esto. Se agradece cualquier idea. Sdos

No quiero cansarlos, estos relojes independientes responden a un proyecto mayor, que seria hacer una pizarra o tablero como se conoce en otras regiones para autos, con todos los parametros a medir, temp, presion de aceite, nivel de combustible, RPM, voltage o amperaje de bateria, todo esto adaptado a la pizzara original del auto, ahora estoy tratando de hacer el de nivel de combustible, el amigo Surbyte me esta ayudando pues no se si por la cuarentena o que, aunque parecia un proyecto mas facil que los anteriores me esta costando echarlo adelante. Sdos y gracias por la paciencia.

Moderador:
Metiste la pata y me hiciste comprender que estas incurriendo en una falta a las normas del foro.
Esto es un doble posteo. Por un lado pones este hilo y por otro preguntas como resolver el código. Es el mismo tema para los dos hilos.
Tienes una primer advertencia y voy a juntar los hilos aquí.
No lo vuelvas a hacer o eres pasible de sanciónes.
Las respuestas por privado.
Si respondes del tema acá las voy a borrar.

Saludos a los del foro, aunque estube revisando el foro y he visto algun que otro tema sobre la lectura con arduino del nivel de combustible, estos estan ejemplificados con un potenciometro. Tengo en mi mano un flotante de un tanque de combustible y me esta rompiendo la cabeza, cuando lo trato con un divisor de tension me da lecturas erroneas y datos imprecisos, la lectura del flotante en su punto maximo osea lleno, es de 65 ohm y en su punto mas bajo osea vacio, es de 3 ohm, pregunto, cual seria el valor de la resistencia de calibracion seria 65ohm igual?. bien probe con una y no me da estoy bloqueado, si alguno me pudiera ayudar lo agradesco. Sdos y Gracias

Resistencia de calibración? No se a què te refieres con eso.
Para mi debes montar un divisor de tensión o uno de corriente.
Nunca olvidar qué se mide! Mides combustible entonces hay consideraciones a tener en cuenta como no hacer circular una corriente peligrosa.
Como usas supongo 12 o 5V entonces es dificil que eso ocurra.
Veamos:
Lo mas lógico si fuera un divisor de tensión es poner una R de 65 ohms en serie con el potenciometro y de ese modo tendrias una excursión casi entre 0 y 2.5V
Si fueramos algo mas inteligentes entonces podriamos poner algo que cuando este lleno y el potenciómetro tenga una R de 65 ohms te de una tensión de 1.1V aprovechando la referencia interna del Arduino y entonces podrias medir con mejor precisión todo el tanque de combustible
Para ello entonces si alimentas con 5V requieres que cuando este lleno los 65 ohms mas otra Resistencia te den una caida de 1.V
Veamos como hacer eso:
Llamo R a la Resistencia desconocida
Llamo Rfull a la resistencia del Sensor a Fondo Escala o con todo el combustible y abrán 1.1V en ese momento.
Puedo plantear una relación de este modo 1.1V/65 ohms = 5V /(R+65)
Despejando R tengo R = 230 ohms

Entonces un divisor alimentado por 5V → R => 230 ohms => Pin AD y a R sensor => el otro extremo a GND.

Cuando leas con el arduino, cambia la tensión de referencia a Referencia Interna y en lugar de medir con 5V el máximo será 1.1V, tentras de 0 a 1023 para 1.1V.
No es perfecto porque para 3 ohms no tienes 0 pero es lo mejor que puedes lograr si no quieres usar mas electronica o un amplificador diferencial.

Sdos y gracias por responder, exacto lo que quiero hacer es un divisor de tension, osea la R en serie con el flotador que es una resistencia de 3 a 65 ohms, la duda era el valor que debia usar en la R del divisor de tension, leyendo su respuesta ahora me surgen mas dudas, yo estaba leyendo el divisor por el pin A0, no se si esta bien, y cuando se refiere a Referencia Interna quiere decir hacer la division de los 1023 por 1.1 volt y no con 5.0 volt?. Voy a hacer algo, modificare el circuito en protoboard, y lo subire en fritzing y el codigo que estoy intentando que resulte, y ahi si puede me dira que esta mal o que puedo dejar. Sdos y gracias una ves mas.

Sdos, aqui pongo imagen en protoboard como pienso que quedaria el divisor, por favor si lo puede chequear y decirme donde estoy cometiendo el error. Sdos y Gracias.
CONTROLCOMBUSTIBLERESISTENCIA.ino (6,9 KB)

Este es el codigo con todo tipo de variaciones que he usado y no me han funcionado, se que es mucho pedir pero estoy verdaderamente bloqueado, en la seccion de proyectos deje uno completo para medir temperatura en un auto de los 50 usando arduino y manteniendo el sensor original, esta funcionando hace un año. Disculpen la molestia

//#include <math.h>
//
//Nivel de combustible



const int SEGMENTS = 7;  
const int SEG_PINS[SEGMENTS] = {4, 8, 11, 9, 2, 5, 12};
const int DP_PIN = 10;
const int DIGITS = 3;
const int DIG_PINS[DIGITS] = {3, 6 , 7,};
const int SYMBOL_COUNT = 10;

//const int SYMBOLS[SYMBOL_COUNT][SEGMENTS] = {//CATODO COMUN CAMBIAR LOW,HIGH
        // {1, 1, 1, 1, 1, 1, 0}, //| 0
        // {0, 1, 1, 0, 0, 0, 0}, //| 1
         //{1, 1, 0, 1, 1, 0, 1}, //| 2
        // {1, 1, 1, 1, 0, 0, 1}, //| 3
        // {0, 1, 1, 0, 0, 1, 1}, //| 4
       //  {1, 0, 1, 1, 0, 1, 1}, //| 5
        // {1, 0, 1, 1, 1, 1, 1}, //| 6
        // {1, 1, 1, 0, 0, 0, 0}, //| 7
        // {1, 1, 1, 1, 1, 1, 1}, //| 8
        // {1, 1, 1, 1, 0, 1, 1}, //| 9
        

const int SYMBOLS[SYMBOL_COUNT][SEGMENTS] = {//ANODO COMUN CAMBIAR LOW,HIGH
       {0, 0, 0, 0, 0, 0, 1}, //| 0
       {1, 0, 0, 1, 1, 1, 1}, //| 1
       {0, 0, 1, 0, 0, 1, 0}, //| 2
       {0, 0, 0, 0, 1, 1, 0}, //| 3
       {1, 0, 0, 1, 1, 0, 0}, //| 4
       {0, 1, 0, 0, 1, 0, 0}, //| 5
       {0, 1, 0, 0, 0, 0, 0}, //| 6
       {0, 0, 0, 1, 1, 1, 1}, //| 7
       {0, 0, 0, 0, 0, 0, 0}, //| 8
       {0, 0, 0, 0, 1, 0, 0}, //| 9
  
};

const int ITERATIONS = 50;
const int DELAY = 4;
//const int analogPin = A0;
int value;      //variable que almacena la lectura analógica raw
int position;   //posicion del potenciometro en tanto por ciento
long Rsensor;
int Vout=0;
int Rc=0;
//int   lpadc = A0;
float lpv = 0;
int   lpp = 0;
int pladc=0;
int P2 = A0; // ANALOG IN: A2, va al terminal intermedio del potenciómetro.
float valor = 0;
float deceroauno;
int valor1=0;
int porciento=0;


void setup() 


{

float measureN=MeasureN(30, getNivelCombustible);

//pinMode(zumbador,OUTPUT);
for (int i = 0; i < SEGMENTS; i++) {
pinMode(SEG_PINS[i], OUTPUT);
}
pinMode(DP_PIN, OUTPUT);
for (int i = 0; i < DIGITS; i++) {
pinMode(DIG_PINS[i], OUTPUT);

}
}
 
void loop() {                 
             displayNivelCombustible(getNivelCombustible());   
              // pitaTemp(vigilaTemp());
            }
      
                      
                             float MeasureN( int samplesNumber, float(*funct)())
                             {
                             float sum;
                             for (int i=0; i<samplesNumber; i++)
                             {
                             sum +=funct();
                             }
                             return sum/samplesNumber;
                             }
                           
                             float getNivelCombustible()
                             {
                                               
                                 //value = analogRead(analogPin);          // realizar la lectura analógica raw
                                 //Rsensor = 1023L * Rc /value - Rc;   //calcular el valor de la resistencia
                                 //Vout=value*Rsensor/Rc+Rsensor;
                                 //position = map(value, 0, 1023, 0, 40);  // convertir a porcentaje

                                 //lpadc = analogRead(A0);                 // lectura potenciometro mostrada ADC:
                                 //lpv  = analogRead(A0) * (5.0 / 1023);   // convierte en voltage V:
                                 //lpp = analogRead(A0) * (100.0 / 1023);  // Convierte en porcentaje %:
                                 //pladc = map(lpv, 0, 1023, 0, 100);


                                  valor = analogRead(A0)* (1.1 / 1023);
                                  //valor1 = map(valor, 0, 1023, 0, 100);
                                 // porciento=valor1*100/40;
                                 // voltage=analogRead(A0);
                                 // Rsensor = 1023L * Rc / voltage - Rc;   //calcular el valor de la resistencia
                                 // Vsalida= (Rsensor/Rc+Rsensor)*voltage ;
                                 // Vcalculado= Vsalida* (5.0 / 1023) ;
                                  //Vporcentual= Vcalculado * (100.0/1023);
                                  return  valor;
                               
                               }
                             
                            
                             void displayNivelCombustible(int measureN) {
                             int int_part = int(measureN);
                             int digits[3];
                              
                             digits[0] = int_part % 1000/100;   
                             digits[1] = int_part % 100/10;          
                             digits[2] =int_part  % 100%10;        
                                                      
                             if (digits[2] == 10) {
                             digits[2] = 0;
                             digits[1]++;
                             if (digits[1] == 10) {
                             digits[1] = 0;
                             digits[0]++;                                            
                             }
                             }                                    
                                                                                 
                             for (int i = 0; i < ITERATIONS; i++) {
                             displaySymbol(0, digits[0], 0);
                             delay(DELAY);
                             displaySymbol(1, digits[1], 0);
                             delay(DELAY);
                             displaySymbol(2, digits[2], 0);
                             delay(DELAY);
                             }
                             }                            
                             void displaySymbol(int digit, int symbol, int dp) {
                             //| Check arguments are between ranges.
                             if (digit < 0 || digit >= DIGITS) {
                             return;
                             }
                             if (symbol < 0 || symbol > SYMBOL_COUNT) {
                             return;
                             }                              
                             for (int i = 0; i < DIGITS; i++) {
                             if (i == digit) {
                             digitalWrite(DIG_PINS[i], HIGH);
                             }
                             else {
                             digitalWrite(DIG_PINS[i], LOW);
                             }
                             }                           
                             for (int i = 0; i < SEGMENTS; i++) {
                             digitalWrite(SEG_PINS[i], SYMBOLS[symbol][i] ? HIGH : LOW);
                             }                           
                            if (dp) {
                            digitalWrite(DP_PIN, LOW);
                             }
                            else {
                            digitalWrite(DP_PIN, HIGH);
                             }    
                                                
                             }
                            

No inserte la imagen, disculpas

Los códigos deben verse, no subas el archivo .ino porque nos obliga a descargar algo que podemos ver. El nuevo foro no tiene la restricción de 9k y tu archivo apenas tiene 6.9K.
Asi que ve al post#4 y edita al final con el código. Te lo pido para que aprendas a hacerlo.
Cuando lo vea responderé.

El Arduino UNO tiene una referencia interna analogReference() - Arduino Reference que permite medir tensiones entre 0-1.1V con su rango de medicion de 10 bits.
Para ello debes agregar esto

analogReference(INTERNAL);

en el setup()

Mira este tutorial La referencia analogica AREF | Tienda y Tutoriales Arduino

El divisor resistivo esta al revés de lo que se ve en la imagen del post#5
Te dije que la R de 230 ohms debe estar contra 5V y el potenciómetro contra GND para que al medir, vaya de casi 0 a 1.1V

Sdos, ya edite el post No. 4 originalmente tenia la resistencia a 5volts pero no se que me pasa con este dichoso trabajo que me tiene muy confundido no logro avanzar, talves deba bajarle la atencion por par de dias. Sdos

Bueno, ahora te doy otro empujón.
El divisor será algo asi

2

donde R2 es tu potenciometro con R de 3 a 65 ohms
R1 = 230 ohms... mmm vas a conseguir 220. Veamos que tal va con 220 y sino tendras que sumar en serie una de 10 a 220 ohms

VA0 = tensión en terminal Analógico A0.
VA0 = 5V * R2 /(R1+R2) = 5V* 65 / (65+230) = 1.1016V lo que esta bastante cerca de lo que predije
Si fuera con 220 veamos el mismo calculo

VA0 = 5V * R2 /(R1+R2) = 5V* 65 / (65+220) = 1,14V o sea sube la tensión y ya no me gusta tanto.
Respetemos lo anterior.
220 mas una R de 10 ohms en serie para completar 230 o bien compras un presete y lo ajustas para que de perfectos 1.100V según tu tester. Se entiende?

Siguiente, tu código modificado.
La ecuación de la recta es que pasa por un punto (x1, y1) es
La ecuación punto-pendiente de la recta que pasa por P1(x1, y1) con pendiente m es
(y - y1) = m(x - x1)
m es la pendiente.
Tienes una recta que tiene para x = 3 ohms y = 0 y para x = 65 y = 100
Entonces m = (100-0)/(65-3) = 100/62
y = 100/62*(x-3)
Cuando x = 3 ohms tienes 0 % del tanque
Cuando x = 65 ohms tiense 100% del tanque
Pero ocurre que mides Tension y no R pero veamos por ahora lo que SI tenemos
y [en %]= 100/62*(x-3)
Esta ecuación nos da 0 para x= 3 y 100 para x = 65. Perfecto!!!

Por otro lado del divisor de tensión tengo la otra ecuación.

Vadc = 5V * R / (R+230)
despejando queda que
R = 230*Vadc/(5-Vadc) o divido x Vadc a ver si queda mejor
R = 230/(5/Vadc-1)
Este es el x anterior asi que

La ecuación de tu flotante será
y = 100/62 * (230/(5/Vadc-1)-3)
puede parecer complicado pero ya veras

//Nivel de combustible

const int SEGMENTS = 7;
const int SEG_PINS[SEGMENTS] = {4, 8, 11, 9, 2, 5, 12};
const int DP_PIN = 10;
const int DIGITS = 3;
const int DIG_PINS[DIGITS] = {3, 6 , 7,};
const int SYMBOL_COUNT = 10;


const int SYMBOLS[SYMBOL_COUNT][SEGMENTS] = {//ANODO COMUN CAMBIAR LOW,HIGH
  {0, 0, 0, 0, 0, 0, 1}, //| 0
  {1, 0, 0, 1, 1, 1, 1}, //| 1
  {0, 0, 1, 0, 0, 1, 0}, //| 2
  {0, 0, 0, 0, 1, 1, 0}, //| 3
  {1, 0, 0, 1, 1, 0, 0}, //| 4
  {0, 1, 0, 0, 1, 0, 0}, //| 5
  {0, 1, 0, 0, 0, 0, 0}, //| 6
  {0, 0, 0, 1, 1, 1, 1}, //| 7
  {0, 0, 0, 0, 0, 0, 0}, //| 8
  {0, 0, 0, 0, 1, 0, 0}, //| 9

};

const int ITERATIONS = 50;
const int DELAY = 4;
//const int analogPin = A0;
int value;      //variable que almacena la lectura analógica raw
int position;   //posicion del potenciometro en tanto por ciento
int Vout = 0;
int Rc = 0;
//int   lpadc = A0;
float lpv = 0;
int   lpp = 0;
int pladc = 0;
int P2 = A0; // ANALOG IN: A2, va al terminal intermedio del potenciómetro.
float valor = 0;
float deceroauno;
int valor1 = 0;
int porciento = 0;
float R2 = 63.0, R1 = 230.0;
// 


void setup() {
  
  //pinMode(zumbador,OUTPUT);
  for (int i = 0; i < SEGMENTS; i++) {
    pinMode(SEG_PINS[i], OUTPUT);
  }
  pinMode(DP_PIN, OUTPUT);
  for (int i = 0; i < DIGITS; i++) {
	   pinMode(DIG_PINS[i], OUTPUT);
  }
  
  analogReference(INTERAL);
}

void loop() {
  displayNivelCombustible(getNivelCombustible(30));
  // pitaTemp(vigilaTemp());
}

float getNivelCombustible(int samplesNumber) {
	float Vadc;
	long sum = 0;
	// y = 100/62 * (230/(5/Vadc-1)-3)
	for (int i = 0; i < samplesNumber; i++)   {
		sum += analogRead(A0);
	}
	Vadc= sum * 0.0010752688/samplesNumber; // 0.0010752688 = (1.1 / 1023);
	// 100/62 = 1.6129032258
	valor =  1.6129032258*(230/(5/Vadc-1)-3); expresado en % 0 a 100
	return  valor;
}

void displayNivelCombustible(int measureN) {
  int int_part = measureN;
  int digits[3];

  digits[0] = int_part % 1000 / 100;
  digits[1] = int_part % 100 / 10;
  digits[2] = int_part  % 100 % 10;

  if (digits[2] == 10) {
    digits[2] = 0;
    digits[1]++;
    if (digits[1] == 10) {
      digits[1] = 0;
      digits[0]++;
    }
  }

  for (int i = 0; i < ITERATIONS; i++) {
    displaySymbol(0, digits[0], 0);
    delay(DELAY);
    displaySymbol(1, digits[1], 0);
    delay(DELAY);
    displaySymbol(2, digits[2], 0);
    delay(DELAY);
  }
}
void displaySymbol(int digit, int symbol, int dp) {
  //| Check arguments are between ranges.
  if (digit < 0 || digit >= DIGITS) {
	return;
  }
  if (symbol < 0 || symbol > SYMBOL_COUNT) {
    return;
  }
  for (int i = 0; i < DIGITS; i++) {
    if (i == digit) {
      digitalWrite(DIG_PINS[i], HIGH);
    }
    else {
      digitalWrite(DIG_PINS[i], LOW);
    }
  }
  for (int i = 0; i < SEGMENTS; i++) {
    digitalWrite(SEG_PINS[i], SYMBOLS[symbol][i] ? HIGH : LOW);
  }
  if (dp) {
    digitalWrite(DP_PIN, LOW);
  }
  else {
    digitalWrite(DP_PIN, HIGH);
  }
}

Sdos, aunque me lleve un regaño tambien me lleve un regalo, el amigo Surbyte me mostro como quedaria el codigo para mi medicion de tanque de combustible, ayer lo hice y funciona bastante bien, digo bastante bien porque todavia tengo que acotar algunas cosas, me esta dando saltos en la lectura, que pudiera ser por la inestabilidad del montaje en protoboard, o que la R que he logrado hacer no es exactamente de 230 ohms, vivo en Cuba y no me es posible comprar un preset como me sugirio Surbyte, por lo tanto dos R en serie que no he logrado llevar a 230 ohms exactamente. otra cosa que pudiera estar incidiendo es que todo lo tengo montado a partir del voltage que entrega el puerto usb de la PC, hoy voy a montarlo con una bateria de 12 Volt a ver si estabiliza un poco. Al codigo que me envio Surbyte le adicione una convercion de porciento a litros para que este sea el valor que se vea en los display. Seguire informando de como va la cuestion. Sdos y gracias una ves mas.

Hola @mhgarrote.
El regaño fue por abrir dos hilo nada mas.
Dime que resistencias tienes como para pensar en posibles soluciones. Recuerda que puedes hacer Series y Paralelos y conseguir lo que se desea.
Los saltos pueden deberse al protoboard pero... hay que mirar mas el código.
Tienes 4 mseg de delay entre digito y digito, no creo que sea eso.

Ahora detengámosnos un instante y trabajemos con una presentación mas rapida.
Este es el problema

for (int i = 0; i < ITERATIONS; i++) {
    displaySymbol(0, digits[0], 0);
    delay(DELAY);
    displaySymbol(1, digits[1], 0);
    delay(DELAY);
    displaySymbol(2, digits[2], 0);
    delay(DELAY);
  }

tienes 4 x 3 = 12 mseg x 50 iteracciones o sea 50x12mseg = 600 mseg o sea mas de medio segundo.
Olvida eso. Presenta una ves y afuera.
Si luego resulta que es muy feloz, le pondremos algo para presentar sin consumir tiempo.
Ve a Documentación => indice de temas tutoriales => millis() y entederás lo que te voy a modificar ahora.

Ahora comprendo. Has cambiado la presentación para que se exprese en litros y lo has hecho mal. No se cambia ahi, se cambia antes.

Bueno comienzo a ver mas errores en el código de ambos.
Haces todas las cuentas con float y luego presentas enteros. Debes decidirte!!
O usas una cosa o la otra.
Si vas a presentar con enteros para que arrastras float?
En algun punto has las cuentas como gustes pero luego convierte a enteros.
Mira como yo he cambiado esa parte.
Tambien te agregué una Constante que se expresan en Mayúsculas que llamé TANQUE y puse por ejemplo 50 litros asi que ese número lo pones por el valor que corresponda a tu carro.
Quité tambien el SAMPLESNUMBER y lo puse fijo al comienzo.
Finalmente

//Nivel de combustible

#define TANQUE        50  // cambiar 50 por el valor de tu tanque
#define SAMPLESNUMBER 20  // 30 muestras me parece mucho pero luego lo mejoramos.
#define INTERVALO   1000  // cada 1 segundo presenta valores en el display, este valor modificalo a tu gusto
const int SEGMENTS = 7;
const int SEG_PINS[SEGMENTS] = {4, 8, 11, 9, 2, 5, 12};
const int DP_PIN = 10;
const int DIGITS = 3;
const int DIG_PINS[DIGITS] = {3, 6 , 7,};
const int SYMBOL_COUNT = 10;

const int SYMBOLS[SYMBOL_COUNT][SEGMENTS] = {//ANODO COMUN CAMBIAR LOW,HIGH
  {0, 0, 0, 0, 0, 0, 1}, //| 0
  {1, 0, 0, 1, 1, 1, 1}, //| 1
  {0, 0, 1, 0, 0, 1, 0}, //| 2
  {0, 0, 0, 0, 1, 1, 0}, //| 3
  {1, 0, 0, 1, 1, 0, 0}, //| 4
  {0, 1, 0, 0, 1, 0, 0}, //| 5
  {0, 1, 0, 0, 0, 0, 0}, //| 6
  {0, 0, 0, 1, 1, 1, 1}, //| 7
  {0, 0, 0, 0, 0, 0, 0}, //| 8
  {0, 0, 0, 0, 1, 0, 0}, //| 9

};

int value;      //variable que almacena la lectura analógica raw
int position;   //posicion del potenciometro en tanto por ciento
float valor;
float deceroauno;
int porciento = 0;
float R2max = 63.0, 
      R2min =  3.0,
      R1 = 230.0;
unsigned long startNivel;

void setup() {
  
  for (int i = 0; i < SEGMENTS; i++) {
      pinMode(SEG_PINS[i], OUTPUT);
  }
  pinMode(DP_PIN, OUTPUT);
  for (int i = 0; i < DIGITS; i++) {
      pinMode(DIG_PINS[i], OUTPUT);
  }
  analogReference(INTERAL);
}

void loop() {
  if (millis() - startNivel > INTERVALO) {
      displayNivelCombustible(getNivelCombustible());
      startNivel = millis();
  }
  // pitaTemp(vigilaTemp());
}

float getNivelCombustible() {
  float Vadc;
  long sum = 0;
  
  // y = 100/62 * (230/(5/Vadc-1)-3)
  for (int i = 0; i < SAMPLESNUMBER; i++)   {
      sum += analogRead(A0);
  }
  
  Vadc= sum * 0.0010752688/samplesNumber; // 0.0010752688 = (1.1 / 1023);
  // 100/(R2max - R2min) = 1.6129032258
  
  valor =  1.6129032258*(R1/(5/Vadc-1)-R2min); expresado en % 0 a 100
  // convierte acá a litros.
  return  valor;
}

void displayNivelCombustible(float valorMedido) {
  int digits[3];
  int xlitros;
  
  // regla de tres simple para cambiar de % a litros
  // porque tenemos 100% para tanque lleno en X litros
  //
  //         100% _________________ TANQUE `en litros]
  // valorMedido% _________________ xlitros = x% * TANQUE / 100 =

  xlitros = valorMedido * TANQUE /100;

  // espero que esto funcione, no es lo que yo puse en el código.
  digits[0] = xlitros % 1000 / 100;
  digits[1] = xlitros % 100 / 10;
  digits[2] = xlitros / 10 % 10;

  displaySymbol(0, digits[0], 0);
  displaySymbol(1, digits[1], 0);
  displaySymbol(2, digits[2], 0);
}

void displaySymbol(int digit, int symbol, int dp) {
  //| Check arguments are between ranges.
  if (digit < 0 || digit >= DIGITS) {
  return;
  }
  if (symbol < 0 || symbol > SYMBOL_COUNT) {
    return;
  }
  for (int i = 0; i < DIGITS; i++) {
    if (i == digit)
      digitalWrite(DIG_PINS[i], HIGH);
    else 
      digitalWrite(DIG_PINS[i], LOW);
  }
  for (int i = 0; i < SEGMENTS; i++) {
      digitalWrite(SEG_PINS[i], SYMBOLS[symbol][i] ? HIGH : LOW);
  }
  if (dp)
      digitalWrite(DP_PIN, LOW);
  else 
      digitalWrite(DP_PIN, HIGH);
}

El codigo del post anterior descuadra un poco las cosas en lo referente a los display, como estaba en la primera compilacion quedaba bien, solo creo que hay un problema de ajustes, hagamos una cosa, voy a tratar de resolver los problemas fisicos primero, digamos la R con el valor que requiere, ponerlo a una bateria que me de voltage estable, porque es como si hubiera ruido osea los saltos son en los valores, no en los display, estos tienen la misma configuracion que en los proyectos anteriores y van bastante bien, dejo aqui codigo con la modificacion a litros que habia hecho, veremos que crees. Sdos y gracias.

//Nivel de combustible

const int SEGMENTS = 7;
const int SEG_PINS[SEGMENTS] = {4, 8, 11, 9, 2, 5, 12};
const int DP_PIN = 10;
const int DIGITS = 3;
const int DIG_PINS[DIGITS] = {3, 6 , 7,};
const int SYMBOL_COUNT = 10;


const int SYMBOLS[SYMBOL_COUNT][SEGMENTS] = {//ANODO COMUN CAMBIAR LOW,HIGH
  {0, 0, 0, 0, 0, 0, 1}, //| 0
  {1, 0, 0, 1, 1, 1, 1}, //| 1
  {0, 0, 1, 0, 0, 1, 0}, //| 2
  {0, 0, 0, 0, 1, 1, 0}, //| 3
  {1, 0, 0, 1, 1, 0, 0}, //| 4
  {0, 1, 0, 0, 1, 0, 0}, //| 5
  {0, 1, 0, 0, 0, 0, 0}, //| 6
  {0, 0, 0, 1, 1, 1, 1}, //| 7
  {0, 0, 0, 0, 0, 0, 0}, //| 8
  {0, 0, 0, 0, 1, 0, 0}, //| 9

};

const int ITERATIONS = 50;
const int DELAY = 4;
int P2 = A0; // ANALOG IN: A2, va al terminal intermedio del potenciómetro.
float valor = 0;
int valor1 = 0;
float R2 = 64.5, R1 = 230.0;
int llenado=0;
int capt=40;

void setup() {
  
  
  for (int i = 0; i < SEGMENTS; i++) {
    pinMode(SEG_PINS[i], OUTPUT);
  }
  pinMode(DP_PIN, OUTPUT);
  for (int i = 0; i < DIGITS; i++) {
     pinMode(DIG_PINS[i], OUTPUT);
  }
  
  analogReference(INTERNAL);
}

void loop() {
  displayNivelCombustible(getNivelCombustible(50));
  
}

float getNivelCombustible(int samplesNumber) {
  float Vadc;
  long sum = 0;  // y = 100/62 * (230/(5/Vadc-1)-3)
  for (int i = 0; i < samplesNumber; i++)   {
    sum += analogRead(A0);
  }
  Vadc= sum * 0.0010752688/samplesNumber; // 0.0010752688 = (1.1 / 1023);
  // 100/62 = 1.6129032258
  valor =  1.6129032258*(230/(5/Vadc-1)-3); //expresado en % 0 a 100
  llenado=capt*valor/100;
  
  return  llenado;
}

void displayNivelCombustible(int measureN) {
  int int_part = measureN;
  int digits[3];

  digits[0] = int_part % 1000 / 100;
  digits[1] = int_part % 100 / 10;
  digits[2] = int_part  % 100 % 10;

  if (digits[2] == 10) {
    digits[2] = 0;
    digits[1]++;
    if (digits[1] == 10) {
      digits[1] = 0;
      digits[0]++;
    }
  }

  for (int i = 0; i < ITERATIONS; i++) {
    displaySymbol(0, digits[0], 0);
    delay(DELAY);
    displaySymbol(1, digits[1], 0);
    delay(DELAY);
    displaySymbol(2, digits[2], 0);
    delay(DELAY);
  }
}
void displaySymbol(int digit, int symbol, int dp) {
  //| Check arguments are between ranges.
  if (digit < 0 || digit >= DIGITS) {
  return;
  }
  if (symbol < 0 || symbol > SYMBOL_COUNT) {
    return;
  }
  for (int i = 0; i < DIGITS; i++) {
    if (i == digit) {
      digitalWrite(DIG_PINS[i], HIGH);
    }
    else {
      digitalWrite(DIG_PINS[i], LOW);
    }
  }
  for (int i = 0; i < SEGMENTS; i++) {
    digitalWrite(SEG_PINS[i], SYMBOLS[symbol][i] ? HIGH : LOW);
  }
  if (dp) {
    digitalWrite(DP_PIN, LOW);
  }
  else {
    digitalWrite(DP_PIN, HIGH);
  }
}

En lo referente a las variables, debo ajustarlas tambien, tienes razon en lo del uso de diferentes tipos, voy a chequear eso tambien.

Es solo un ajuste a como ves las cosas.
Recuerda que las constantes se definen con mayúsculas sea con

#define INTERVALO 20
const int TANQUE 60

y las variables al menos comienza con minúsculas y luego usa lo que te sirva para manejarte bien

int sensorNivelAlto;

Esto es algo de lo que yo suelo valerme para entender mejor lo que estoy programando.