Inhoudsopgave:
2025 Auteur: John Day | [email protected]. Laatst gewijzigd: 2025-01-13 06:57
Invoering
Een zeker bekend Amerikaans fitnessbedrijf (Wahoo) heeft onlangs een geweldig hulpmiddel voor indoortraining uitgebracht dat de voorkant van de fiets op de fietstrainer omhoog en omlaag brengt volgens de gesimuleerde helling die de gebruiker berijdt (de Kickr Climb).
Ziet er geweldig uit, maar helaas is dit niet voor ons allemaal beschikbaar, omdat je 1) een eersteklas Wahoo-trainer en 2) £ 500 contant geld nodig hebt om dit van jou te maken.
Ik brak een sleutelbeen (zet nooit een wielrenner op een mountainbike) dus ik had meer kilometers op de trainer en meer tijd om te sleutelen en dacht dat dit een leuk project zou kunnen worden.
De commerciële unit simuleert -5% tot +20% dus daar wilde ik in de buurt komen, maar op 10% van het budget!
Dit is ontworpen rond mijn Tacx Neo, maar elke trainer die zijn kracht- en snelheidsgegevens uitzendt via ANT+ of BLE zou kunnen worden gemaakt om te werken (denk ik!).
Aangezien de wielbasis van mijn racefiets precies 1000 mm meet, zou ik de vorken 200 mm moeten optillen om 20% te simuleren (zie foto), dus een lineaire actuator van 200 mm zou het doen. Het gewicht van de fiets + berijder zal waarschijnlijk niet hoger zijn dan 100 kg en aangezien dit is verdeeld over de assen en de meeste op de achterkant zit, zal 750N 75 kg tillen en zou in orde moeten zijn. Snellere actuatoren zijn beschikbaar voor meer geld, maar deze kostte me ongeveer £ 20 en beheert 10 mm / sec. Actuatoren met potentiometers die als eenvoudige servo's kunnen worden gebruikt, zijn ook 2 tot 3 keer duurder.
Benodigdheden
3D-print (PLA of ABSetc) van het steekasadapterdeel:
100 mm 3/4 inch 10 swg aluminium buisvoorraad (voor een steekasframe)
80 mm 6 mm roestvrijstalen staafmateriaal
3D-print (PLA of ABSetc) van de schoen voor het lineaire actuatorgedeelte:
3D print van de Case voor de H-bridge
3D-print van de Case voor Arduino (Versie 1 met toetsenbord) https://www.thingiverse.com/thing:3984911 (Versie 2 zoals afgebeeld (https://www.thingiverse.com/thing:3995976)
Lasergesneden stuk van 3 mm helder acryl 32 x 38 mm om te voorkomen dat je over de hele elektronica gaat zweten (deed dat, niet ideaal).
Enkele ontluchtingsblokken (aangepast om de remblokken erin te laten) om te voorkomen dat je in je enthousiasme per ongeluk de remklauwzuigers uit je Shimano schijfremmen duwt
Lineaire Actuator 750N 200mm veerweg bijv. Al03 Mini Lineaire Actuators van
L298N H-brug (zoals:
Arduino Nano IoT 33 www.rapidonline.com bestel 73-4863
2 key membraan toetsenbord bijv. Https://www.aliexpress.com/item/33030999674.html
IIC I2C Logic Level Converter Bi-Directional Module 5V naar 3.3V Voor Arduino bijv.
12V 3A DC-voeding - die voor LED-verlichting werken geweldig!
NPE-KABEL Ant+ naar BLE-brug
3D-afdrukbare clip voor de CABLE-brug
1.3 OLED LCD-displaymodule met IIC I2C-interface 128x32 3.3V
Stap 1: wat wiskunde
We moeten de helling berekenen die wordt gesimuleerd. Ik had gehoopt dat de trainer deze gegevens samen met snelheid, kracht, cadans enz. zou adverteren, maar de trainer stelt eenvoudigweg weerstand in om het vermogen te behouden volgens de software op de tablet, computer enz. die wordt gebruikt om het te bedienen. Ik had geen manier om het 'gesimuleerde cijfer' gemakkelijk uit de software te halen, dus ik zou achteruit moeten werken …
De krachten die op de fiets en de berijder werken, zijn een combinatie van weerstandsverliezen en de kracht die nodig is om de heuvel te beklimmen. De trainer meldt snelheid en kracht. Als we de weerstandsverliezen bij een bepaalde snelheid kunnen vinden, wordt het resterende vermogen gebruikt om de heuvel te beklimmen. Het vermogen om te klimmen hangt af van het gewicht van de fietser en de berijder en de stijgsnelheid en dus kunnen we terug naar de helling werken.
Eerst gebruikte ik de verbazingwekkende https://bikecalculator.com om enkele gegevenspunten te vinden voor weerstandsverlies bij normale snelheden. Daarna heb ik het snelheidsdomein getransformeerd om een lineaire relatie te produceren en de best passende lijn gevonden. Als we de vergelijking van de lijn nemen, kunnen we nu het vermogen (W) berekenen uit weerstand = (0.0102*(Speedkmh^2.8))+9.428.
Haal de kracht uit weerstand van de gemeten kracht om kracht van 'klimmen' te geven.
We kennen de stijgsnelheid in km/uur en rekenen dit om naar SI-eenheden van m/s (delen door 3,6).
Helling wordt gevonden van: Helling (%) =((PowerClimbing/(WeightKg*g))/Speed)*100
waarbij versnelling van vrije val g = 9,8 m/s/s of 9,8 N/kg
Stap 2: Verkrijg wat gegevens
De hellingberekening vereist snelheid en kracht. Ik heb een Arduino Nano 33 IoT gebruikt om via BLE verbinding te maken met de trainer om dit te ontvangen. Ik liep aanvankelijk erg vast omdat de huidige v.1.1.2-versie van de native ArduinoBLE-bibliotheek voor deze module geen authenticatie in welke vorm dan ook aankan, wat betekent dat de meeste (?) commerciële BLE-sensoren er niet mee kunnen worden gekoppeld.
De oplossing was om een NPE-kabel ANT+ naar BLE-brug te gebruiken (https://npe-inc.com/cableinfo/) waardoor de ingebouwde BLE van de trainer vrij blijft zodat de trainingsapp kan communiceren en geen authenticatie op de BLE vereist. kant.
De BLE-vermogenskarakteristiek is vrij eenvoudig, aangezien het vermogen in watt is opgenomen in de tweede en derde bytes van de verzonden gegevens als een 16-bits geheel getal (kleine endian, oftewel het minst significante octet eerst). Ik heb een voortschrijdend gemiddelde filter toegepast om 3s gemiddeld vermogen te geven - net zoals mijn fietscomputer laat zien - omdat dit minder grillig is.
if (powerCharacteristic.valueUpdated()) {
// Definieer een array voor de waarde uint8_t holdpowervalues [6] = {0, 0, 0, 0, 0, 0}; // Lees waarde in array powerCharacteristic.readValue (holdpowervalues, 6); // Vermogen wordt teruggegeven als watt op locatie 2 en 3 (loc 0 en 1 zijn 8-bits vlaggen) byte rawpowerValue2 = holdpowervalues [2]; // power minste sig byte in HEX byte rawpowerValue3 = holdpowervalues [3]; // power meest sig byte in HEX long rawpowerTotal = (rawpowerValue2 + (rawpowerValue3 * 256)); // Gebruik voortschrijdend gemiddelde filter om '3s power' powerTrainer = movingAverageFilter_power.process(rawpowerTotal) te geven;
De BLE-snelheidskarakteristiek (Cycling Speed and Cadence) is een van die dingen waardoor je je afvraagt wat de SIG in hemelsnaam aan het roken was toen ze de specificatie schreven.
Het kenmerk geeft een array van 16 bytes terug die geen snelheid of cadans bevat. In plaats daarvan krijg je wielomwentelingen en krukomwentelingen (totalen) en tijd sinds de laatste gebeurtenisgegevens in 1024ste van een seconde. Dus meer wiskunde dan. Oh, en de bytes zijn niet altijd aanwezig, dus er staat een vlagbyte aan het begin. Oh, en de bytes zijn kleine endiane HEX, dus je moet achteruit lezen door de tweede byte te vermenigvuldigen met 256, de derde met 65536 enz. en ze vervolgens bij elkaar op te tellen. Om snelheid te vinden, moet je uitgaan van een standaard wielomtrek van een fiets om de afstand te weten …
if (speedCharacteristic.valueUpdated()) {
// Deze waarde heeft een array van 16 bytes nodig uint8_t holdvalues [16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Maar ik ga alleen de eerste 7 speedCharacteristic.readValue(holdvalues, 7) lezen; byte rawValue0 = holdvalues[0]; // binaire vlaggen 8 bit int byte rawValue1 = holdvalues [1]; // omwentelingen minst significante byte in HEX byte rawValue2 = holdvalues [2]; // omwentelingen volgende meest significante byte in HEX byte rawValue3 = holdvalues [3]; // omwentelingen volgende meest significante byte in HEX byte rawValue4 = holdvalues [4]; // omwentelingen meest significante byte in HEX byte rawValue5 = holdvalues [5]; // tijd sinds laatste wielgebeurtenis kleinste byte byte rawValue6 = holdvalues [6]; // tijd sinds laatste wielgebeurtenis meest sig byte if (firstData) { // Krijg cumulatieve wielomwentelingen als kleine endian hex in loc 2, 3 en 4 (minst significante octet eerst) WheelRevs1 = (rawValue1 + (rawValue2 * 256) + (rawValue3 * 65536) + (rawValue4 * 16777216)); // Haal de tijd op sinds de laatste wielgebeurtenis in 1024ste van een seconde Time_1 = (rawValue5 + (rawValue6 * 256)); firstData = onwaar; } else { // Krijg tweede set gegevens lang WheelRevsTemp = (rawValue1 + (rawValue2 * 256) + (rawValue3 * 65536) + (rawValue4 * 16777216)); lange TimeTemp = (rawValue5 + (rawValue6 * 256)); if (WheelRevsTemp > WheelRevs1) { // zorg ervoor dat de fiets beweegt WheelRevs2 = WheelRevsTemp; Tijd_2 = TijdTemp; firstData = waar;}
// Zoek het afstandsverschil in cm en converteer naar km float distanceTravelled = ((WheelRevs2 - WheelRevs1) * wheelCircCM);
float kmReizen = afgelegde afstand / 1000000;
// Zoek de tijd in 1024ste van een seconde en converteer naar uren
float timeDifference = (Time_2 - Time_1); float timeSecs = timeDifference / 1024; float timeHrs = timeSecs / 3600;
// Vind snelheid kmh
snelheidKMH = (kmReis / tijdHrs);
De Arduino-schets wordt gehost op GitHub (https://github.com/mockendon/opengradesim).
Stap 3: Hardware 1 de lineaire actuator
De steekas op mijn racefiets met schijfrem specificeert een 19,2 mm as om de 12 mm steekas vrij te maken met 100 mm tussen de vorken.
Standaard 3/4 inch 10swg aluminium buis past perfect en een aardige kerel genaamd Dave op ebay (https://www.ebay.co.uk/str/aluminiumonline) leverde en knipte hem voor mij op lengte voor een paar pond.
De actuator heeft een staaf van 20 mm met een gat van 6 mm, zodat het 3D-geprinte deel de aluminium buis verbindt met een stalen staaf van 6 mm en aangezien de krachten 90% compressie zijn, kan wat PLA / ABS de uitdaging aan.
Als u een standaard quick release-installatie uitvoert, zou zoiets als dit (https://www.amazon.co.uk/Sharplace-Quick-Release-Conversion-Adapter/dp/B079DCY344) voorkomen dat u dit onderdeel opnieuw hoeft te ontwerpen.
De schoen is ontworpen om in het verhogingsblok te passen dat bij mijn Tacx-trainer wordt geleverd, maar zou waarschijnlijk in veel vergelijkbare verhogingen passen of u kunt het TinkerCad-bestand aanpassen aan uw vereisten.
Stap 4: Hardware 2 - de H-brug
Dit L298N H-brugbord dat heel gebruikelijk is online, heeft een ingebouwde 5V-regelaar die geweldig is voor het voeden van de Arduino via de 12V-voeding die nodig is voor de lineaire actuator. Helaas is het Arduino Nano IoT-bord een 3.3V-signalering, vandaar de noodzaak van een logische niveauconvertor (of een opto-isolator omdat de signalen alleen unidirectioneel zijn).
De behuizing is ontworpen om de stroomconnectoren te accepteren die vaak worden gebruikt in LED-verlichtingstoepassingen. Ik heb een USB-verlengsnoer afgeslacht om het mogelijk te maken om de Arduino-head-unit gemakkelijk aan te sluiten / los te koppelen en hoewel ik zeker was dat ik de stroomkabels voor stroom en de datalijnen voor de 3.3V-signalering zou gebruiken, zou ik dit eerlijk TEGEN adviseren, omdat ik haat iemand om hun USB-poorten of randapparatuur te braden door ze per ongeluk aan te sluiten!
Stap 5: Hardware 3 de besturingselektronica (Arduino)
De behuizing voor de Arduino OLED en logic level converter heeft een standaard 1/2 draai Garmin-stijl mount aan de achterkant zodat deze stevig op de fiets kan worden gemonteerd. Met een 'aan de voorkant'-montage kan het apparaat omhoog of omlaag worden gekanteld tot de positie van de versnellingsmeter op 'nul' of een regel code om aan het begin automatisch op nul te zetten, zou eenvoudig kunnen worden toegevoegd.
De koffer heeft een plek voor een membraantoetsenbord - dit wordt gebruikt om het gecombineerde gewicht van de rijder en de fiets in te stellen. Je kunt dit gewoon programmatisch instellen, vooral als je met niemand een trainer deelt.
Het zou leuk zijn om een 'handmatige' modus te implementeren. Misschien kan het indrukken van beide knoppen een handmatige modus starten en dan kunnen de knoppen de helling verhogen / verlagen. Deze zet ik op de to-do lijst!
Het STL-bestand van de zaak is opnieuw beschikbaar op Thingiverse (zie de sectie met benodigdheden voor een link).
De Arduino-schets wordt gehost op GitHub (https://github.com/mockendon/opengradesim).
U kunt vanaf hier een leuk clipje voor uw CABLE-brug afdrukken
Stap 6: 'De achterste drop-outs'
Veel mensen hebben het probleem van het wrijven van de achtervork als de fiets beweegt aan de orde gesteld. Sommige trainers hebben een as die beweegt (zoals de Kickr), maar veel niet.
Momenteel is mijn beste oplossing voor mij om enkele standaard 61800-2RS diepgroeflagers (ongeveer £ 2 per stuk) op de snelontgrendelingsadapters te monteren en vervolgens de doorgaande as-drop-outs hierop te monteren (zie foto's) met een overmaatse QR-spies
De lagers hebben een dunne vulring nodig, bijv. M12 16 mm 0,3 mm tussen de adapter en het lager.
Ze passen perfect en draaien onafhankelijk van de trainer met de fiets en de spies mee.
Op dit moment verandert dit de offset aan de aandrijfzijde met een paar mm, dus je zult opnieuw moeten indexeren
Ik ontwerp aangepaste onderdelen (zie pdf-plan) om te bewerken (op de draaibank van mijn toekomstige zwager als hij een uur kan helpen!). Deze zijn nog niet getest!!! Maar 1 mm van het binnenoppervlak van de standaard QR-adapter aan de aandrijfzijde slijpen is een snelle oplossing zonder speciaal gereedschap;)