Registro de datos remoto de alta precisión con multímetro / Arduino / pfodApp: 10 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

Actualizado el 26 de abril de 2017 Circuito y placa revisados para su uso con medidores USB 4000ZC.

No se requiere codificación de Android

Este instructivo le muestra cómo acceder a una amplia gama de mediciones de alta precisión desde su Arduino y también enviarlas de forma remota para registrar y trazar. Para el registro de datos de alta velocidad (2000 muestras / seg), vea este instructivo, Registro de datos remoto de alta velocidad usando Arduino / GL AR150 / Android / pfodApp

El convertidor AtoD integrado en Arduino tiene poca precisión, típicamente +/- 10% y un rango muy limitado, típicamente 0 a 5V DC voltios solamente. Usando un circuito simple y una biblioteca, puede alimentar su Arduino con mediciones de rango automático de alta precisión desde un multímetro con una conexión RS232 ópticamente aislada. Tener las medidas disponibles para su boceto le permite controlar las salidas en función de los valores. Este tutorial también cubre el envío de la medición de forma remota, a través de WiFi, Bluetooth, Bluetooth Low Energy o SMS, a un móvil Android para su visualización, registro y trazado usando pfodApp.

Este instructable utiliza una placa Arduino Mega2560 5V que puede emparejar con una amplia variedad de escudos de comunicación, Ethernet, WiFi, Bluetooth V2 (clásico), Bluetooth LE o SMS. El hardware de interfaz y la biblioteca presentados aquí también se pueden usar con placas compatibles con Arduino de 3.3V. Además de la Mega2560 puedes utilizar una amplia variedad de otras placas como UNO con y escudo Ehternet, una placa base ESP8266 (independiente), una placa con Bluetooth Low Energy integrado, como Arduino 101, o placas que se conectan a la comunicación. subsistema que utiliza SPI, como el escudo RedBear BLE y las placas Bluefruit SPI de Adafrut. pfodDesignerV2 admite todas estas combinaciones de placas y generará el código para ellas. La condición limitante es que necesita tener una serie de hardware libre para conectarse al blindaje RS232 de este multímetro.

El circuito y el código presentados aquí funcionan con varios multímetros. Uno fácilmente disponible y económico es un Tekpower TP4000ZC, también conocido como Digitek TD-4000ZC. Los multímetros que funcionan con este circuito y biblioteca incluyen Digitek DT-4000ZC, Digitech QM1538, Digitech QM1537, Digitek DT-9062, Digitek INO2513, Digitech QM1462, PeakTech 3330, Tenma 72-7745, Uni-Trend UT30A, Uni-Trend UT30E, Uni -Trend UT60E, Voltcraft VC 820, Voltcraft VC 840

Paso 1:

Este tutorial tiene dos partes:

La primera parte cubre la interfaz de hardware del multímetro y la biblioteca de códigos usando un Arduino Mega. Si solo desea obtener la medición en su Arduino, esto es todo lo que necesita.

La segunda parte cubre el envío de la medición a un dispositivo móvil Android remoto para su visualización, registro y trazado. En este ejemplo usaremos un escudo Bluetooth y generaremos el boceto básico usando pfodDesignerV2, pero también puede generar código para conexiones WiFi, Ethernet, Bluetooth Low Energy y SMS usando pfodDesignerV2. Luego, la biblioteca del multímetro se agrega al boceto básico para completar el código. No se requiere codificación de Android para mostrar, registrar y trazar la lectura. Todo está controlado desde su código Arduino.

Este proyecto también está disponible en línea en www.pfod.com.au

Para una visualización remota del multímetro, consulte este instructable, Arduino Data Glasses For My Multimeter de Alain.

Paso 2: el multímetro

Los multímetros utilizados en este tutorial son el económico (~ US40) Tekpower TP4000ZC (también conocido como Digitek DT-4000ZC) y el antiguo Digitech QM1538, que ya no se vende. Ambos medidores son visualmente iguales y utilizan la misma codificación RS232 de la medición.

Aquí las especificaciones para el Tekpower TP4000ZC: -Voltaje CC: 400mV / 4/40 / 400V ± 0.5% + 5, 600V ± 0.8% Voltaje CA: 4/40 / 400V ± 0.8% + 5, 400mV / 600V ± 1.2% + 5CC Corriente: 400 / 4000μA ± 2.0% + 5, 40 / 400mA ± 1.5% + 5, 4 / 10A ± 2% + 5CA Corriente: 400 / 4000μA ± 2.5% + 3, 40 / 400mA ± 2% + 5, 4 / 10A ± 2.5% + 5 Resistencia: 400Ω / 4/40 / 400kΩ / 4MΩ ± 1% + 5, 40MΩ ± 2% + 5 Capacitancia: 40nF ± 3.5% + 10, 400nF / 4 / 40μF ± 3% + 5, 100μF ± 3.5% + 5 Frecuencia: 10Hz-10MHz ± 0.1% + 5 Ciclo de trabajo: 0.1% -99.9% ± 2.5% + 5 Temperatura: 0oC - + 40oC ± 3oC, -50oC - + 200oC ± 0.75% ± 3oC, + 200oC - + 750oC ± 1,5% ± 3oC, resolución 0,1oC mediante sonda termopar incluida.

La conexión RS232 del multímetro es unidireccional y no puede cambiar la configuración del multímetro de forma remota, por lo que debe seleccionar manualmente el tipo de medición. Sin embargo, el medidor tiene rango automático y las configuraciones de voltaje y corriente manejan tanto CA como CC.

Paso 3: El hardware de la interfaz RS232

Hay dos interfaces. Los medidores Digitek DT-4000ZC y Tekpower TP40000ZC más nuevos vienen con un cable USB. Mientras que el Digitek QM1538 más antiguo se proporcionó un cable conector RS232 de 9 pines D. El circuito anterior (versión pdf) muestra cómo conectar el optoacoplador del multímetro para impulsar un pin serie Arduino RX. Nota: Este circuito se ha actualizado para agregar otra resistencia de protección, R2, para los medidores Digitek DT-4000ZC y Tekpower TP40000ZC. Esta resistencia no se incluyó en la placa del conector D de 9 pines que se muestra arriba.

Digitek DT-4000ZC y Tekpower TP40000ZC

Para Digitek DT-4000ZC y Tekpower TP40000ZC, necesita un cable de audio de 3,5 mm macho a macho, estéreo o mono, y una toma de 3,5 mm.

Digitek QM1538

Para el Digitek QM1538 más antiguo, necesita un zócalo D de 9 pines. El conector D de 9 pines tiene pines desplazados que no se conectan al protector del prototipo. Simplemente corte la fila de 4 pines para poder soldar el conector a la placa, ya que el circuito solo usa pines en la segunda fila de 5 pines. Las patas de montaje se doblaron para dejar que el conector quedara plano y el conector se aseguró al protector del prototipo con pegamento epoxi de 2 partes ("Araldite"). La disposición de los pines del conector que se muestra arriba es de este sitio. La resistencia de 10K que viene montada dentro del conector de los cables RS232 suministrados (conectados entre los pines 2 y 3) no es necesaria para este proyecto.

Conectando la señal a un pin Arduino RX

Este circuito funcionará para placas Arduino de 5V y 3.3V. Aquí estamos usando un Arduino Mega2560 (5V) y montamos el circuito en un escudo prototipo como se muestra arriba.

Se usa un cable flotante para conectar el TP1 en el blindaje a un Serial1 RX, pin D19, en el Mega2560.

Nota sobre la serie de software: Inicialmente, este escudo se emparejó con un UNO utilizando la serie de software en los pines 10, 11. Sin embargo, cuando se emparejó con el protector de Bluetooth en serie a 9600 baudios, se perdieron algunos bytes de recepción. Mover el RS232 a una conexión serial de hardware resolvió este problema. Por lo tanto, para una visualización y registro remotos confiables, si está utilizando un escudo de comunicación que se conecta a través de una serie, necesita una placa con dos o más series de hardware, como la Mega2560. Otras alternativas son una UNO con escudo Ehternet, una placa base ESP8266 (independiente), una placa con Bluetooth Low Energy integrado como Anduino 101 o placas que se conectan al subsistema de comunicación usando SPI como RedBear BLE shield y Bluefruit SPI de Adafrut. tableros. pfodDesignerV2 admite todas estas placas y generará el código para ellas.

Paso 4: Biblioteca PfodVC820MultimeterParser

El Tekpower TP4000ZC y varios otros multímetros no envían la medición a través de RS232 como texto ASCII, sino que envía 14 bytes con bits establecidos según los segmentos de la pantalla LCD que estén iluminados. La codificación de los 14 bytes se explica en este pdf. La biblioteca pfodVC820MeterParser.zip decodifica estos bytes en cadenas de texto y flotantes. (El VC820 se refiere a uno de los medidores que utiliza esta codificación). Consulte también el software informático QtDMM para Windows, Mac y Linux que maneja una amplia gama de multímetros.

Hay un ejemplo mínimo, MeterParserExample.ino, del uso de la biblioteca pfodVC820MeterParser. Conecte el medidor a una conexión en serie de 2400 baudios y luego llame a haveReading () en cada bucle para procesar los bytes. haveReading () devolverá verdadero cuando haya una nueva lectura completa analizada. Luego, puede llamar a getAsFloat () para obtener el valor (escalado) como flotante o getAtStr () para obtener la lectura con escalado para imprimir y registrar. Hay otros métodos disponibles para acceder al tipo de medición, getTypeAsStr () y getTypeAsUnicode (), así como otros métodos de utilidad.

#incluya "pfodVC820MeterParser.h" medidor pfodVC820MeterParser; // configuración vacía () {Serial.begin (74880); Serial1.begin (2400); meter.connect (& Serial1); } lectura flotante; bucle vacío () {if (meter.haveReading ()) {lectura = meter.getAsFloat (); // use esto para los cálculos de Arduino Serial.print ("Lectura con unidades:"); Serial.print (meter.getDigits ()); Serial.print (meter.getScalingAsStr ()); Serial.print (meter.getTypeAsStr ()); Serial.print (F ("= como flotante impreso (6 dígitos):")); Serial.println (lectura, 6); Serial.println ("Tiempo (seg) y lectura como cadena para el registro"); Serial.print (((float) millis ()) / 1000.0); Serial.print (", seg,"); Serial.print (meter.getAsStr ()); Serial.print (','); Serial.println (meter.getTypeAsStr ()); }}

Con el medidor configurado en Deg C y usando la sonda de termopar, el boceto de ejemplo da esta salida en el monitor serial Arduino IDE

Lectura con unidades: 25.7C = como flotante impreso (6 dígitos): 25.700000 Tiempo (seg) y Lectura como cadena para registro 2.40, seg, 25.7, C

Paso 5: Parte 2 - Visualización remota, registro y trazado

Esta parte del tutorial cubre cómo visualizar, registrar y trazar de forma remota la lectura del medidor en su móvil Android. pfodApp se utiliza para manejar la visualización, el registro y el trazado en su móvil Android. No se requiere programación de Android. Todas las pantallas, el registro y el trazado están completamente controlados por su boceto de Arduino. La aplicación gratuita pfodDesignerV2 le permite diseñar su menú y gráfico de Android y luego genera el boceto de Arduino para usted.

pfodApp admite varios tipos de conexión, Ethernet, WiFi, Bluetooth V2 (clásico), Bluetooth LE o SMS. Este tutorial utiliza Arduino 101 (Bluetooth Low Energy) para el registro y trazado de datos. También se admiten otras placas Bluetooth de baja energía. Este tutorial utiliza SMS para conectarse a pfodApp. Puede usar pfodDesignerV2 para agregar registro de datos y gráficos a ese ejemplo de SMS. pfodDesignerV2 también tiene opciones para generar código Arduino a un escudo Bluetooth V2 (clásico) para conectarse a pfodApp.

Para este ejemplo usaremos un Iteadstudio Bluetooth Shield V2.2 que se conecta al Arduino Mega2560 a través de una conexión serial de 9600baudios. Usando la aplicación gratuita pfodDesignerV2, configuramos un menú simple que solo tiene una etiqueta para mostrar la lectura del medidor y un botón para abrir el gráfico. Esta página tiene varios tutoriales de pfodDesignerV2. Una vez que tengamos un boceto básico, lo modificaremos para agregar el analizador del medidor y enviar la lectura y los datos del medidor para registrar y graficar.

Diseñando el Menú

En esta sección diseñaremos un menú de Android / pfodApp que mostrará la lectura del medidor y un botón para abrir un gráfico de las lecturas. Las lecturas también se guardan en un archivo en el móvil Android.

Paso 6: agregar una etiqueta

Instale el pfodDesignerV2 gratuito e inicie un nuevo menú.

El objetivo predeterminado es Serial a 9600baudios, que es lo que se necesita para Iteadstudio Bluetooth Shield V2.2. Si se está conectando mediante un dispositivo Bluetooth de baja energía o Wifi o SMS, haga clic en Destino para cambiar la selección.

Para agregar una etiqueta para mostrar la lectura del medidor, haga clic en Agregar elemento de menú y seleccione desplazarse hacia abajo para seleccionar Etiqueta.

Elija un tamaño y colores de fuente adecuados. Deje el texto como etiqueta, ya que modificaremos el código generado para reemplazarlo con la medición del medidor más adelante. Aquí hemos establecido el tamaño de fuente en +7, el color de fuente en rojo y el fondo en plateado.

Vuelva a la pantalla Editing Menu_1 y establezca un intervalo de actualización de 1 seg. Hará que pfodApp vuelva a solicitar el menú aproximadamente una vez por segundo para mostrar la última lectura en la etiqueta.

Paso 7: agregar un botón de gráfico

Haga clic en Agregar elemento de menú nuevamente para agregar un botón de gráfico.

Edite el texto del botón Gráfico en algo adecuado, p. Ej. simplemente "Gráfico" y elija un tamaño de fuente y colores.

Luego haga clic en el botón "Gráfico" para abrir la pantalla de edición de gráficos. Solo habrá un gráfico, así que haga clic en los botones Editar gráfico 2 y Editar gráfico 3, desplácese hacia abajo y haga clic en Ocultar gráfico para cada uno de ellos.

Edite la etiqueta del gráfico a algo adecuado, p. Ej. “Multímetro”. No es necesario cambiar ninguna de las otras configuraciones de trazado, ya que modificaremos el boceto para enviar una etiqueta del eje y diferente según la configuración del multímetro.

Por último, vuelva al menú de edición_1 y al indicador de edición, esto establece el texto en la parte inferior del menú y el color de fondo general del menú. Aquí hemos configurado el mensaje en “Multímetro remoto” con tamaño de fuente +3 y color de fondo Plateado.

Ahora puede volver al Menú de edición_1 y hacer clic en Menú de vista previa para obtener una vista previa del diseño del menú.

Si no le gusta el diseño, puede cambiarlo antes de generar el código. Si desea espaciar la etiqueta del botón, puede agregar algunas etiquetas en blanco como se describe aquí. Agregar un gráfico y registrar datos sobre cómo mostrar / trazar datos de Arduino en Android es otro tutorial sobre el registro de datos y gráficos de pfodDesignerV2 / pfodApp.

Paso 8: Generación del boceto de Arduino

Para generar el código Arduino que mostrará este menú en pfodApp, regrese a la pantalla Editing Menu_1, desplácese hacia abajo y haga clic en el botón Generate Code.

Haga clic en el botón "Escribir código en el archivo" para generar el boceto de Arduino en el archivo /pfodAppRawData/pfodDesignerV2.txt en su dispositivo móvil. Luego salga de pfodDesignerV2. Transfiera el archivo pfodDesignerV2.txt a su PC usando una conexión USB o una aplicación de transferencia de archivos, como wifi file transfer pro. Una copia del boceto generado está aquí, pfodDesignerV2_meter.txt

Cargue el boceto en su Arduino IDE y programe su placa Uno (o Mega). Luego agregue Iteadstudio Bluetooth Shield V2.2. Instale pfodApp en su móvil Android y cree una nueva conexión Bluetooth llamada, por ejemplo, Multímetro. Consulte pfodAppForAndroidGettingStarted.pdf para saber cómo crear nuevas conexiones. Luego, cuando use pfodApp para abrir la conexión del Multímetro, verá su menú diseñado.

Abrir el gráfico no muestra nada interesante porque no hemos agregado el hardware / software del multímetro.

Paso 9: agregar el multímetro

Modificaremos el boceto generado para agregar el analizador multímetro y enviar sus datos a tu móvil Android. El boceto completo modificado está aquí, pfod_meter.ino

Estas modificaciones agregan el analizador multímetro y un temporizador de 5 segundos. Si no hay una nueva lectura válida en ese tiempo, el boceto deja de enviar datos y actualiza la pantalla de Android / pfodApp a "- - -". A medida que se cambia la selección manual del medidor, las etiquetas del gráfico se actualizan, pero debe salir del gráfico y volver a seleccionarlo para ver las nuevas etiquetas. Por otro lado, la lectura del medidor se actualiza automáticamente cada segundo. Finalmente, pfodApp maneja Unicode por defecto, por lo que cuando se muestra la lectura del medidor, se usa el método getTypeAsUnicode () para devolver el Unicode para ohmios, Ω y degsC, ℃ para la pantalla del medidor.

El botón de gráfico muestra un gráfico de actualización de las lecturas: -

Los datos del gráfico, en formato CSV, también se guardan en un archivo en su dispositivo móvil Android en /pfodAppRawData/Mulitmeter.txt para luego transferirlos a su computadora e importarlos a una hoja de cálculo para realizar más cálculos y gráficos.

Paso 10: Las modificaciones del boceto en detalle

1. Descargue la biblioteca pfodVC820MeterParser.zip y luego abra Arduino IDE y haga clic en Sketch → Incluir biblioteca → Agregar.zip para agregar esta biblioteca a su IDE.
2. Agregue la biblioteca pfodVC820MeterParser al boceto. Haga clic en Sketch → Incluir biblioteca → pfodVC820MeterParser. Esto agregará las declaraciones de inclusión en la parte superior del boceto.
3. Edite el analizador pfodParser_codeGenerated ("V1"); al analizador pfodParser_codeGenerated (""); Esto deshabilita el almacenamiento en caché del menú en pfodApp para que se muestren los cambios en el menú. Puede volver a “V3” cuando haya terminado todos los cambios para volver a habilitar el almacenamiento en caché del menú.
4. Agregue estas líneas para crear los objetos para la serie de software y el multímetro. medidor pfodVC820MeterParser;
5. Al final de setup () agregue Serial1.begin (2400); meter.connect (& Serial1);
6. Por encima del bucle () agregue un validReadingTimer largo sin firmar = 0; const unsigned long VALID_READINGS_TIMEOUT = 5000; // 5 segundos bool haveValidReadings = true; // establecer en verdadero cuando tenga lecturas válidas int MeasureType = meter. NO_READING; y en la parte superior del bucle () agregue if (meter.haveReading ()) {if (meter.isValid ()) {validReadingTimer = millis (); haveValidReadings = true; } int newType = meter.getType (); if (MeasureType! = newType) {// generar nuevos títulos de registro de datos parser.print (F ("sec,")); parser.println (meter.getTypeAsStr ()); } MeasureType = newType; } if ((millis () - validReadingTimer)> VALID_READINGS_TIMEOUT) {haveValidReadings = false; // no hay nueva lectura válida en los últimos 5 segundos}
7. Más abajo en el ciclo, reemplace parser.print (F ("{= Multímetro | tiempo (segundos) | Plot_1 ~~~ ||}")); con parser.print (F ("{= Multímetro | tiempo (segundos) | Lectura del medidor ~~~")); parser.print (meter.getTypeAsStr ()); parser.print (F ("||}"));
8. En la parte inferior de loop () reemplace sendData (); con if (haveValidReadings) {sendData (); }
9. En sendData () reemplace parser.print (','); parser.print (((float) (plot_1_var-plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); con parser.print (','); parser.print (meter.getAsStr);
10. En sendMainMenu () reemplace parser.print (F ("~ Etiqueta")); con parser.print ('~'); if (haveValidReadings) {parser.print (meter.getDigits ()); parser.print (meter.getScalingAsStr ()); parser.print (meter.getTypeAsUnicode ()); } else {parser.print (F ("- - -")); }
11. En sendMainMenuUpdate () agregue parser.print (F ("|! A")); parser.print ('~'); if (haveValidReadings) {parser.print (meter.getDigits ()); parser.print (meter.getScalingAsStr ()); parser.print (meter.getTypeAsUnicode ()); } else {analizador.print (F ("- - -")); } Para actualizar la lectura cuando se usa el almacenamiento en caché del menú.

Conclusión

Este tutorial ha mostrado cómo conectar un multímetro económico a un Arduino Mega2560 a través de RS232. También se admiten muchas otras placas. La pfodVC820MeterParserlibrary analiza los datos del multímetro en flotadores para cálculos de Arduino y cadenas para visualización y registro. Se usó pfodDesignerV2 para generar un boceto básico para mostrar la lectura del multímetro y mostrar un gráfico de los valores en un móvil Android usando pfodApp. No se requiere programación de Android. A este boceto básico se agregó el manejo del multímetro y el boceto final muestra la lectura actual del multímetro en su móvil Android, además de graficar las lecturas y registrarlas en un archivo en su móvil para su uso posterior.