Simulatore di voto aperto (bicicletta) - OpenGradeSIM: 6 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

introduzione

Una nota azienda di fitness statunitense (Wahoo) ha recentemente presentato un ottimo ausilio per l'allenamento indoor che alza e abbassa la parte anteriore della bici sul turbo trainer in base al grado di salita simulato che l'utente sta percorrendo (il Kickr Climb).

Sembra incredibile, ma purtroppo non è disponibile per tutti noi in quanto avrai bisogno di 1) un trainer Wahoo di alta gamma e 2) £ 500 in contanti per renderlo tuo.

Mi sono rotto una clavicola (non ho mai messo un ciclista su una mountain bike) quindi ho avuto più chilometri sull'allenatore e più tempo per armeggiare e ho pensato che questo potesse essere un progetto divertente.

L'unità commerciale simula da -5% a +20% quindi volevo avvicinarmi a questo, ma con il 10% del budget!

Questo è progettato attorno al mio Tacx Neo, ma qualsiasi trainer che trasmette i suoi dati di potenza e velocità tramite ANT + o BLE potrebbe essere fatto funzionare (immagino!).

Poiché la base della ruota della mia bici da strada misura esattamente 1000 mm, avrei bisogno di sollevare le forcelle di 200 mm per simulare il 20% (vedi foto), quindi un attuatore lineare da 200 mm farebbe. È improbabile che il peso della bici + del ciclista superi i 100 kg e poiché questo è distribuito tra gli assi e la maggior parte è sul retro, 750 N solleverà 75 kg e dovrebbe essere ok. Attuatori più veloci sono disponibili per più soldi, ma questo mi è costato circa £ 20 e gestisce 10 mm/sec. Anche gli attuatori con potenziometri che possono essere utilizzati come semplici servi sono da 2 a 3 volte più costosi.

Forniture

Stampa 3D (PLA o ABSetc) della parte dell'adattatore perno passante:

100 mm di tubo in alluminio da 3/4 di pollice 10 swg (per un telaio con perno passante)

80 mm di barra in acciaio inossidabile da 6 mm

Stampa 3D (PLA o ABSetc) della scarpa per la parte dell'attuatore lineare:

Stampa 3D della custodia per il ponte H

Stampa 3D della custodia per Arduino (versione 1 con tastiera) https://www.thingiverse.com/thing:3984911 (versione 2 come mostrato (https://www.thingiverse.com/thing:3995976)

Pezzo tagliato al laser di acrilico trasparente da 3 mm 32 x 38 mm per impedirti di sudare su tutta l'elettronica (l'ha fatto, non è l'ideale).

Alcuni blocchi di spurgo (adattati per lasciare le pastiglie) per evitare che tu spinga accidentalmente i pistoni della pinza dai tuoi freni a disco Shimano nel tuo entusiasmo

Attuatore lineare 750N corsa 200mm ad es. Attuatori lineari Al03 Mini da

Ponte L298N H (come:

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

Tastiera a membrana a 2 tasti, ad esempio

Modulo bidirezionale del convertitore di livello logico IIC I2C da 5 V a 3,3 V per Arduino, ad es.

Alimentatore 12V 3A DC: quelli per l'illuminazione a LED funzionano alla grande!

CAVO NPE Ponte Ant+ a BLE

Clip stampabile in 3D per il bridge CABLE

Modulo display LCD OLED da 1,3 con interfaccia IIC I2C 128x32 3,3 V

Passaggio 1: un po' di matematica

Dobbiamo calcolare l'inclinazione simulata. Speravo che il trainer pubblicizzasse questi dati insieme a velocità, potenza, cadenza, ecc. Tuttavia, il trainer imposta semplicemente la resistenza per mantenere la potenza in base al software sul tablet, computer ecc. utilizzato per controllarlo. Non avevo modo di acquisire facilmente il "voto simulato" dal software, quindi avrei dovuto lavorare all'indietro…

Le forze che agiscono sulla bici e sul ciclista sono una combinazione di perdite resistive e potenza necessaria per salire la collina. Il trainer segnala velocità e potenza. Se riusciamo a trovare le perdite resistive a una data velocità, la potenza rimanente viene utilizzata per salire la collina. La potenza per salire dipende dal peso della bici e del ciclista e dalla velocità di salita, quindi possiamo lavorare di nuovo sulla pendenza.

Per prima cosa ho usato il fantastico https://bikecalculator.com per trovare alcuni punti dati per la perdita di potenza resistiva a velocità tipiche. Quindi ho trasformato il dominio della velocità per produrre una relazione lineare e ho trovato la linea più adatta. Prendendo l'equazione della linea possiamo ora calcolare la potenza (W) dalla resistenza = (0.0102*(Speedkmh^2.8))+9.428.

Prendi il potere dalla resistenza dal potere misurato per dare il potere di 'arrampicarsi'.

Conosciamo la velocità di salita in km/h e la convertiamo in unità SI di m/s (dividiamo per 3,6).

L'inclinazione si ricava da: Inclinazione (%) =((PowerClimbing/(WeightKg*g))/Speed)*100

dove accelerazione di caduta libera g = 9,8 m/s/s o 9,8 N/kg

Passaggio 2: ottenere alcuni dati

Il calcolo dell'inclinazione richiede velocità e potenza. Ho usato un Arduino Nano 33 IoT per connettermi al trainer tramite BLE per riceverlo. Inizialmente sono rimasto molto bloccato poiché l'attuale versione v.1.1.2 della libreria ArduinoBLE nativa per questo modulo non gestisce l'autenticazione in alcuna forma, il che significa che la maggior parte (?) I sensori BLE commerciali non si accoppiano con essa.

La soluzione è stata quella di utilizzare un cavo NPE da ANT+ a ponte BLE (https://npe-inc.com/cableinfo/) che mantiene il BLE integrato del trainer gratuito per consentire all'app di formazione di comunicare e non richiede autenticazione sul BLE lato.

La caratteristica di potenza BLE è piuttosto semplice in quanto la potenza in watt è contenuta nel secondo e nel terzo byte dei dati trasmessi come un intero a 16 bit (little endian, ovvero l'ottetto meno significativo per primo). Ho applicato un filtro della media mobile per fornire una potenza media di 3 secondi, proprio come mostra il mio computer da bici, poiché è meno irregolare.

if (powerCharacteristic.valueUpdated()) {

// Definisce un array per il valore uint8_t holdpowervalues[6] = {0, 0, 0, 0, 0, 0}; // Legge il valore nell'array powerCharacteristic.readValue(holdpowervalues, 6); // La potenza viene restituita come watt nelle posizioni 2 e 3 (loc 0 e 1 sono flag a 8 bit) byte rawpowerValue2 = holdpowervalues[2]; // byte di potenza minima in byte esadecimale rawpowerValue3 = holdpowervalues[3]; // power most sig byte in HEX long rawpowerTotal = (rawpowerValue2 + (rawpowerValue3 * 256)); // Usa il filtro della media mobile per dare '3s power' powerTrainer = MovingAverageFilter_power.process(rawpowerTotal);

La caratteristica di velocità BLE (Cycling Speed and Cadence) è una di quelle cose che ti fanno chiedere cosa diavolo stava fumando la SIG quando hanno scritto le specifiche.

La caratteristica restituisce un array di 16 byte che non contiene né velocità né cadenza. Invece ottieni i giri della ruota e i giri della pedivella (totali) e il tempo trascorso dai dati dell'ultimo evento in 1024esimi di secondo. Quindi più matematica allora. Oh, e i byte non sono sempre presenti, quindi c'è un flag byte all'inizio. Oh, e i byte sono little endian HEX, quindi devi leggere all'indietro moltiplicando il secondo byte per 256, il terzo per 65536 ecc. Quindi sommandoli insieme. Per trovare la velocità è necessario assumere una circonferenza della ruota della bicicletta standard per conoscere la distanza….

if (speedCharacteristic.valueUpdated()) {

// Questo valore necessita di un array di 16 byte uint8_t holdvalues[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Ma leggerò solo i primi 7 speedCharacteristic.readValue(holdvalues, 7); byte rawValue0 = holdvalues[0]; // flag binari 8 bit int byte rawValue1 = holdvalues[1]; // gira il byte meno significativo in HEX byte rawValue2 = holdvalues[2]; // gira il byte successivo più significativo in HEX byte rawValue3 = holdvalues[3]; // gira il byte successivo più significativo in HEX byte rawValue4 = holdvalues[4]; // gira il byte più significativo in HEX byte rawValue5 = holdvalues[5]; // tempo trascorso dall'ultimo evento ruota meno sig byte byte rawValue6 = holdvalues[6]; // tempo trascorso dall'ultimo evento della ruota più sig byte if (firstData) { // Ottieni le rivoluzioni cumulative della ruota come esadecimale little endian in loc 2, 3 e 4 (prima l'ottetto meno significativo) WheelRevs1 = (rawValue1 + (rawValue2 * 256) + (rawValue3 * 65536) + (rawValue4 * 16777216)); // Ottieni il tempo dall'ultimo evento ruota in 1024esimi di secondo Time_1 = (rawValue5 + (rawValue6 * 256)); firstData = falso; } else { // Ottieni il secondo set di dati lungo WheelRevsTemp = (rawValue1 + (rawValue2 * 256) + (rawValue3 * 65536) + (rawValue4 * 16777216)); long TimeTemp = (rawValue5 + (rawValue6 * 256)); if (WheelRevsTemp > WheelRevs1) { // assicurarsi che la bicicletta si muova WheelRevs2 = WheelRevsTemp; Tempo_2 = TempoTemp; firstData = vero;}

// Trova la differenza di distanza in cm e convertila in km float distanceTravelled = ((WheelRevs2 - WheelRevs1) * wheelCircCM);

float kmPercorso = distanzaPercorsa / 1000000;

// Trova il tempo in 1024esimi di secondo e converti in ore

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

// Trova la velocità kmh

speedKMH = (kmTravelled / timeHrs);

Lo sketch di Arduino è ospitato su GitHub (https://github.com/mockendon/opengradesim).

Fase 3: Hardware 1 l'attuatore lineare

L'asse passante sulla mia bici da strada con freno a disco specifica un axel da 19,2 mm per eliminare l'asse passante da 12 mm con 100 mm tra le forcelle.

Il tubo in alluminio 10swg da 3/4 di pollice si adatta perfettamente e un simpatico tipo chiamato Dave su ebay (https://www.ebay.co.uk/str/aluminiumonline) lo ha fornito e lo ha tagliato a misura per me per poche sterline.

L'attuatore ha una barra da 20 mm con un foro da 6 mm, quindi la parte stampata in 3D collega il tubo di alluminio a una barra in acciaio da 6 mm e poiché le forze sono di compressione del 90%, alcuni PLA / ABS sono all'altezza della sfida.

Se esegui una configurazione a rilascio rapido standard, qualcosa di simile (https://www.amazon.co.uk/Sharplace-Quick-Release-Conversion-Adapter/dp/B079DCY344) eviterebbe di dover riprogettare questo componente.

Lo stivale è progettato per adattarsi al blocco raiser fornito con il mio trainer Tacx, ma probabilmente si adatterebbe a molti raiser simili o puoi semplicemente modificare il file TinkerCad in base alle tue esigenze.

Passaggio 4: Hardware 2 - H-Bridge

Queste schede bridge L298N H, molto comuni online, hanno un regolatore 5V integrato che è ottimo per alimentare Arduino dall'alimentatore 12V richiesto per l'attuatore lineare. Sfortunatamente la scheda Arduino Nano IoT segnala 3.3V quindi la necessità di un convertitore di livello logico (o un optoisolatore poiché i segnali sono solo unidirezionali).

La custodia è progettata per accettare i connettori di alimentazione comunemente utilizzati nelle applicazioni di illuminazione a LED. Ho macellato un cavo di prolunga USB per rendere possibile collegare / scollegare facilmente l'unità principale Arduino e mentre ero sicuro di utilizzare le linee di alimentazione per l'alimentazione e le linee dati per la segnalazione a 3,3 V, consiglierei onestamente CONTRO questo come avrei odio qualcuno che frigga le proprie porte USB o periferiche collegandole per errore!

Passaggio 5: Hardware 3 l'elettronica di controllo (Arduino)

La custodia per Arduino OLED e convertitore di livello logico ha un supporto standard da 1/2 giro in stile Garmin sul retro per consentirne il montaggio sicuro sulla bici. Un supporto "anteriore" consentirà all'unità di essere inclinata verso l'alto o verso il basso fino a "azzerare" la posizione dell'accelerometro o una riga di codice solo per l'auto zero all'inizio sarebbe facile da aggiungere.

La custodia ha uno spazio per una tastiera a membrana: questa viene utilizzata per impostare il peso combinato del ciclista e della bici. Puoi semplicemente impostarlo in modo programmatico, specialmente se non condividi un trainer con nessuno.

Potrebbe essere utile implementare una modalità "manuale". Forse premendo entrambi i pulsanti si potrebbe avviare una modalità manuale e quindi i pulsanti potrebbero aumentare/diminuire l'inclinazione. Lo aggiungo alla lista delle cose da fare!

Il file STL del caso è, di nuovo, disponibile su Thingiverse (vedi la sezione forniture per il collegamento).

Lo sketch Arduino è ospitato su GitHub (https://github.com/mockendon/opengradesim).

Puoi stampare una piccola clip ordinata per il tuo bridge CABLE da qui

Passaggio 6: "I forcellini posteriori"

Molte persone hanno sollevato il problema dello sfregamento del forcellino posteriore mentre la bici si muove. Alcuni trainer hanno un asse che si muove (come il Kickr) ma molti no.

Attualmente la mia migliore soluzione per me è montare alcuni cuscinetti a scanalatura profonda 61800-2RS standard (circa £ 2 ciascuno) sugli adattatori a sgancio rapido e quindi montare i forcellini passanti su questi (vedi foto) con uno spiedino QR sovradimensionato

I cuscinetti necessitano di una rondella di spessore sottile, ad es. M12 16 mm 0,3 mm tra l'adattatore e il cuscinetto.

Si adattano perfettamente e ruotano con la bici e lo spiedo indipendentemente dal trainer.

Al momento questo cambia l'offset sul lato guida di un paio di mm, quindi dovrai reindicizzare

Sto progettando parti personalizzate (vedi piano pdf) da lavorare (sul tornio del mio futuro cognato quando ha un'ora per aiutare!). Questi non sono ancora stati testati!!! Ma la rettifica di 1 mm dalla superficie interna dell'adattatore QR lato guida di serie è una soluzione rapida senza strumenti speciali;)