En la serie actual de artículos me dirijo a mis colegas del grupo de física. Los próximos episodios tratarán sobre un medidor de fuerza sin muelle helicoidal, por supuesto, no sin el uso de un sensor elástico. Sin embargo, se aprecia muy poco su elasticidad. No obstante, la resolución no se ve reducida por el aspecto visual apenas perceptible, sino más bien favorecida. Les revelaré cómo es esto posible en los nuevos episodios de la serie.
MicroPython en ESP32, ESP8266 y Raspberry Pi Pico
hoy
Un medidor de fuerza con MicroPython – Parte 1
1. En la primera parte nos ocuparemos del principio de medición y de la estructura del hardware.
2. En la segunda parte, añadimos una pantalla grande al ordenador portátil, que se controla mediante USB.
3. En la parte 3, sustituiremos el cable de datos USB por transmisión inalámbrica.
4. La parte 4 incluye una unidad de visualización con 8 paneles LED, que también se conecta a través de WLAN.
5. En la parte 5 se presenta una tableta Android como unidad de visualización.
El sensor de fuerza
Hace algún tiempo, utilicé un componente, de cuya familia ahora se está utilizando otro, en otro lugar en una balanza instalado. En ambos casos se trata, en última instancia, de medir fuerzas. Es decir, también en la determinación de la masa con la balanza se trataba de medir una fuerza, concretamente la fuerza de gravedad F.g. Esta se relaciona con la masa m de las piezas de pesaje a través del factor local g = 9,81 N/kg: Fg = g • m. De este modo era posible calibrar la balanza con piezas de masa. La figura 1 muestra una balanza de este tipo. En la balanza, el lado derecho se atornilla firmemente al suelo y el lado izquierdo se fija al plato de la balanza.
Ilustración 1: Célula de carga desde el lateral
En el caso actual, se trata de medir fuerzas directamente. Esto es posible gracias a la deformación elástica de una barra de pesaje de aluminio a la que se han fijado galgas extensométricas. Estos componentes consisten en bucles conductores muy finos que, al doblarse las partes más delgadas de la barra, se estiran o se comprimen según su ubicación, lo que modifica su resistencia eléctrica.
Ilustración 2: Esquema de una banda extensométrica
Al estirarse, los conductores se vuelven más largos y delgados, mientras que al comprimirse ocurre lo contrario. La longitud del conductor y la superficie de la sección transversal se tienen en cuenta en el cálculo de la resistencia eléctrica de un conductor. Tanto el alargamiento como la reducción de la sección transversal provocan un aumento del valor de la resistencia. ρ es la resistencia específica, una constante del material.
Ilustración 3: Fórmula de resistencia
Para que incluso los cambios más pequeños en el valor de resistencia den lugar a un resultado de medición reproducible con alta resolución, las bandas de medición se agrupan en un circuito en puente, cuya tensión de salida se envía a un amplificador de precisión. La tensión de salida de este solo tiene que digitalizarse para su procesamiento en un microcontrolador.
Ilustración 4: Galgas extensométricas en el HX711
El módulo HX711 incluye ambos componentes y permite además seleccionar la amplificación, 128 o 64 veces en la entrada diferencial A, así como 32 veces en la entrada B. La transmisión de los 24 bits...ADCEl valor (ADC = convertidor analógico-digital) al microcontrolador se transmite a través de la Datos-Línea que pasa por 24 pulsos en Reloj Se sincroniza. Hasta tres pulsos adicionales influyen en el ajuste de amplificación del PGA (amplificador de ganancia programable) para la siguiente medición. La barra de pesaje utilizada aquí puede soportar hasta 5 kg, lo que corresponde a una fuerza máxima de aproximadamente 50 N. Junto con la entrada A y Gain=128, alcanzamos una resolución de 1 mN, lo que corresponde a aproximadamente 0,1 gramos de masa. Dado que este es el punto incierto, nos conformamos con 10 mN como valor de medición mínimo y obtenemos a cambio una indicación estable del valor medido. 0,01 N es mucho más de lo que se puede alcanzar con medidores de fuerza con resortes helicoidales.
Ilustración 5: Ajuste de amplificación mediante impulsos de reloj adicionales
La interfaz de software para el HX711 es la clase HX711 del módulo MicroPython hx711.py. Volveremos sobre esto más adelante.
Hardware
Como controlador son adecuados tanto los modelos ESP8266 como los ESP32 con al menos cuatro GPIO libres. El valor medido se muestra inicialmente en una pantalla OLED. Por supuesto, también se puede utilizar otro modelo como célula de carga. Hay disponibles desde 100 g hasta 100 kg de capacidad de pesaje y más.
Por motivos de espacio, en este proyecto me he decidido por un D1 Mini NodeMcu con módulo WLAN ESP8266-12F Decidido. Por ahora, la alimentación eléctrica de la electrónica de medición se realiza a través del USB.
El circuito para el ESP8266 D1 Mini
Ilustración 6: Medidor de fuerza - Circuito
El software
Para flashear y programar el ESP32:
Thonny o
Creación de conjuntos de caracteres propios
zeichensatz.rar Entorno de trabajo para crear conjuntos de caracteres propios
Para representar señales de bus
SALEAE – Software analizador lógico (64 bits) para Windows 8, 10, 11
Firmware utilizado para el ESP32:
Firmware utilizado para el ESP8266:
Firmware utilizado para el Raspberry Pi Pico (W):
RPI_PICO_W-20240602-v1.23.0.uf2
Los programas MicroPython para el proyecto:
ssd1306.py Controlador de hardware para la pantalla OLED
oled.py API para la pantalla OLED
geometer_30.py Gran conjunto de caracteres para la visualización de números
hx711.py API para el AX711
newtonmetro.py El programa operativo
MicroPython - Lenguaje - Módulos y programas
Para instalar Thonny, encontrará aquí una instrucciones detalladas (versión en inglés). En él también se describe cómo la Firmware Micropython (Fecha: 25/01/2024) en el chip ESP quemado será. Aquí encontrará cómo poner en marcha el Raspberry Pi Pico. aquí.
MicroPython es un lenguaje interpretado. La principal diferencia con respecto al IDE de Arduino, donde siempre se flashean programas completos, es que solo hay que flashear el firmware de MicroPython una vez al principio en el ESP32 para que el controlador entienda las instrucciones de MicroPython. Para ello, puede utilizar Thonny, µPyCraft o esptool.py. Para Thonny, he descrito el proceso aquí descrito.
Una vez actualizado el firmware, puede comunicarse libremente con su controlador, probar comandos individuales y ver la respuesta inmediatamente, sin tener que compilar y transferir todo un programa previamente. Eso es precisamente lo que me molesta del IDE de Arduino. Se ahorra mucho tiempo si se pueden comprobar de antemano, a través de la línea de comandos, desde pruebas sencillas de la sintaxis y el hardware hasta la prueba y el perfeccionamiento de funciones y partes completas del programa, antes de crear un programa a partir de ello. Para ello, me gusta crear pequeños programas de prueba. A modo de macro, agrupan comandos recurrentes. A partir de estos fragmentos de programa se desarrollan a veces aplicaciones completas.
Inicio automático
Si desea que el programa se inicie automáticamente al encender el controlador, copie el texto del programa en un archivo nuevo en blanco. Guarde este archivo con el nombre main.py en el espacio de trabajo y cárguelo en el chip ESP. El programa se iniciará automáticamente la próxima vez que se reinicie o se encienda el dispositivo.
Probar programas
Los programas se inician manualmente desde la ventana actual del editor en el IDE Thonny pulsando la tecla F5. Esto es más rápido que hacer clic con el ratón en el botón de inicio o a través del menú. Correr. Solo los módulos utilizados en el programa deben estar en la memoria flash del ESP32.
¿De vez en cuando vuelves a usar Arduino IDE?
Si más adelante desea volver a utilizar el controlador con el IDE de Arduino, simplemente vuelva a grabar el programa como de costumbre. Sin embargo, el ESP32/ESP8266 habrá olvidado que alguna vez habló MicroPython. Por el contrario, cualquier chip Espressif que contenga un programa compilado desde el IDE de Arduino o el firmware AT o LUA o... puede equiparse sin problemas con el firmware MicroPython. El proceso es siempre el mismo, como aquí descrito.
Estructura del dispositivo de medición
Para suspender la barra de pesaje de 12 mm x 12 mm x 75 mm, necesitamos otros dos perfiles de aluminio con las mismas dimensiones, además de dos láminas de aluminio de 21 mm x 12 mm x 2,5 mm como separadores. Se necesitan dos perfiles en U de aluminio para alojar las placas en las que se conectan el controlador y el HX711. Aquí está el esquema de las piezas, que también se puede utilizar como Documento PDF descargado . En él se incluye el diseño de las placas y su esquema de montaje.
Los perfiles de aluminio los compré en una tienda de bricolaje. En el perfil superior hay que cortar roscas M3 para fijar los rieles en U. La fijación de las placas en los rieles en U también se realiza mediante roscas M3 y separadores de plexiglás (12 mm x 10 mm x 2 mm). Las roscas de 3 mm en los lados exteriores de los rieles en U sirven para fijar una cubierta opcional.
Ilustración 7: Estructura mecánica del medidor de fuerza
Ilustración 8: Unidad sensora desde arriba
Ilustración 9: Medidor de fuerza en uso
La figura 8 muestra el montaje de los componentes electrónicos. Como soporte se utilizan dos placas equipadas con conectores hembra para alojar el microcontrolador y el HX711. Aquí se muestran el diseño y el esquema de montaje. Las tres conexiones de cable están marcadas en verde.
Ilustración 10: Diseño de las dos placas
Para una primera toma de contacto, he montado una prueba con un NodeMCU Lua Lolin Módulos V3 ESP8266que tenía a mano. He conectado la barra de pesaje al circuito con mis cables de prueba.
Ilustración 11: Configuración de prueba con una placa ESP8266 Node MCU.
Estos cables de prueba se pueden fabricar fácilmente a partir de un cable altamente flexible. cable de silicona y un pinza de prueba Fabricar en cualquier longitud. Una regleta de un polo permite la conexión a la placa de pruebas. Un trozo de tubo termorretráctil contrario.
Ilustración 12: Práctica pinza de prueba con cable de silicona
Un gran conjunto de caracteres para la pantalla OLED
Los números grandes facilitan considerablemente la lectura de la medición. En lugar de los ocho píxeles habituales, utilizamos 30 píxeles como altura de los caracteres. El archivo geometer_30.py contiene la información correspondiente al respecto.
Para crear nuestro propio juego de caracteres para la pantalla OLED, necesitamos algunos ingredientes.
1. Python para Windows
2. freetype-py
Si aún no tiene Python instalado en su PC, deberá hacerlo ahora. Descargue el paquete actual Python 3.13.3 Descárguelo e instálelo ejecutando el archivo python-3.13.3-amd64.exe Inicie la carpeta de descargas y siga las instrucciones del asistente.
freetype-py es una herramienta necesaria para convertir un juego de caracteres TTF de Windows. Con Python también se creó una herramienta llamada pip3 instalado. Lo utilizamos para freetype-py instalar.
Abra el símbolo del sistema y escriba la siguiente línea en el indicador.
pip3 install freetype-py
Y así es como se crea un juego de caracteres propio a partir del repositorio TTF de Windows.
Descargar el archivo zeichensatz.rar y descomprima el contenido en cualquier directorio. Para ahorrar tiempo, recomiendo crear un directorio con un nombre corto en la ruta raíz del disco duro o de una memoria USB. En mi caso es F:\fuentes.
Desde el Explorador, abra una ventana de Powershell en este directorio manteniendo pulsada la tecla tecla Mayús uno clic con el botón derecho en el directorio. A continuación, haga clic con el botón izquierdo del ratón en Abrir la ventana de PowerShell aquí.
Ilustración 13: Abrir ventana Powershell
Eingeben Sie die folgende Zeile in die Eingabeaufforderung ein und drücken Sie Intro.
.\makecharset.bat geometer 30 """0123456789,-+N""" "F:\fonts\quellen\"
Ilustración 14: El juego de caracteres está listo.
Ahora hay un archivo en el directorio. geometer_30.py con los datos de píxeles del nuevo extracto del juego de caracteres. Solo se han implementado los caracteres en «0123456789,-+N», lo que ahorra espacio de almacenamiento. Puede obtener más juegos de caracteres en el fuentes-Directorio de Windows al directorio fuentes Copie y convierta como se indica arriba. Tenga en cuenta que el nombre del archivo se indica sin la extensión .TTF.
Ahora copiamos el juego de caracteres creado en el directorio de trabajo de nuestro nuevo proyecto MicroPython.
Primeras pruebas
El LED de señalización
Entonces podemos empezar a realizar algunas pruebas iniciales. Para ello, podemos utilizar el circuito de prueba de la figura 11, al que se conecta la barra de pesaje tal y como se muestra en el esquema de conexiones de la figura 6.
Como LED de señalización, he utilizado un LED Neopixel de una tira de LED que sobró al construir el reloj ábaco. Esto tiene la ventaja de que con un LED se puede representar cualquier color a través de un único cable de control.
Ilustración 15: LED Neopixel
Porque el NodeMCU Lua Lolin Módulos V3 ESP8266 Como el pin Vin no transmite los 5 V del USB, he conectado los +5 V del cable a la salida de 3,3 V de la placa controladora, lo cual funciona sin problemas con un LED. El ESP8266 D1 MiniEl sensor de fuerza que instalamos en el sensor de fuerza suministra realmente los 5 V del USB en el pin de 5 V. Din conectamos D4 = GPIO2 activado.
A continuación se describen las entradas en REPL grasa formateado, gastos cursiva.
>>> desde neopixel importar NeoPixel
El objeto Neopixel consta de un LED en GPIO2.
>>> led=Pin(2, Pin.OUT, value=0) # D4
>>> np=NeoPixel(led,1)
Definimos algunos colores...
>>> rojo=(4,0,0)
>>> azul=(0,0,4)
>>> amarillo=(16,8,0)
>>> off=(0,0,0)
Y comprueban su eficacia.
>>> np[0]=rojo
>>> np.write()
>>> np[0]=off
>>> np.write()
La selección del color y la escritura en el LED se resumen en la función señal() juntos.
>>> def señal(col):
np[0]=col
np.write()
>>> señal (amarilla)
>>> señal(apagada)
Medición de fuerzas
Para el manejo del HX711 ¿Hay alguna clase en el módulo hx711.py vive. Si se inicia hx711.py en una ventana del editor Thonny, el bloque if al final del listado crea un objeto HX711 con el identificador hx.
if __name__ == "__main__":
from machine import Pin
hx=HX711(Pin(14),Pin(12,Pin.IN)) # D5, D6
Esto nos permite dar los primeros pasos con el sensor de fuerza. Obtenemos un valor de medición, tal y como lo ha determinado el HX711, a través del cable serie. De acuerdo con su cableado, obtenemos 10 valores por segundo (velocidad de conexión = GND).
>>> %Run -c $EDITOR_CONTENT
HX711 listo en el canal A con ganancia 128
>>> hx.getRaw()
-502747
Este valor se obtiene para la barra de pesaje sin carga. En nuestro caso, el punto de referencia no es el soporte inferior de la barra de pesaje, sino el gancho de la parte superior. Cuando la unidad de medición está suspendida, entre las partes que ejercen carga sobre el sensor se encuentran también las piezas perfiladas montadas debajo de la barra de pesaje. Debemos tener en cuenta este valor como tara para mediciones posteriores. Determinamos el valor de tara a partir de varias mediciones como valor medio. Especificamos el número de mediciones al iniciar la medición, en este caso 2.
>>> hx.tara(2)
-502631
Ilustración 16: Registrar Tara
A continuación, hay que calibrar el sensor. Esto significa que el valor bruto medido para una fuerza determinada, corregido por el valor de tara, debe convertirse en una indicación de fuerza en newtons. Por lo tanto, fijamos la barra de pesaje o colgamos nuestra unidad de medición, iniciamos hx711.py y llamamos a hx.tara(2) . El valor de tara se almacena en el atributo hx.tare almacenado y devuelto.
Ahora debemos determinar el factor de calibración para la conversión a newtons. Esto se realiza mediante el método hx.calibrateF(), al que transferimos la masa de 102 g. En el campo gravitatorio de la Tierra, esta masa está sometida a una fuerza de gravedad de aproximadamente 1 newton, dependiendo del lugar de medición.
Ilustración 17: Calibrar con una masa de 102 g a 1 N.
Este valor también se utiliza como atributo. hx.fcal del objeto HX711. A partir de ahora, podemos medir fuerzas directamente utilizando el método hx.kraft(n). El parámetro n Indica el número de mediciones que se deben realizar para calcular el valor medio. Cada medición individual dura aproximadamente 100 ms.
>>> hx.calibrateF(102)
44098.7
>>> hx.kraft(2)
1.00366
Podemos consultar el factor de calibración en cualquier momento y, si es necesario, reajustarlo manualmente. Para simplificar el procedimiento, se recomienda introducir el factor de calibración encontrado en la clase HX711 en el atributo de clase KFaktorKraft . Como alternativa, también podríamos escribir el valor en un archivo que leemos cada vez que se inicia el sistema.
>>> hx.fcalFactor(44098.1)
>>> hx.kraft(2)
1.00045
>>> hx.kraft(2)
1.00288
Nos damos cuenta de que solo se puede dar un resultado útil con dos decimales, porque el tercer decimal ya cambia bastante. Pero eso es suficiente, porque ningún medidor de fuerza convencional con resorte helicoidal puede medir hasta 0,01 N. Por lo tanto, en el futuro ajustaremos los resultados de nuestras mediciones para mostrarlos en seis posiciones con dos decimales y los alinearemos a la derecha (>) con una «N» como denominación.
>>> «{:>6.2f} N».format(hx.kraft(2))
' 1,00 N'
Caracteres más grandes en la pantalla OLED
El módulo geometer_30.py tiene la siguiente estructura. Tras un encabezado, en el que se enumeran los caracteres contenidos, la altura y la anchura máxima de los caracteres, en la lista siguen número Tupel, cuyo primer componente indica el ancho actual del carácter. A continuación, sigue el patrón de píxeles del carácter en forma de bytes-Objetos en representación binaria. Sobre la posición del carácter en la cadena chars obtenemos acceso a la entrada en número. Se pueden generar caracteres propios creando manualmente el patrón de bits e insertando un carácter puntero en chars Registrar.
El módulo debe cargarse en la memoria flash del controlador para que pueda ser activado.
>>> importar geometer_30 como cs
Una vez importado de esta manera, podemos utilizar el módulo con el prefijo geómetra_30 muy breve con el prefijo cs abordar.
chars="0123456789,-"
altura=31
width=29
número=[
(17, # Caracteres: 0
0b00000000000000000,
0b00000000000000000,
0b00000000000000000,
0b00000011111000000,
0b00001111111110000,
0b00011111111111000,
0b00011111111111000,
0b00111110001111100,
0b00111110001111100,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b00111110001111100,
0b00111110001111100,
0b00011111111111000,
0b00011111111111000,
0b00001111111110000,
0b00000011111000000,
0b00000000000000000,
0b00000000000000000,
0b00000000000000000,
0b00000000000000000,
0b00000000000000000,
0b00000000000000000,
0b00000000000000000,
),
Para representarlo, ahora solo tenemos que colocar un píxel en la pantalla a partir de la posición inicial (= esquina superior izquierda de la matriz de caracteres) en todos los lugares donde haya un 1 en el patrón. Esto lo hace la función putNumber(). Obtenemos el número del patrón en la lista mediante la siguiente línea. z es el signo que se va a representar, el método índice() determina la posición en chars.
>>> n=cs.chars.index(z)
def putNumber(n, xpos, ypos, show=True):
anchura=cs.number[n][0]
para fila en rango(1,cs.altura):
for col in range(anchura-1,-1,-1):
c=cs.number[n][row] & 1<
d.setPixel(xpos+anchura+3-col,ypos+row,c,False)
if show:
d.show()
return xpos+anchura+2
Obtenemos el ancho del carácter y recorremos el patrón línea por línea y columna por columna. Leemos el código de color c, 0 o 1, y establecemos de forma oculta (False) el píxel en el color de fondo o de primer plano, 0 o 1. Se prevén dos píxeles como distancia entre caracteres. La función devuelve la posición x para el siguiente carácter, de modo que los caracteres se pueden mostrar en modo proporcional.
Para las próximas pruebas, los archivos deben oled.py y ssh1306.py se carguen en la memoria flash del controlador.
>>> importar geometer_30 como cs
>>> desde máquina importar Pin, freq, SoftI2C
>>> desde oled importar OLED
>>> importar geometer_30 como cs
>>> def putNumber(n, xpos, ypos, show=True):
anchura=cs.number[n][0]
para fila en rango(1,cs.altura):
for col in range(anchura-1,-1,-1):
c=cs.number[n][row] & 1<
d.setPixel(xpos+anchura+3-col,ypos+row,c,False)
if show:
d.show()
return xpos+anchura+2
>>> n=cs.chars.index("5")
>>> n
5
>>> n=cs.chars.index("N")
>>> n
13
>>> d.clearAll(False)
>>> pos=putNumber(5,0,0, False)
>>> pos=putNumber(13,pos,0, True)
Con esto, tenemos todos los requisitos necesarios para programar nuestro medidor de fuerza. La implementación se llevará a cabo en la próxima publicación.
¡Sigan atentos! ¡Hasta pronto!
