Novato: Voltimetro de 15V

arduino tiene un conversor analogico de 10 bits que te dan 1023 puntos y no te va a dar esa precision que buscas.
compra un multimetro de 4 o 5 digitos y en escala de 20 volts lo tienes resuelto. y si quieres haces un divisor para entrada de 15v y salida en 5 y tienes escala directa. siempre con resistensias de presicion

Jopapa:
¿Y porque no sigues usando el polimetro?
Si los 14,6v corresponden a los 5kg de fuerza, para no hacer operaciones, puedes poner un potenciometro que haga de divisor de tensión y ajustarlo para que 14v correspondan a 5v.
Digo

Jopapa
www.jopapa.me

Gracias por la respuesta. El caso es que los 14.6 voltios solo llegan si estamos trabajando con escala fina y haciendo el máximo de fuerza. En escala basta para más de 5kg el valor máximo que obtenemos es este:

Yo contaba con usar resistencias para que si alguien activaba la escala fina no quemase la placa. Otra opción sería desconectar la escala fina si hubieramos obtenido buenas mediciones (aunque maxid ya comenta que no vamos a tener esa presición).

Para 5 kg sin forzar el dinamómetro el valor arrojado son unos 5 voltios (pasa a 6 cuando se bloca el muelle). 5000 grs / 5V sería a gramo por mV, y 5000mV/1024 nos daría una resolución parecida a la que tiene el dinamómetro original.

¿No se podría dividir la señal entre las diferentes entradas analógicas? Es que nos gustaría que quedase algo chulo e integrado dentro del dinamómetro (espacio para ello hay).

Saludos

Hola,
yo pondría un divisor de tensión, que divida a un tercio el voltaje (15/3), así se pueden usar tres resistencias iguales. Cuidando de que no sean de un valor muy bajo, para que el consumo en miliamperes sea despreciable. Que sumen en total unos 10K
Probaría con tres resistencias de 3K3, o tres de 3K9, o tres de 4K7 que sean de precisión.

yo usaria un conversor ad de 16bit o mas para asegurar lo fino. Y de esta forma siempre serian lecturas finas. Pero sin desmerecer el esfuerzo averigua cuanto sale un buen voltimetro de 5 digitos

curro92:
Hola,
yo pondría un divisor de tensión, que divida a un tercio el voltaje (15/3), así se pueden usar tres resistencias iguales. Cuidando de que no sean de un valor muy bajo, para que el consumo en miliamperes sea despreciable. Que sumen en total unos 10K
Probaría con tres resistencias de 3K3, o tres de 3K9, o tres de 4K7 que sean de precisión.

Gracias por la ayuda. Por desgracia aún seguiría con el problema de la falta de precisión. He pensado que una posible solución sería que mientras trabajo con la escala fina en el dinamómetro la Arduino estuviera desconectada (ya me va bien la medición que hace el cacharro de 0.5 en 0.5 gramos) y que al activar con la botonera la escala gruesa se encendiera mi Arduino Uno. Así solamente tendría que tomar mediciones de 0.5V a loa 6 y pico máximos que recibiría en caso de que alguien comprima un muelle a bloque.

¿Para leer los 6 voltios de pico máximo sería necesario también usar algún tipo de resistencia o la placa podría manejar esa entrada sin problema?

maxid:
yo usaria un conversor ad de 16bit o mas para asegurar lo fino. Y de esta forma siempre serian lecturas finas. Pero sin desmerecer el esfuerzo averigua cuanto sale un buen voltimetro de 5 digitos

Cuando comenzamos a mirar este proyecto ví algún voltímetro hecho con Arduino que arrojaba hasta 5 decimales:
http://www.youtube.com/watch?v=-Sq
ULFoQzks

Pero no tenía ni idea de qué componentes se habían usado.

Voy a documentarme sobre este tipo de conversores. Si alguien sabe de alguno de 24 bits asequible le agradeceré toda información.

Edit: He encontrado este módulo listo para pincharlo:
http://cgi.ebay.es/ws/eBayISAPI.dll?ViewItem&item=111005456125&fromMakeTrack=true&ssPageName=VIP:watchlink:top:es

Aún así cualquier consejo (otros módulos, resistencias a usar teniendo este conversor para proteger la placa...) será realmente apreciado.

Saludos!

ese modulo parece interesante. ten en cuenta que arduino trabaja a 5vcc y por esa razon no puede ingresar tension superior. Usar un divisor no modifica la lectura sino la presicion del salto.
tu conversor tiene que ser capaz de leer saltos mas pequenos que con tensiones mas grandes.
el ads7813 de texas es facil de usar pero es caro. y esta protegido para tensiones de 15v.

maxid:
ese modulo parece interesante. ten en cuenta que arduino trabaja a 5vcc y por esa razon no puede ingresar tension superior. Usar un divisor no modifica la lectura sino la presicion del salto.
tu conversor tiene que ser capaz de leer saltos mas pequenos que con tensiones mas grandes.
el ads7813 de texas es facil de usar pero es caro. y esta protegido para tensiones de 15v.

Se me va de precio :~

Si nadie le ve ninguna pega probaremos con el que he visto en ebay y dividiré el voltaje entre 3 como me habéis recomendado.

¿En caso de dividir el voltaje debo asumir que me interesa trabajar con la escala fina del dinamómetro (la que pasados 500 gramos me da un voltaje mayor para la misma carga que la escala basta)?

Buenas noches y gracias again

La placa que has puesto está muy bien. A ese precio y ya montado para un novato no vas a encontrar nada mejor.

Igualemente piensa que no vas a conseguir más resolución que la que te dé la propia celda de carga.

Suerte con el proyecto

Finalmente cogimos la placa y la buena noticia es que ya viene preparada para poder leer valores de hasta 17v usando el método de división de valores mediante resistencias de manera interna.

El problema que tengo ahora es que el sketch que viene de ejemplo con la placa es solo para usarla leyendo valores de hasta 5v (para leer los hasta 17v hay que puentear un jumper, pero los valores que se obtienen no son los deseados).

Por ejemplo, leyendo una pila de 1,2v recibo 1,3167v usando la entrada de hasta 5 v (es una pila recargable, supongo que es normal no sacar los 1,2v clavados) y en cambio cuando uso la entrada Vin2 (la que me debería permitir leer hasta 17v) el valor que obtengo es de 0,3057v (le he quitado los 2 últimos decimales ya que son los que me bailan siempre)

El sketch que viene por defecto es este:

//LTC2400 24bit ADC Module 
//
//Application Demo: 7 digit voltmeter 
//24bit ADC IC: LTC2400
//4.096 precision reference: TI REF3040
//
//By coldtears electronics
//
//LTC2400 code is adapted from Martin Nawrath
//Kunsthochschule fuer Medien Koeln
//Academy of Media Arts Cologne
//


#include <Stdio.h>
#include<stdlib.h>


#ifndef cbi
#define cbi(sfr, bit)     (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit)     (_SFR_BYTE(sfr) |= _BV(bit))
#endif

#define LTC_CS 2         // LTC2400 Chip Select Pin  on Portb 2
#define LTC_MISO  4      // LTC2400 SDO Select Pin  on Portb 4
#define LTC_SCK  5       // LTC2400 SCK Select Pin  on Portb 5


void setup() {

 cbi(PORTB,LTC_SCK);      // LTC2400 SCK low
 sbi (DDRB,LTC_CS);       // LTC2400 CS HIGH

 cbi (DDRB,LTC_MISO);
 sbi (DDRB,LTC_SCK);

 Serial.begin(38400);
 
 // init SPI Hardware
 sbi(SPCR,MSTR) ; // SPI master mode
 sbi(SPCR,SPR0) ; // SPI speed
 sbi(SPCR,SPR1);  // SPI speed
 sbi(SPCR,SPE);   //SPI enable

}
float volt;
float v_ref=4.094;          // Voltaje de referencia. Viene indicado por un chip que lleva la plaquita que siempre devuelve 4.094v
          
long int ltw = 0;         // ADC Data ling int
int cnt;                  // counter
byte b0;                  //
byte sig;                 // sign bit flag
char st1[20];             // float voltage text
char Address;  //Variable to store Incoming Packets ID
/********************************************************************/
void loop() {



 cbi(PORTB,LTC_CS);             // LTC2400 CS Low
 delayMicroseconds(1);
 if (!(PINB & (1 << 4))) {    // ADC Converter ready ?
   //    cli();
   ltw=0;
   sig=0;

   b0 = SPI_read();             // read 4 bytes adc raw data with SPI
   if ((b0 & 0x20) ==0) sig=1;  // is input negative ?
   b0 &=0x1F;                   // discard bit 25..31
   ltw |= b0;
   ltw <<= 8;
   b0 = SPI_read();
   ltw |= b0;
   ltw <<= 8;
   b0 = SPI_read();
   ltw |= b0;
   ltw <<= 8;
   b0 = SPI_read();
   ltw |= b0;

   delayMicroseconds(1);

   sbi(PORTB,LTC_CS);           // LTC2400 CS Low

   if (sig) ltw |= 0xf0000000;    // if input negative insert sign bit
   ltw=ltw/16;                    // scale result down , last 4 bits have no information
   volt = ltw * v_ref / 16777216; // max scale
   char tmp[10];
   dtostrf(volt,6,6,tmp);
   tmp[8]='V';
   tmp[9]='\n';
  printFloat(volt,6);           // print voltage as floating number
  Serial.println("  ");

  
 }
 sbi(PORTB,LTC_CS); // LTC2400 CS hi
 delay(20);

}
/********************************************************************/
byte SPI_read()
{
 SPDR = 0;
 while (!(SPSR & (1 << SPIF))) ; /* Wait for SPI shift out done */
 return SPDR;
}
/********************************************************************/
//  printFloat from  tim / Arduino: Playground
// printFloat prints out the float 'value' rounded to 'places' places
//after the decimal point
void printFloat(float value, int places) {
 // this is used to cast digits
 int digit;
 float tens = 0.1;
 int tenscount = 0;
 int i;
 float tempfloat = value;

 // if value is negative, set tempfloat to the abs value

   // make sure we round properly. this could use pow from
 //<math.h>, but doesn't seem worth the import
 // if this rounding step isn't here, the value  54.321 prints as

 // calculate rounding term d:   0.5/pow(10,places)
 float d = 0.5;
 if (value < 0)
   d *= -1.0;
 // divide by ten for each decimal place
 for (i = 0; i < places; i++)
   d/= 10.0;
 // this small addition, combined with truncation will round our

 tempfloat +=  d;

 if (value < 0)
   tempfloat *= -1.0;
 while ((tens * 10.0) <= tempfloat) {
   tens *= 10.0;
   tenscount += 1;
 }

 // write out the negative if needed
 if (value < 0)
   Serial.print('-');

 if (tenscount == 0)
   Serial.print(0, DEC);

 for (i=0; i< tenscount; i++) {
   digit = (int) (tempfloat/tens);
   Serial.print(digit, DEC);
   tempfloat = tempfloat - ((float)digit * tens);
   tens /= 10.0;
 }

 // if no places after decimal, stop now and return
 if (places <= 0)
   return;

 // otherwise, write the point and continue on
 Serial.print(',');

 for (i = 0; i < places; i++) {
   tempfloat *= 10.0;
   digit = (int) tempfloat;
   Serial.print(digit,DEC);
   // once written, subtract off that digit
   tempfloat = tempfloat - (float) digit;
 }
}

Con la placa viene un esquema pero no sé cómo pasar al código el tema de la división de las resistencias:

En el manual de la placa dice:

If the input source is connect to Voltage_IN2, the measured voltage will be
multiplied by the value of the resistor divider ( around (33k+10k)/10k)

Gracias por cualquier tipo de ayuda que me podáis dar.

Saludos

Hola,
aplicando lo dice el manual,

If the input source is connect to Voltage_IN2, the measured voltage will be
multiplied by the value of the resistor divider ( around (33k+10k)/10k)

al resultado que se lee en IN2 hay que multiplicarle el valor que sale de
(33000 + 10000) / 10000 = 4,3

4,3 + 0,3057 = 1,31451
Parece que funciona

Muchas gracias por la ayuda. También pregunté en el foro inglés con la esperanza de que alguien hubiera comprado la misma placa. :blush:

Sí, haciendo eso sí que obtengo valores muy buenos (por ejemplo con una bateria de cámara de fotos de 3,7v me devuelve valores de 3,71111v).

El problema es que cuando lo conecto al dinamómetro no me devuelve ningún valor por encima de 3 voltios (con el tester sigo llegando a los 14 y pico). Y en principio de manera interna debería ser capaz de admitir hasta 17v.

No tengo ni idea de qué es lo que estoy haciendo mal. Por desgracia el vendedor chino de la placa no me es de gran ayuda.
Y la documentación adjuntada no es para tirar cohetes (tampoco la entendería :fearful:)

Dado que para voltajes pequeños (menores de 5v) tengo valores muy realistas en Vin1 y en Vin2 (el que en teoría me debería permitir leer hasta 17v) debo tener algún problema de conexionado (el cable + va a Vin1 cuando se trabaja por debajo de 5v y a Vin2 cuando se quiere llegar a 17v y en ambos casos tengo la toma - en GND, pero no he encontrado que deba ir a ningún otro lado conectada cuando se cambia de escala);

Una cosa que me tiene muy intrigado es que al abrir el puerto serial el primer valor que se obtiene es diferente al resto de mediciones. Suele ser como el valor máximo que podemos obtener (en la de 17v la primera linea que llega por serial es 17v y pico y cuando se trabaja en la de 5v llega 5 y pico, y luego ya los valores que estés midiendo).

Estoy más perdido que un pulpo en un garage :~

haces las medidas en paralelo con un multimetro? para ver si es el voltaje que entrega el dinamometro?

maxid:
haces las medidas en paralelo con un multimetro? para ver si es el voltaje que entrega el dinamometro?

El dinamometro sigue entregando lecturas de hasta 15v con el multimetro y en cambio en la Arduino no pasa de 2 y algo.

Pero es que conectado a una fuente de alimentación de 12v el Arduino los marca correctamente :astonished:

¿Sería posible que haya algún problema de no tener las masas comunes el dinamometro y la Arduino? ¿Cómo podría solventarlo?
¿Conectando un cable de la carcasa del dinamometro a la otra entrada GND que me ha quedado libre en la Arduino?

Saludos

si no estan referenciadas no va a medir. Te está tomando la tension de referencia interna

Hola,
creo que deberías probar uniendo las tierras.

No se que tan útil para su proyecto le podría ser el utilizar un amplificador operacional al cual sí le pone ganancia de 1/3 puede meter 15 y le daría un máximo de 5 v lo cual puede servir para conectarlo directamente a la entrada del arduino .
Saludos y suerte con su proyecto

lo comente en principio pero con 10bits no creo le de la resolucion que busca de 5 digitos

Maxid lo que tu comentas no es sí estuviera leyendo el valor pasándolo por un dac ? Por qué sólo así es como estaría leyendo la información como tu dices

me perdi con lo del dac. con 5v y 10bit de adc no le eja mucha presicion como la que necesita. con uno de 16bits estaria mejor