Manufactura industrial
Internet industrial de las cosas | Materiales industriales | Mantenimiento y reparación de equipos | Programación industrial |
home  MfgRobots >> Manufactura industrial >  >> Manufacturing Technology >> Proceso de manufactura

Una plantilla inteligente de bricolaje para comprobar la distribución de la presión

Componentes y suministros

Arduino MKR1000
× 1
Resistencia sensible a la fuerza
He usado Interlink modelo 402
× 3
Cable de alambre OpenBuilds - Por el pie
× 1
Resistencia de 10k ohmios
× 3
Power Bank
× 1
Desglose del acelerómetro de triple eje SparkFun - ADXL345
× 1

Herramientas y máquinas necesarias

Soldador (genérico)
No olvide comprar soldadura, termocontraíble y otros accesorios aplicables si no los tiene

Aplicaciones y servicios en línea

Plataforma Thinger.io
Arduino IDE

Acerca de este proyecto

La medición de presión ya se utiliza en una variedad de situaciones. Proporciona información sobre la mecánica de la marcha y tiene una amplia gama de aplicaciones, es decir, en situaciones clínicas y deportivas. En este proyecto, los sensores se utilizan para obtener información sobre la distribución del peso. También se incorpora la visualización en tiempo real del mapeo de presión porque facilita mucho la comprensión de sus datos.

Hardware necesario

  • Arduino MKR1000:la mayoría de las placas de 3.3V o 5V con Wi-Fi harán el trabajo, pero no recomendaría usar un ESP para esto. Por alguna razón, varias placas ESP arrojaron medidas inexactas al crear este proyecto.
  • Resistencias sensibles a la fuerza (3). Usé el Interlink 402 (100 N). También he usado un Interlink 406 más caro, pero en retrospectiva, el 402 también habría funcionado. Utilice más FSR para una mayor precisión.
  • Resistencias de 10K. Cambie la resistencia para escalar sus lecturas para que estén en el rango que desee. Cuanto más altas sean las resistencias, mayores serán los incrementos. Encuentre más información sobre esto aquí.
  • Acelerómetro, he usado el ADXL345 de 16G. Use esto para medir la aceleración y el movimiento del pie.
  • Un soldador para armarlo todo. Las pinzas de cocodrilo no funcionan bien en un zapato por razones obvias.

Conectando cosas

Algunas notas rápidas sobre el circuito:

FSR: Leer esto antes usted empezar soldadura: Tenga mucho cuidado al soldar los cables a los FSR. No intente hacer esto si no está seguro de tener las habilidades. Necesitas soldarlo muy rápidamente o el plástico se derrite. Créame, lo descubrí por las malas ...

No hay un lado positivo o negativo en un FSR, por lo que no tiene que preocuparse por eso.

Como mencioné anteriormente, puede cambiar las resistencias para escalar sus lecturas para que estén en el rango que prefiera.

Tierra / 5 V: Como puede ver, todos los sensores están soldados a la línea de 5V y al común.

Acelerómetro: Puede dejar el acelerómetro fuera si no lo necesita para su proyecto. No es necesario usarlo si solo desea medir la presión, pero puede ser útil si desea medir la aceleración o si necesita analizar el ciclo de la marcha. Sin embargo, no es estrictamente necesario para este tutorial.

Colocación del hardware en la plantilla

Recomiendo hacer esto después de ejecutar el código primero, porque si cometió algún error de soldadura, lo descubrirá en ese momento. Eso puede ahorrarle algunas molestias al conectar y volver a conectar el hardware a la plantilla en caso de que necesite resolver algo.

Los FSR están unidos a tres puntos de la plantilla. El FSR superior izquierdo mide la eversión, el FSR superior derecho mide la inversión y el FSR en el talón mide la presión del talón. Encontrar el lugar adecuado para sus FSR es cuestión de intentarlo. La mejor posición para colocarlos es el lugar donde el valor analógico cambia más al caminar.

Se usa cinta para mantener los cables en su lugar. Si se mueven, puede causar interferencia con las lecturas FSR. También usé cinta de velcro en la parte inferior de la suela y en el interior del zapato para mantener la plantilla en su lugar.

Coloque el acelerómetro en la parte posterior del talón del zapato si usa uno. He usado cinta adhesiva de doble cara para eso.

Midiendo las fuerzas

Ahora estamos listos para medir las fuerzas. Nota:En las siguientes dos secciones asumo que estoy familiarizado con la biblioteca Thinger.io. Para más información al respecto, me refiero a la sección titulada "enviar los datos a través de Thinger.io".

El programa tiene una parte de encabezado bastante larga, que incluye las variables que se necesitan para configurar las cosas, como los datos de la conexión WiFi. Esta parte también incluye las variables globales, en su mayoría matrices, utilizadas en el programa. Una decisión importante que hice fue utilizar matrices tanto como fuera posible. La idea es utilizar elementos de matriz individuales para cada sensor FSR. Entonces, en este caso, las matrices tienen una longitud de 3.

No se convierta en un hábito de utilizar demasiadas variables globales, debido a efectos secundarios no deseados. Los usamos porque en varios casos son necesarios para enviar los datos a través de Thinger.io.

El código se explica en los comentarios. Repasaremos el código paso a paso. Puede descargar el código completo a continuación.

  #define _DEBUG_ // nos permite usar el Monitor serial 
#include
#include
#include // Acelerómetro
#include // Acelerómetro
#include // Acelerómetro
#include
#define USERNAME "yourUsername"
#define DEVICE_ID "yourDeviceID"
#define DEVICE_CREDENTIAL "yourDeviceCredential"
#define SSID "yourSSID"
#define SSID_PASSWORD "yourSSIDPassword"
// * Sensores FSR * /
#define noFSRs 3 // Número de FSRs conectados
#define FSR1 A1
#define FSR2 A2
#define FSR3 A3
float fsrVoltageArray [3 ]; // La lectura analógica convertida y escalada a voltaje como un número de coma flotante
float fsrForceArray [3]; // La fuerza en Newton
float fsrWeightInGramsArray [3]; // Peso convertido a gramos
int pinArray [3] ={FSR1, FSR2, FSR3}; // El ID de pin para los tres dispositivos
float forceMaxArray [3] ={100.0, 100.0, 100.0}; // Fuerzas máximas soportadas
float million =1000000.0; // Unidad para "1 / micro
float conversionToKgrams =1.0 / 9.80665;
long K =1000;
long R =10 * K; // R in K Ohm
long Vcc =5000; // 5V =5000mV, 3.3V =3300 mV
Voltaje flotante Max =0.98 * Vcc; // Voltaje máximo establecido en 95% de Vcc. Establezca la fuerza al máximo más allá de este valor.
ThingerWifi101 cosa (USERNAME, DEVICE_ID, DEVICE_CREDENTIAL);

No entre en pánico si aún no lo comprende todo. Tendrá más sentido una vez que haya visto el resto del código.

Queremos visualizar los resultados. Para ello utilizamos la biblioteca Wi-Fi Thinger.io. Esta conexión se configura a través de la siguiente línea:

  ThingerWifi101 cosa (USERNAME, DEVICE_ID, DEVICE_CREDENTIAL);  

Los argumentos de entrada se obtienen a través de su cuenta en Thinger.io, por lo que debe configurar esto primero.

En la función setup (), la conexión en serie se establece primero. A esto le sigue una llamada para crear la conexión WiFi.

  void setup (void) {
Serial.begin (115200); // Iniciar comunicación serial
thing.add_wifi (SSID, SSID_PASSWORD); // llamar para configurar la función WiFi
}
void loop (void) {
thing.handle ();
}

A continuación, definimos una "cosa" llamada "presión". Una "cosa" es un concepto clave de la biblioteca Thinger.io. Se comporta como una función, pero tiene una estructura especial. Es necesario enviar los datos de los resultados a la nube. Se pueden encontrar más detalles sobre esta biblioteca en la sección "Enviar los datos a través de Thinger.io".

La "cosa" llamada "presión" lee los valores de los tres sensores FSR y los imprime en la consola serie. Los mismos valores también se envían al canal "de salida". De esta manera, podemos verificar fácilmente los datos de entrada sin procesar.

En la "cosa" con el nombre "voltaje", los valores de voltaje se leen y almacenan en una variable local llamada "fsrReading". Con la función "mapa", el valor se escala, en relación con los valores mínimo y máximo admitidos, y se devuelve a la matriz "fsrVoltageArray". A través del bucle for, nos aseguramos de que cada FSR tenga su propia ubicación en esta matriz de resultados.

Tenga en cuenta que todo el código se coloca dentro de la función de configuración. No pongas nada dentro del bucle (como probablemente estés acostumbrado). La biblioteca Thinger.io no puede manejar eso ...

  void setup (void) {
Serial.begin (115200); // Iniciar comunicación serial
thing.add_wifi (SSID, SSID_PASSWORD); // llamar para configurar la función WiFi
/ * sensores FSR * /
cosa ["presión"]>> [] (pson &out) {
out ["FSR1"] =analogRead (FSR1);
Serial.print ("FSR1:");
Serial.println (analogRead (FSR1));
out ["FSR2"] =analogRead (FSR2);
Serial.print ("FSR2:");
Serial.println (analogRead (FSR2));
out ["FSR3"] =analogRead (FSR3);
Serial.print ( "FSR3:");
Serial.println (analogRead (FSR3));
};
cosa ["voltaje"]>> [] (pson &out) {
para (int FSR =0; FSR fsrVoltageArray [ FSR] =0,0; // Restablecer valores al ingresar
fsrForceArray [FSR] =0.0;
int fsrPin =pinArray [FSR];
int fsrReading =analogRead (fsrPin);
fsrVoltageArray [FSR] =(flotante) mapa (fsrReading, 0, 1023, 0, 5000); // cambia el 5000 a otro valor si no usas un dispositivo de 5V
} // fin del ciclo sobre FSR's
out ["FSR1voltage"] =fsrVoltageArray [0];
out ["FSR2voltage"] =fsrVoltageArray [1];
out ["FSR3voltage"] =fsrVoltageArray [2];
};
bucle void (void) {
cosa.handle ();
// No ponga ningún código aquí porque a Thinger.io no le gustará.
}

Una vez finalizado el bucle for, los valores se envían al canal de salida "out". Cada sensor tiene una cadena única, como "FSR1voltage".

La "cosa" llamada "newton" es la función más compleja de este programa. Convierte el voltaje en una fuerza en Newtons. Nuevamente, se usa un bucle for para hacer esto para cada FSR.

El cálculo es bastante complejo, porque necesitamos distinguir varios casos de esquina. En caso de que el valor de voltaje sea demasiado pequeño o demasiado grande, asignamos un valor fijo a la fuerza. En caso de que el voltaje esté entre los valores de corte, se usa una función logarítmica para calcular la fuerza. Esta función se elige para reducir la pendiente de la curva.

Tenga en cuenta que las fórmulas son solo aproximadas. Cada sensor puede tener una curva (algo) diferente, pero por simplicidad no distinguimos esto aquí.

El valor resultante de los cálculos se almacena en la matriz "fsrForceArray". Nuevamente, cada FSR tiene su propia posición en esta matriz. Los tres valores finales se envían al canal de salida "out".

La función final de "cosa" se llama "peso". Se aplica una conversión sencilla para devolver la fuerza como el peso en gramos.

  cosa ["newton"]>> [] (pson &out) {
for (int FSR =0; FSR // El valor del la fuerza F en función del voltaje V se calcula como:F (V) =(Fmax / Vmax) * V
float force_value =(forceMaxArray [FSR] / voltageMax) * fsrVoltageArray [FSR];
// Se distinguen tres situaciones:
//
// 1. Si V está demasiado cerca del máximo (según lo definido por voltageMax), el
//
// 2 . Si la fuerza F calculada es demasiado pequeña, la ponemos a cero para evitar efectos de ruido.
//
// 3. En todos los demás casos, tomamos el valor logarítmico para reducir el balandro y
if (fsrVoltageArray [FSR] // V no es demasiado alto en esta rama
if (force_value <=1.00) {
fsrForceArray [FSR] =0.0; // La fuerza es demasiado pequeña, establézcala en cero
} else {
fsrForceArray [FSR] =log10 (force_value); // El valor está bien, tome el registro de esto
}
} else {
// Cap la fuerza si el voltaje está demasiado cerca de Vcc (para Vcc sería infinito)
fsrForceArray [FSR] =log10 (forceMaxArray [FSR]);
Serial.print ("Corte activado para FSR ="); Serial.println (FSR);
}
} // Fin del ciclo sobre FSR
out ["FSR1newton"] =fsrForceArray [0];
out ["FSR2newton"] =fsrForceArray [1];
fuera ["FSR3newton"] =fsrForceArray [2];
}; // fin de la cosa
cosa ["peso"]>> [] (pson &out) {
// Cálculo sencillo para convertir la fuerza en Newton al peso en gramos
para ( int FSR =0; FSR fsrWeightInGramsArray [FSR] =fsrForceArray [FSR] * conversionToKgrams * 1000.0;
}
out ["FSR1weight"] =fsrWeightInGramsArray [0];
fuera ["FSR2weight"] =fsrWeightInGramsArray [1];
fuera ["FSR3weight"] =fsrWeightInGramsArray [2];
}; // fin de la cosa

No olvide configurar el panel en Thinger.io. Supongo que sabes cómo funciona eso.

Sugerencia :Si todo funciona como se esperaba, su panel debería verse similar a esto:

Midiendo la aceleración

En realidad, esto es mucho más fácil que medir la presión. Primero debemos agregar algo de código a la parte del encabezado. Comenzamos con Incluir las bibliotecas "Wire.h" (para comunicarse con el pin SDA y SDL), "Adafruit_Sensor.h" y "Adafruit_ADXL345_U.h". También necesitaremos tres nuevas variables globales, para que podamos medir y transferir la aceleración en los ejes x, y y z

No elimine las bibliotecas que ha agregado anteriormente. Los necesitará para la conexión a Thinger.io.

En el siguiente bloque de código, verificamos que el acelerómetro responda. Si no, no pasará nada. De lo contrario, se define el rango y se ejecuta una "cosa" llamada "acelerómetro". Esto consulta el dispositivo y envía los tres valores de aceleración en la dirección x, y, z al canal de salida "out".

Esta parte del código es similar al código de muestra incluido de Adafruit (Archivo> Ejemplos> Adafruit ADXL345), pero dejé algunas partes porque no las necesitamos.

  #include  
#include
#include
/ * Asigne una ID única a este sensor en el mismo tiempo * /
Adafruit_ADXL345_Unified accel =Adafruit_ADXL345_Unified (12345);
int x =0;
int y =0;
int z =0;
void setup (void) {
Serial.begin (115200);
if (! accel.begin ()) {// Inicializar el sensor
Serial.println ("No ADXL345 detectó ");
} else {
// Rango para este sensor:si no conoce el rango, ejecute
// displayDataRate del código de ejemplo de ADXL345 proporcionado por Adafruit
accel. br /> accel.getEvent (&evento); // Obtener un nuevo evento de sensor
out ["x"] =event.acceleration.x; // Mostrar los resultados (la aceleración se mide en m / s ^ 2)
out ["y"] =event.acceleration.y;
out ["z"] =event.acceleration.z;
Serial.print ("X:"); Serial.print (event.acceleration.x); Serial.print ("");
Serial.print ("Y:"); Serial.print (event.acceleration.y); Serial.print ("");
Serial.print ("Z:"); Serial.print (event.acceleration.z); Serial.print (""); Serial.println ("m / s ^ 2");
}; // fin de la cosa
} // fin de la declaración if / else
}

Sugerencia: después de ejecutar el código anterior, su resultado debería ser similar al ejemplo que se muestra a continuación

Poniéndolo todo junto

Encuentre el código completo en la parte inferior de la página :)

Envíe los datos a través de Thinger.io

Esta biblioteca está bien documentada aquí, pero aquí hay información importante para hacer "cosas" (sin juego de palabras) más fáciles de escribir y usar.

Thinger.io es una biblioteca muy extensa. En esta sección solo cubrimos la funcionalidad necesaria y utilizada en nuestra aplicación. La estructura es la siguiente (observe el punto y coma ";" después de la llave de cierre "}"):

  cosa []>> [] (pson &out) 
{

};

A esto se le llama función lambda en C ++. La primera palabra obligatoria para comenzar la definición es "cosa" y la función completa también se conoce como "cosa".

La cadena (por ejemplo, cosa ["myFirstThing"]) le da un nombre a la función. Cada "cosa" debe tener un nombre único.

El símbolo ">>" indica que esta "cosa" solo tiene valores de salida. En caso de que sea necesario introducir datos, cámbielo a "<<". Si se necesita tanto entrada como salida, se debe utilizar el símbolo "=". En nuestro caso, solo tenemos valores de salida.

El argumento "pson &out" significa que nuestros valores de salida se envían a través de una estructura de datos llamada "out". El tipo de datos "pson" es muy flexible y puede contener varios tipos de variables, y también admite documentos JSON.

En nuestro código usamos la forma "out [] =value" t o enviar valores a la pantalla de visualización relacionada con la llamada "ThingerWifi101 thing (USERNAME, DEVICE_ID, DEVICE_CREDENTIAL)" en la primera parte del programa.

Como habrás notado, normalmente no hay mucho código dentro de la función de bucle. Solo necesitará llamar a "thing.handle ()". También puede llamar a puntos finales y recursos de transmisión en la parte del bucle. Todo el resto del código se maneja en las "cosas" que defina.

El código dentro de las "cosas" se repite continuamente. Es importante poner sus cálculos dentro de las "cosas" si sus datos se actualizan con regularidad, como en nuestro caso.

Preguntas frecuentes

¡No pasa nada!

Revisa tus cables. Lo más probable es que algo se haya estropeado en este nivel. Si no aparece nada dentro de su Serial Monitor, verifique si "#define _DEBUG_" está en la primera línea de su código. TLS también puede estar interfiriendo. Puede desactivar eso, pero tenga cuidado con esto. También verifique si su conexión a Thinger.io está funcionando bien.

El resultado no es el esperado

¿Todo el código que necesita actualizarse dentro de una "cosa"? Si está fuera de una "cosa", no se actualiza. También descubrí que los dispositivos ESP no funcionan bien con los sensores FSR sin razón aparente.

El salida es no actualizado regularmente

¿Agregó retrasos a su código? Eliminarlos :) Puede establecer la frecuencia de actualización en Thinger.io mismo.

Preferiría tener todo el resultado en un gráfico

Agrega todo el código dentro de una sola "cosa"

¡Bien hecho!

Espero que este tutorial te haya ayudado a comprender los conceptos básicos de los sensores FSR, acelerómetros y Thinger.io. Me encantaría leer cualquier sugerencia para mejorar este código, ¡y no seas tímido y comparte tus creaciones!

Código

  • Tutorial de plantilla inteligente
Tutorial de plantilla inteligente Arduino
Código completo de este tutorial
 #define _DEBUG_ // Asegúrese de que esto venga antes que cualquier otra inclusión o su placa podría fallar / * Encuentre el tutorial aquí:https://www.hackster.io/projects/a5ceae*/# include  // Thinger # include  // Thinger # include  // Acelerometer # include  // Acelerometer # include  // Acelerometer # define USERNAME "yourUsername" #define DEVICE_ID "yourDispositivo" #define DEVICE_CREDENTIAL "yourCredential" #define SSID "yourSSID" #define SSID_PASSWORD "yourSSIDPassword" Adafruit_ADXL345_Unified accel =12345_UnifiedXL // Acelerómetroint x =0; // Restablecer a 0 int y =0; int z =0; // * Sensores FSR * / # define noFSRs 3 // Número de FSRs conectados # define FSR1 A1 // Puertos analógicos # define FSR2 A2 #define FSR3 A3 float fsrVoltageArray [3]; // La lectura analógica convertida y // escalada a voltaje como punto flotante // numberfloat fsrForceArray [3]; // La fuerza en Newtonfloat fsrWeightInGramsArray [3]; // Peso convertido a gramosint pinArray [3] ={FSR1, FSR2, FSR3}; // El ID de pin para los // tres dispositivos flotantes forceMaxArray [3] ={100.0, 100.0, 100.0}; // Fuerzas máximas // flotador soportado millones =1000000.0; // Unidad para "1 / conversión de microfloatToKgrams =1.0 / 9.80665; long K =1000; long R =10 * K; // R en K Ohmlong Vcc =5000; // 5V =5000mV, 3.3V =3300 mVfloat voltageMax =0.98 * Vcc; // Voltaje máximo establecido en 95% de Vcc. Establezca // la fuerza al máximo más allá de este //valor.ThingerWifi101 cosa (USERNAME, DEVICE_ID, DEVICE_CREDENTIAL); // Llame para configurar la función WiFi, void setup (void) {Serial.begin (115200); thing.add_wifi (SSID, SSID_PASSWORD); if (! Accel.begin ()) {// Inicializa el sensor Serial.println ("No se detectó ADXL345.");} Else {accel.setRange (ADXL345_RANGE_16_G); // Rango para este sensor ["acelerómetro"]>> [] (pson &out) {sensor_event_t event; accel.getEvent (&event); out ["x"] =event.acceleration.x; out [ "y"] =event.acceleration.y; out ["z"] =event.acceleration.z;};} / * sensores FSR * / cosa ["presión"]>> [] (pson &out) {out ["FSR1"] =analogRead (FSR1); // Serial.print ("FSR1:"); // Serial.println (analogRead (FSR1)); out ["FSR2"] =analogRead (FSR2); // Serie .print ("FSR2:"); // S erial.println (analogRead (FSR2)); out ["FSR3"] =analogRead (FSR3); // Serial.print ("FSR3:"); // Serial.println (analogRead (FSR3)); }; cosa ["voltaje"]>> [] (pson &out) {for (int FSR =0; FSR > [] (pson &out) {for (int FSR =0; FSR > [] (pson &out) {// Cálculo sencillo para convertir la fuerza en Newton al peso en gramos para (int FSR =0; FSR   

Esquemas

Tres FSR (con divisores de voltaje) y un acelerómetro.

Proceso de manufactura

  1. Smart Bartender
  2. ABB presenta el sensor inteligente para comprobar el estado de los cojinetes
  3. Sea inteligente:el futuro de su hogar
  4. Sea inteligente con su dólar de IoT
  5. Sistema de gestión de edificios:su boleto a una ciudad inteligente
  6. Verifique el uso de memoria de sus objetos de Python
  7. Una revisión trimestral de su cadena de suministro
  8. DIY Osciloscopio Arduino simple de 20 kHz en Nokia 5110 LCD
  9. Mide tu tiempo de reacción
  10. La bomba de presión de agua misteriosa puede ser el trabajador más duro en su hogar
  11. Reducción de la caída de presión en su sistema de aire comprimido