Simulateur de niveau ouvert (vélo) - OpenGradeSIM : 6 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

introduction

Une certaine société de fitness américaine bien connue (Wahoo) a récemment sorti une excellente aide à l'entraînement en salle qui élève et abaisse l'avant du vélo sur le turbo trainer en fonction de la pente simulée de la colline que l'utilisateur parcourt (le Kickr Climb).

Cela a l'air incroyable, mais malheureusement, ce n'est pas disponible pour nous tous car vous aurez besoin 1) d'un entraîneur Wahoo haut de gamme et 2) de 500 £ en espèces pour en faire le vôtre.

Je me suis cassé une clavicule (ne mettez jamais un cycliste de route sur un vélo de montagne), donc j'ai eu plus de kilomètres sur l'entraîneur et plus de temps pour bricoler et j'ai pensé que cela pourrait être un projet amusant.

L'unité commerciale simule -5% à +20% donc je voulais m'en approcher mais sur 10% du budget !

Ceci est conçu autour de mon Tacx Neo, mais tout entraîneur qui diffuse ses données de puissance et de vitesse via ANT+ ou BLE pourrait fonctionner (je suppose !).

Étant donné que l'empattement de mon vélo de route mesure exactement 1000 mm, je devrais soulever les fourches de 200 mm pour simuler 20% (voir photo), donc un actionneur linéaire de 200 mm ferait l'affaire. Il est peu probable que le poids du vélo + du cycliste dépasse 100 kg et comme il est réparti entre les essieux et que la plupart se trouvent à l'arrière, 750N soulèvera 75 kg et devrait être ok. Des actionneurs plus rapides sont disponibles pour plus d'argent, mais celui-ci m'a coûté environ 20 £ et gère 10 mm/sec. Les actionneurs avec potentiomètres pouvant être utilisés comme de simples servos sont également 2 à 3 fois plus chers.

Fournitures

Impression 3D (PLA ou ABSetc) de la partie adaptateur d'axe traversant:

100 mm de tube en aluminium 3/4 pouce 10 swg (pour un cadre à axe traversant)

80 mm de stock de barre en acier inoxydable de 6 mm

Impression 3D (PLA ou ABSetc) de la chaussure pour la partie actionneur linéaire:

Impression 3D du boîtier pour le pont en H

Impression 3D du boîtier pour Arduino (Version 1 avec clavier) https://www.thingverse.com/thing:3984911 (Version 2 comme indiqué (https://www.thingverse.com/thing:3995976)

Pièce découpée au laser d'acrylique transparent de 3 mm 32 x 38 mm pour vous empêcher de transpirer partout dans l'électronique (cela n'est pas idéal).

Quelques blocs de purge (adaptés pour laisser les plaquettes dedans) pour vous éviter de pousser accidentellement les pistons d'étrier hors de vos freins à disque Shimano dans votre enthousiasme

Actionneur linéaire 750N course de 200 mm, par exemple les mini-actionneurs linéaires Al03 de

Pont L298N H (comme:

Arduino Nano IoT 33 www.rapidonline.com commande 73-4863

Clavier à membrane à 2 touches, par exemple

Module bidirectionnel de convertisseur de niveau logique IIC I2C 5V à 3,3V pour Arduino, par exemple

Alimentation 12V 3A DC - celles pour l'éclairage LED fonctionnent très bien !

Pont NPE CABLE Ant+ vers BLE

Clip imprimable en 3D pour le pont CABLE

Module d'affichage LCD OLED 1.3 avec interface IIC I2C 128x32 3.3V

Étape 1: Quelques mathématiques

Nous devons calculer l'inclinaison simulée. J'avais espéré que l'entraîneur publierait ces données avec la vitesse, la puissance, la cadence, etc. Cependant, l'entraîneur définit simplement une résistance pour maintenir la puissance de sortie en fonction du logiciel de la tablette, de l'ordinateur, etc. utilisé pour la contrôler. Je n'avais aucun moyen de capturer facilement la «note simulée» à partir du logiciel, je devais donc travailler à l'envers…

Les forces agissant sur le vélo et le cycliste sont une combinaison de pertes résistives et de la puissance nécessaire pour gravir la colline. L'entraîneur rapporte la vitesse et la puissance. Si nous pouvons trouver les pertes résistives à une vitesse donnée, la puissance restante est utilisée pour gravir la colline. La puissance de montée dépend du poids du vélo et du cycliste et de la vitesse de montée et nous pouvons donc travailler de nouveau à la pente.

J'ai d'abord utilisé l'incroyable https://bikecalculator.com pour trouver des points de données pour la perte de puissance résistive à des vitesses typiques. Ensuite, j'ai transformé le domaine de vitesse pour produire une relation linéaire et j'ai trouvé la meilleure ligne d'ajustement. En prenant l'équation de la ligne, nous pouvons maintenant calculer la puissance (W) à partir de la résistance = (0,0102*(Vitessekmh^2,8))+9,428.

Prenez la puissance de la résistance de la puissance mesurée pour donner la puissance de « escalade ».

Nous connaissons la vitesse d'ascension en km/h et la convertissons en unités SI de m/s (divisez par 3,6).

L'inclinaison est trouvée à partir de: Inclinaison (%) =((PowerClimbing/(WeightKg*g))/Speed)*100

où accélération de la chute libre g = 9,8 m/s/s ou 9,8 N/kg

Étape 2: Obtenez des données

Le calcul de l'inclinaison demande de la vitesse et de la puissance. J'ai utilisé un Arduino Nano 33 IoT pour me connecter au formateur via BLE pour recevoir cela. Au départ, je suis resté très bloqué car la version v.1.1.2 actuelle de la bibliothèque ArduinoBLE native de ce module ne gère pas l'authentification sous quelque forme que ce soit, ce qui signifie que la plupart (?) Des capteurs BLE commerciaux ne s'y associeront pas.

La solution consistait à utiliser un pont NPE Cable ANT+ vers BLE (https://npe-inc.com/cableinfo/) qui maintient le BLE intégré du formateur gratuit pour que l'application de formation puisse communiquer et ne nécessite aucune authentification sur le BLE côté.

La caractéristique de puissance BLE est assez simple car la puissance en watts est contenue dans les deuxième et troisième octets des données transmises sous la forme d'un entier de 16 bits (petit boutien, c'est-à-dire l'octet le moins significatif en premier). J'ai appliqué un filtre de moyenne mobile pour donner une puissance moyenne de 3 secondes - tout comme mon ordinateur de vélo le montre - car c'est moins erratique.

if (powerCharacteristic.valueUpdated()) {

// Définit un tableau pour la valeur uint8_t holdpowervalues[6] = {0, 0, 0, 0, 0, 0}; // Lire la valeur dans le tableau powerCharacteristic.readValue(holdpowervalues, 6); // La puissance est renvoyée sous forme de watts aux emplacements 2 et 3 (loc 0 et 1 sont des indicateurs de 8 bits) byte rawpowerValue2 = holdpowervalues[2]; // puissance l'octet le moins significatif dans l'octet HEX rawpowerValue3 = holdpowervalues[3]; // alimente la plupart des octets sig en HEX long rawpowerTotal = (rawpowerValue2 + (rawpowerValue3 * 256)); // Utilise le filtre de moyenne mobile pour donner '3s power' powerTrainer = movingAverageFilter_power.process(rawpowerTotal);

La caractéristique de vitesse BLE (Cycling Speed and Cadence) est l'une de ces choses qui vous fait vous demander ce que le SIG fumait quand ils ont écrit la spécification.

La caractéristique renvoie un tableau de 16 octets qui ne contient ni vitesse ni cadence. Au lieu de cela, vous obtenez les tours de roue et les tours de manivelle (totaux) et le temps écoulé depuis le dernier événement en 1024e de seconde. Donc plus de maths alors. Oh, et les octets ne sont pas toujours présents, il y a donc un octet indicateur au début. Oh, et les octets sont petit endian HEX, vous devez donc lire à l'envers en multipliant le deuxième octet par 256, le troisième par 65536, etc., puis en les additionnant. Pour trouver la vitesse, vous devez supposer une circonférence de roue de vélo standard pour connaître la distance….

if (speedCharacteristic.valueUpdated()) {

// Cette valeur nécessite un tableau de 16 octets uint8_t holdvalues[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Mais je ne vais lire que les 7 premiers speedCharacteristic.readValue(holdvalues, 7); octet rawValue0 = holdvalues[0]; // drapeaux binaires 8 bits int octet rawValue1 = holdvalues[1]; // révolutions l'octet le moins significatif dans l'octet HEX rawValue2 = holdvalues[2]; // révolutions l'octet le plus significatif suivant dans l'octet HEX rawValue3 = holdvalues[3]; // révolutions l'octet le plus significatif suivant dans l'octet HEX rawValue4 = holdvalues[4]; // révolutions l'octet le plus significatif dans l'octet HEX rawValue5 = holdvalues[5]; // temps depuis le dernier événement de roue octet le moins significatif octet rawValue6 = holdvalues[6]; // temps depuis le dernier événement de roue octet le plus important if (firstData) { // Récupère les révolutions de roue cumulées sous forme d'hex petit endian dans les loc 2, 3 et 4 (octet le moins significatif en premier) WheelRevs1 = (rawValue1 + (rawValue2 * 256) + (rawValue3 * 65536) + (rawValue4 * 16777216)); // Obtenir le temps depuis le dernier événement de roue en 1024e de seconde Time_1 = (rawValue5 + (rawValue6 * 256)); firstData = false; } else { // Récupère le deuxième ensemble de données long WheelRevsTemp = (rawValue1 + (rawValue2 * 256) + (rawValue3 * 65536) + (rawValue4 * 16777216)); long TimeTemp = (rawValue5 + (rawValue6 * 256)); if (WheelRevsTemp > WheelRevs1) { // assurez-vous que le vélo bouge WheelRevs2 = WheelRevsTemp; Time_2 = TimeTemp; firstData = vrai;}

// Trouver la différence de distance en cm et la convertir en km float distanceTravelled = ((WheelRevs2 - WheelRevs1) * wheelCircCM);

float kmTravelled = distanceTravelled / 1000000;

// Trouver l'heure en 1024e de seconde et la convertir en heures

float timeDifference = (Time_2 - Time_1); float timeSecs = timeDifference / 1024; float timeHrs = timeSecs / 3600;

// Trouver la vitesse kmh

vitesseKMH = (kmTravelled / timeHrs);

L'esquisse Arduino est hébergée sur GitHub (https://github.com/mockendon/opengradesim).

Étape 3: Matériel 1 l'actionneur linéaire

L'axe traversant de mon vélo de route à freins à disque spécifie un axe de 19,2 mm pour dégager l'axe traversant de 12 mm avec 100 mm entre les fourches.

Le tube en aluminium 10swg de 3/4 pouces est un ajustement parfait et un gars sympa appelé Dave sur ebay (https://www.ebay.co.uk/str/aluminiumonline) m'a fourni et coupé à la longueur pour moi pour quelques livres.

L'actionneur a une barre de 20 mm avec un trou de 6 mm, donc la pièce imprimée en 3D relie le tube en aluminium à une barre en acier de 6 mm et puisque les forces sont à 90 % de compression, certains PLA/ABS sont à la hauteur du défi.

Si vous exécutez une configuration de version rapide standard, quelque chose comme ceci (https://www.amazon.co.uk/Sharplace-Quick-Release-Conversion-Adapter/dp/B079DCY344) éviterait d'avoir à reconcevoir ce composant.

La botte est conçue pour s'adapter au bloc élévateur fourni avec mon entraîneur Tacx, mais s'intégrerait probablement dans de nombreux élévateurs similaires ou vous pouvez simplement modifier le fichier TinkerCad en fonction de vos besoins.

Étape 4: Matériel 2 - le H-Bridge

Ces cartes de pont L298N H qui sont très courantes en ligne ont un régulateur 5V intégré qui est idéal pour alimenter l'Arduino à partir de l'alimentation 12V requise pour l'actionneur linéaire. Malheureusement, la carte Arduino Nano IoT est une signalisation de 3,3 V, d'où la nécessité d'un convertisseur de niveau logique (ou d'un optoisolateur puisque les signaux sont unidirectionnels uniquement).

Le boîtier est conçu pour accepter les connecteurs d'alimentation couramment utilisés dans les applications d'éclairage à LED. J'ai découpé une rallonge USB pour permettre de connecter / déconnecter facilement l'unité principale Arduino et bien que j'étais sûr d'utiliser les lignes électriques pour l'alimentation et les lignes de données pour la signalisation 3,3 V, je déconseille honnêtement cela car je le ferais détestez que quelqu'un grille ses ports USB ou ses périphériques en les branchant par erreur !

Étape 5: Matériel 3 l'électronique de contrôle (Arduino)

Le boîtier pour l'Arduino OLED et le convertisseur de niveau logique a un support de style Garmin 1/2 tour standard à l'arrière pour lui permettre d'être monté en toute sécurité sur le vélo. Un support "à l'avant" permettra à l'unité d'être inclinée vers le haut ou vers le bas jusqu'à "zéro" la position de l'accéléromètre ou une ligne de code juste au zéro automatique au début serait facile à ajouter.

Le boîtier a un emplacement pour un clavier à membrane - il est utilisé pour définir le poids combiné du cycliste et du vélo. Vous pouvez simplement définir cela par programme, surtout si vous ne partagez un entraîneur avec personne.

Il serait peut-être intéressant d'implémenter un mode « manuel ». Peut-être qu'appuyer sur les deux boutons pourrait lancer un mode manuel, puis les boutons pourraient augmenter/diminuer l'inclinaison. Je vais l'ajouter à la liste de choses à faire !

Le fichier STL du boîtier est, encore une fois, disponible sur Thingiverse (voir la section fournitures pour le lien).

L'esquisse Arduino est hébergée sur GitHub (https://github.com/mockendon/opengradesim).

Vous pouvez imprimer un petit clip soigné pour votre pont CABLE à partir d'ici

Étape 6: « Les pattes arrière »

Beaucoup de gens ont soulevé la question du frottement de la patte arrière lorsque le vélo se déplace. Certains entraîneurs ont un axe qui bouge (comme le Kickr) mais beaucoup ne le font pas.

Actuellement, ma meilleure solution pour moi est de monter des roulements à gorge profonde standard 61800-2RS (environ 2 £ chacun) sur les adaptateurs à dégagement rapide, puis de monter les pattes d'axe traversant sur ceux-ci (voir photos) avec une brochette QR surdimensionnée

Les roulements ont besoin d'une fine rondelle de calage, par exemple M12 16 mm 0,3 mm entre l'adaptateur et le roulement.

Ils s'adaptent parfaitement et tournent avec le vélo et la brochette indépendamment du home trainer.

Pour le moment, cela modifie le décalage côté entraînement de quelques mm, vous devrez donc ré-indexer

Je conçois des pièces sur mesure (voir plan pdf) à usiner (sur le tour de mon futur beau-frère quand il a une heure pour m'aider !). Ceux-ci ne sont pas encore testés !!! Mais meuler à 1 mm de la surface intérieure de l'adaptateur QR côté entraînement d'origine est une solution rapide sans outils spéciaux;)