Show Posts
Pages: [1] 2
1  International / Español / Re: Novato: Voltimetro de 15V on: February 27, 2014, 02:34:26 pm
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  smiley-eek

¿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
2  International / Español / Re: Novato: Voltimetro de 15V on: February 26, 2014, 04:03:36 pm
Muchas gracias por la ayuda. También pregunté en el foro inglés con la esperanza de que alguien hubiera comprado la misma placa.  smiley-red

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  smiley-eek-blue)

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  smiley-confuse
3  Using Arduino / Programming Questions / Re: Resistor divider doubt on: February 26, 2014, 04:48:53 am
Hello again.

The Arduino is giving us reliable result for voltages lower than 5v.

 smiley-confuse

I've been trying to contact with the dealer of the 24 ADC bits converter board but he doens't give any solution.

In theory it could manage voltages up to 17v. Is there anyone out here that have the same board or any idea of what we're doing wrong?

Thanks again for your help.

Greets from Barcelona
4  Using Arduino / Programming Questions / Re: Resistor divider doubt on: February 23, 2014, 11:05:05 am

I tried to modify the code:
Code:
Serial.print(',');
 for (i = 0; i < places; i++) {
   tempfloat *= 10.0;
   digit = (int) tempfloat;
   digit2 = digit * 4.3; //I'm not sure if this is the way of multiplying the value :S Pathetic, I Know

So, you do not know well (at all?) this sketch?

Near the top of the loop there are:
Code:
   ltw=ltw/16;                    // scale result down , last 4 bits have no info
   volt = ltw * v_ref / 16777216; // max scale

Is ltw the result of the scale read?
What is volt?  Some conversion?

What if "we" change that to:
Code:
   ltw=(ltw/16)*4.3;               // scale result down , last 4 bits have no info
   volt = ltw * v_ref / 16777216; // max scale

or
Code:
   ltw=ltw/16;                    // scale result down , last 4 bits have no infO
   volt = (ltw * v_ref / 16777216)*4.3; // max scale
??



Yeh, thanks a lot again. I just edited when I saw the way of solving it.

Thanks a lot for your help.
5  Using Arduino / Programming Questions / Re: Resistor divider doubt on: February 23, 2014, 10:11:55 am
EDIT: I got it!!

Thanks a lot for your help.

Code:
//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(115200);
 
 // 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 = 4.3 * (ltw * v_ref / 16777216); // max scale
   char tmp[10];
   dtostrf(volt,6,6,tmp);
   tmp[8]='V';
   tmp[9]='\n';
  printFloat(volt,4);           // 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;
 int digit2;
 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;
 }
}

6  Using Arduino / Programming Questions / Resistor divider doubt on: February 23, 2014, 09:16:23 am
Hello from Barcelona

In my company we do have a dinamometer to measure load of the compression springs we do produce.

It can measure forces form 0g to 5000g and it works with two scales. With the first scale it can measure from 0g to 500g with 0,5g steps and the second scale let's us measure from up to 5000g with 5g steps.

The first scale is just fine for our porposes but the second one is not as much accurated as we need.
We have notice that the machine has two outputs where you can get a voltage that increases as you are compressing the springs:







On each scale the max value you can get in the segment's light screen is


When you reach that value you have to pass to the second scale if you were at the first one and stop compressing the spring if you already were in the second one. But if you keep compressing the spring you get higher values with a voltimeter while the dinamometer screen is freezed:


So we wanted to create a voltimeter using one Arduino Uno to be able to measure the voltage changing int he second scale and determinate the load of the springs with the same precision for loads bigger than 500g.

As the Uno was only able to give us 1024 steps of resolution using the analog inputs we found on ebay a 24bits ADC module that would give us up to 6 decimal places values:

http://cgi.ebay.es/ws/eBayISAPI.dll?ViewItem&item=111005456125&fromMakeTrack=true&ssPageName=VIP:watchlink:top:es



One of the good thing of this module is that it can get up to 17v inputs, so we had not to be afraid about using resistors to protect our Arduino. To allow up to 17v measures you have to shorter a jumper. Our dinamometer can output up to 15,6 volts when you are blocking something against the load cell.

With the module comes an sketch:
Code:
//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
/****************/
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;
 }
}

Our problem is that when we try to read from Vin2 (the pin that allows up to 17v) we do not get realistic data
(for example, a 1,2 volts rechargeable battery gives back 0,30567v and when we were trying on the Vin1 it was 1,31677v.)

With the module there was a PDF explaining that when you allow the Vin2 shortening a jumper the value of the voltage (up to 17v) was obtained doing a resistor divider opertion, but I haven't seen anything of this in the code provided (I'm a total newbie with Arduino, I'm going to send the data via serial port to work with a program writted in Autoit, wich i'm not as newbie)

The PDF that comes with the board claims:
Quote
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)

And there is this electrical schematic:


But I don't have any idea of how to get the resistor division inside the code
I have tried to contact with the seller of the board but I get no results.

Any kind of help would be trully apreciatted.

Greets from Barcelona
7  International / Español / Re: Novato: Voltimetro de 15V on: February 22, 2014, 03:07:54 pm
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:
Code:
//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:
Quote
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
8  International / Español / Re: Novato: Voltimetro de 15V on: January 22, 2014, 04:51:18 pm
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  smiley-confuse

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
9  International / Español / Re: Novato: Voltimetro de 15V on: January 22, 2014, 03:36:07 pm
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?



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:

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!
10  International / Español / Re: Novato: Voltimetro de 15V on: January 22, 2014, 12:01:37 am
¿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
11  International / Español / Novato: Voltimetro de 15V on: January 21, 2014, 05:12:27 pm
Muy buenas noches a todos.

En mi trabajo tenemos un dinamómetro con el que medimos la fuerza de los muelles que fabricamos.

Se basa en una célula de carga contra la que comprimimos los muelles y obtenemos la fuerza que estos hacen al ser comprimidos en un display digital:

(detalle de la célula de carga)


(display donde vemos la carga de los muelles comprimidos).

El dinamómetro nos permite medir muelles de hasta 5kg de fuerza y el display muestra los valores redondeando de 0.5 en 0.5 gramos:

(en este caso estaríamos midiendo un muelle que hace 342.5 gramos)

El problema con el que nos encontramos es que una vez llegamos a los 500 gramos de fuerza el display se queda bloqueado y tenemos que cambiar la escala de medición. A hacer esto el display nos marca la fuerza del muelle pero el redondeo pasa a ser de 5 en 5 gramos (vamos, que el último dígito del display es siempre un 5 o un 0).

(Display bloqueado al pasar de los 500 gramos)


(Trabajando con la escala gruesa).

El dinamómetro tiene dos salidas en su parte posterior que servían en su día para conectar el equipo a otros aparatos de medición. Hemos comprobado con el voltímetro y en todo momento obtenemos valores que varían según aumentamos o disminuimos la fuerza medida con la célula de carga:




Una cosa que nos ha llamado mucho la atención es que aunque estemos en la escala fina y el display esté bloqueado porque hemos pasado de 500 gramos la medición con el voltímetro sí que aumenta conforme más comprimimos es muelle:


Por lo que nos gustaría añadir un segundo display al dinamómetro para poder leer el voltaje que nos dan las dos salidas del dinamómetro y, haciendo una regla de 3, obtener la fuerza en gramos de los muelles en saltos de 0.5 gramos cuando el display se quede bloqueado en la escala fina más allá de los 500 gramos.

He visto varios ejemplos de voltímetros para 12 y 14V (nuestra célula de carga nos ha dado un pico máximo de 14,6V y a partir de ahí no pasa). Pero no acabo de tener muy claro como tengo que reducir de esos 14V máximos a los 5V que podré leer sin cargame mi Arduino Uno. Otra cosa que me genera dudas es cómo debo conectar los cables que irán de la Arduino al dinamómetro ya que uno de ellos irá a una entrada analógica, pero el otro no sé dónde deberá ir conectado (en principio a GND). El caso es que voy a mostrar los datos en una LCD que ya tengo conectada y configurada y la Arduino irá conectada con una fuente de alimentación de 12V.

He leído que podría ser un problema el hecho de compartir tomas de tierra entre diferentes aparatos eléctricos, ¿Sería este el caso de mi proyecto?

Lo más que sé de electricidad es que no hay que meter los dedos en un enchufe  smiley-red

Cualquier ayuda y consejo será muy bienvenido.

Saludos
12  Using Arduino / Project Guidance / Re: Help to create a pass detector for 24v machine on: February 28, 2013, 01:20:15 pm
Perhaps using a relay is the easiest way to send a signal the device.

So you recomend to use a relay to send a 24v signal to the CNC machine, but is there any way intead of buying a shield to recieve the signal from the machine?


Detecting the particles can be done in the same way a metal detector works.
The ring in your picture could be a coil with a radio frequency.
If the frequency changes, some metal passed.

Thanks for pointing the idea of the frecuency change. I'm going to look for examples of this in the forum.

Greets from Barcelona
13  Using Arduino / Project Guidance / Help to create a pass detector for 24v machine on: February 19, 2013, 12:34:22 pm
Hello from Barcelona.

I have an old CNC machine that we use to produce little metal pieces.

When the pieces haves been conformed they are cutted and they must fall inside a furniture.

The problem comes when any of the pieces doesn't fall into the furniture because is possible that it remains where the next piece is going to be conformed.
That can produce a crash between the upcoming piece and the forming tools.

Time ago the cnc machine was equiped with an antifailure system that basically was a plastic tube where the finished pieces passed trough their way to the furniture and if any of the pieces didn't fall then the machine stopped before starting the new piece.

I want to clone this method using an Arduino board. The goal is to get a 24v signal from the CNC machine, wait for a determinated amount of time for the piece to pass through a ring (or another pass-detector) and if there is not piece then send a 24v signal back to the machine (as the old original system did).

Something like this:


The first issue we have to deal with is the fact that the machine operates natively at 24v so we are going to need a shield to this kind of voltage and to send a similar signal to the machine in the case that we want to stop it.

Any advice on what kind of shield would fit in our needs will be trully apreciatted.

As we want  to clone the old system we plug the Arduino directly from the shield to the machine inputs and outputs (we can code the machine to send a signal to the arduino when the piece is produced).

I don't know what would be the best way of detecting the pass or not of the finished pieces. The pieces are as big as a paper clip.

Thanks in advance for any idea.

Greets from barcelona
14  Using Arduino / Motors, Mechanics, and Power / Re: help servo motors on: January 29, 2011, 01:59:24 pm
Thanks for your answers. I feed the servos directly with the PC cutting some USB cables to get the +5V.

I'm going to work always with Arduino connected and ruled by the PC.
Can¡t wait to try your examples.

I thoght that the pde that let us control so many servos was going to be something like a charachter and a number sended via the COM port (Something like analogwrite($pinnumber, "a120"). So if the character is the letter "a" and the number is "120" it will move the first servo to position 120º, if the character is "b" and the number is 100 the move the second servo to position 100º...

I'm going to study your examples to try to understand how do they works (comments on the code are really apreciatted for newbies like me).

Cheers
15  Using Arduino / Motors, Mechanics, and Power / Re: help servo motors on: January 29, 2011, 05:18:02 am
Thanks for your example.

How it can be modified to rule more than just one servomotor?

I'm using Arduino Uno and I don't find any example about how to rule up to 5 or 6 servomotors with the serial monitor.

Have a nice day
Pages: [1] 2