Proyecto de coeficiente de efectividad para escalada con galga extensiométrica

DATOS

Universidad de Salamanca – Master Universitario en Profesor de Educación Secundaria Obligatoria, Bachillerato, Formación Profesional y Enseñanza de Idiomas.

Asignatura: Innovación Docente en la Especialidad de Tecnología.

Curso: 2019/2020

COMPONENTES DEL GRUPO

• Francisco Borrego Bermejo
• Rubén Hernández Martín
• Iván Pérez Díez

CONTEXTO

El siguiente proyecto se puede realizar para alumnos de 4º de la E.S.O. de la asignatura de Tecnología tanto Académicas como Aplicadas.

Para el caso de académicas esta relacionado con los bloques:

Bloque 1. Electrónica aplicada.

Bloque 2. Control y robótica.

Bloque 4. Tecnologías del diseño asistido e impresión 3D.

Para el caso de aplicadas esta relacionado con los bloques:

Bloque 1. Tecnologías de la Información y la Comunicación.

Bloque 3. Electrónica.

Bloque 4. Control y robótica.

FUNCIONAMIENTO

El objetivo del sistema es medir la fuerza que se realiza sobre una presa de escalada en un rocódromo cuando el escalador se encuentra realizando el paso sobre ella. Después de medir la fuerza sacaremos un coeficiente que hemos llamado de efectividad que será un indicador de lo bien que se utiliza la técnica en este deporte.

Entendemos que cuanto menos fuerza se realice sobre la presa mejor se utiliza la técnica de escalada. Como el peso juega un papel determinante en la fuerza sobre la presa; lo que hacemos con el coeficiente es similar a lo que se hace en el ciclismo respecto a los puertos de montaña que se utilizan los W/Peso.

En nuestro caso será:

C.efectividad = Fuerza / Peso

Para medir la fuerza sobre la presa se utilizará una galga extensiométrica con su adaptador de señal HX711 que proporciona una señal entendible para Arduino y  su librería correspondiente. Esta fuerza no la mediremos siempre, ya que solo queremos la ejercida por las manos del escalador por lo que la presa tendrá instalado un sensor capacitivo para distinguir entre mano y pie.

Para conocer el peso del deportista tendremos unos interruptores en las entradas digitales de Arduino para cargar el peso dentro de la franja correspondiente.

Una vez que en Arduino tenemos la fuerza y el peso, simplemente haremos la división para sacar el coeficiente de efectividad.

Todos estos datos se sacan por el puerto serie para verlos y además nos permite exportarlos a Excel para hacer las distintas gráficas.

Cuanto más bajo es el coeficiente mejor se utiliza la técnica de escalada para esa vía que hemos diseñado.

Nota aclaratoria: Decir que la fuerza que una persona ejerce sobre una presa es bastante compleja en su conjunto y depende de muchos factores al igual que la utilización de la técnica. Este pequeño proyecto es una simplificación y aproximación de medir esa fuerza con una galga extensiometrica en una sola dirección y por lo tanto quedarían muchos cabos sueltos para depurar el coeficiente del que hablamos.

ESQUEMA DEL CIRCUITO

MATERIALES UTILIZADOS 

• Arduino uno
• Protoboard 
• 1 LED verde
•  3 pulsadores
• HX711 (convertidor galga extensiomética)
• Galga extensiométrica 20 Kg.
• 1 resistencia 220Ω
• 4 resistencia 10kΩ 
• Cables para el montaje de los circuitos
• Papel de plata (sensor capacitivo)
• Sargento
• Ordenador

Materiales utilizados para la maqueta:

• Presa diseñada con Tinkercad e impresa en 3D
• Muñeco
• Cartón
• Cinta de carrocero
• Mosquetones
• Pegamento
• Cinta adhesiva
• Pintura blanca
• Cartulina
• Cuerda
• Presas de cartón
• Tornillos de sujeción

IMÁGENES DE LA COSNTRUCCIÓN DEL PROYECTO

CODIGO FUENTE

// PROGRAMA PARA LA ASIGNATURA DE INOVACIÓN DOCENTE (MUPES USAL.)
//_____________FRANCISCO BORREGO BERMEJO, IVÁN PÉREZ DÍEZ Y RUBÉN HERNÁNDEZ MARTÍN
//_____________!!!!! %%%%COEFICIENTE DE EFECTIVIDAD PARA EL ENTRENAMIENTO DE LA
ESCALADA%%%%!!!!!!___________________
//INICIO DEL PROGRAMA. Librerias necesarias para el funcionamiento de la galga y del sensor
capacitivo.
#include <Q2HX711.h> // Libreria para el sensor capacitivo.
#include <HX711_ADC.h> // Libreria para el convertidor HX711 (bascula con galga
extensiometrica.)
#include <HX711.h> // Libreria para el convertidor HX711 (bascula con galga
extensiometrica.)
#include "HX711.h" // Libreria para el convertidor HX711 (bascula con galga
extensiometrica.)
#include <CapacitiveSensor.h> // Libreria para el sensor capacitivo (bascula con galga
extensiometrica.)
//VARIABLES PARA SENSOR CAPACITIVO, RANGO DE PESO Y BASCULA CON GALGA EXTENSIOMETRICA.
byte pinData = 3; // Pin de datos y de reloj para el sensor capacitivo.
byte pinClk = 2;
CapacitiveSensor capSensor = CapacitiveSensor(4, 5);
int threshold =400; // Limite de variable ajustada a la mano humana.
(distinguimos entre mano y pie)


const int ledPin = 12; // En el pin 12 conectamos el led que se iluminará
cuando toquemos con la mano LA PRESA.
const int cincuenta =11 ; // En el pin 11 Interruptor para meter 50kg.
const int setenta = 10; // En el pin 10 Interruptor para meter 70kg
const int noventa = 9; // En el pin 9 Interruptor para meter 90kg
HX711 bascula;
// Variable para calibrar el peso y el sensor en formato float.
float factor_calibracion = 70000.0; //Este valor es para calibrar nuestra galga de 20 kg.
float pesoPersona=70; // variable que pone 70 kg a la persona.
float resultado = 0; // variable declarada para el resultado
int manoPresa; // variable necesaria para la detección de la mano.
int leer50; // variable para leer interruptor de 50.
int leer70; // variable para Leer interruptor de 70.
int leer90; // variable para leer interruptor de 90.
// FIRST SCAN DEL PROGRAMA ( SOLO SE EJECUTA UNA VEZ AL INICIO )
void setup() {
Serial.begin(9600); // Habilitamos el puerto serie.
// Instrucciones para calibrar la bascula desde el puerto serie.
Serial.println("HX711 programa de calibracion");
Serial.println("Quita cualquier peso de la bascula");
Serial.println("Una vez empiece a mostrar informacion de medidas, coloca un peso conocido


encima de la bascula");
Serial.println("Presiona + para incrementar el factor de calibracion");
Serial.println("Presiona - para disminuir el factor de calibracion");
bascula.begin(pinData, pinClk); // Iniciar sensor
bascula.set_scale(); // Aplicar la calibración
bascula.tare(); // Iniciar la tara
// No tiene que haber nada sobre el peso
// Obtener una lectura de referencia
long zero_factor = bascula.read_average();
// Mostrar la primera desviación
Serial.print("Zero factor: ");
Serial.println(zero_factor);
// Led pin lo ponemos como salida para led del capacitivo
pinMode(ledPin, OUTPUT);
pinMode(cincuenta, INPUT); //Declaramos cincuenta como entrada.
pinMode(setenta, INPUT); //Declaramos setenta como entrada.
pinMode(noventa, INPUT); //Declaramos noventa como entrada.
}
// Fin del SETUP
// COMIENZO DEL BUCLE QUE SE EJECUTARA SIEMPRE.
void loop() {


long sensorValue = capSensor.capacitiveSensor(30);// Valor aportado por el sensor
capacitivo
Serial.println(sensorValue); // imprimir el valor del sensor
Serial.println("pesopersona"); // imprimir el valor de los kg de la persona.
if (sensorValue > threshold) { // Condicion de la variable para encender el led cuando
tocamos el capacitivo.
digitalWrite(ledPin, HIGH);
}
// Si el valor es menor apagamos el led.
else {
digitalWrite(ledPin, LOW);
}
delay(10); // Retardo de 10 mS.
if (sensorValue > threshold); // Si el valor del capacitivo es mayor que el estipulado
(se esta tocando con la mano).
{
// Aplicar 00
bascula.set_scale(factor_calibracion);
// Mostrar la información para ajustar el factor de calibración
Serial.print("Leyendo: ");
Serial.print(bascula.get_units(), 1);
Serial.print(" kgs");


Serial.print(" factor_calibracion: ");
Serial.print(factor_calibracion);
Serial.println();
// Obtener información desde el monitor serie
if (Serial.available())
{
char temp = Serial.read();
if (temp == '+')
factor_calibracion += 10;
else if (temp == '-')
factor_calibracion -= 10;
else
delay (10); // Retardo de 10 mS
}
}
leer50 = digitalRead(cincuenta); // Leemos las entradas digitales para ver que
interruptor se pulsa.
if (leer50 == HIGH) { // El valor de arranque es de 70 Kg en el set up si se
pulsan los interruptores cambiará.
pesoPersona = 50;
}
leer70 = digitalRead(setenta);
if (leer70 == HIGH) {


pesoPersona = 70;
}
leer90 = digitalRead(noventa);
if (leer90 == HIGH) {
pesoPersona = 90;
}
manoPresa = digitalRead(ledPin); // Leemos el led del capacitivo; si esta en on haremos
la cuenta
// para sacar el coeficiente de efectividad que será
fuerza/ peso.
if (manoPresa == HIGH) {
resultado = bascula.get_units()/pesoPersona; // Division fuerza en galga/ Peso se
carga en var resultado.
Serial.println("Coeficiente de efectividad");
Serial.println(resultado);
}
// Si no se cumple la condicion de
tocar la presa resultado = 0.
else {
resultado = 0;
}
delay (500); // Retardo para ver comodamente el
monitor Serie.
}