Simulador de grau aberto (bicicleta) - OpenGradeSIM: 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:36

Introdução

Uma certa empresa americana de fitness bem conhecida (Wahoo) recentemente trouxe um grande auxiliar de treinamento interno que levanta e abaixa a frente da bicicleta no turbo trainer de acordo com a inclinação simulada da colina que o usuário está pilotando (a subida Kickr).

Parece incrível, mas infelizmente isso não está disponível para todos nós, pois você precisará de 1) um treinador Wahoo topo de linha e 2) £ 500 em dinheiro para torná-lo seu.

Quebrei uma clavícula (nunca coloquei um ciclista de estrada em uma mountain bike), então tive mais milhas no treinador e mais tempo para mexer e pensei que este poderia ser um projeto divertido.

A unidade comercial simula -5% a + 20% então eu queria chegar perto disso, mas com 10% do orçamento!

Ele foi projetado em torno do meu Tacx Neo, mas qualquer treinador que transmita seus dados de potência e velocidade via ANT + ou BLE pode funcionar (eu acho!).

Como a distância entre eixos da minha bicicleta de estrada mede exatamente 1000 mm, eu precisaria levantar os garfos em 200 mm para simular 20% (ver foto), então um atuador linear de 200 mm faria. É improvável que o peso da moto + piloto exceda 100kg e, uma vez que é distribuído entre os eixos e a maior parte está na parte traseira, o 750N levantará 75kg e deve ficar bem. Atuadores mais rápidos estão disponíveis por mais dinheiro, mas este me custou cerca de £ 20 e administra 10 mm / s. Atuadores com potenciômetros que podem ser usados como servos simples também são 2 a 3 vezes mais caros.

Suprimentos

Impressão 3D (PLA ou ABSetc) da parte do adaptador do eixo:

100 mm de estoque de tubo de alumínio 10 swg de 3/4 de polegada (para uma estrutura de eixo passante)

80 mm de estoque de barra de aço inoxidável de 6 mm

Impressão 3D (PLA ou ABSetc) da sapata para a parte do atuador linear:

Impressão 3D da capa do H-bridge

Impressão 3D da capa para Arduino (versão 1 com teclado) https://www.thingiverse.com/thing:3984911 (versão 2, conforme mostrado (https://www.thingiverse.com/thing:3995976)

Corte a laser um pedaço de acrílico transparente de 3 mm de 32 x 38 mm para evitar que você sue em toda a parte eletrônica (não era o ideal).

Alguns blocos de sangramento (adaptados para deixar as almofadas) para evitar que você acidentalmente empurre os pistões da pinça para fora dos freios a disco Shimano em seu entusiasmo

Atuador Linear 750N 200 mm de curso, por exemplo, Atuadores Mini Linear Al03 de

Ponte L298N H (como:

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

Teclado de membrana de 2 teclas, por exemplo, Módulo bidirecional do conversor de nível lógico IIC I2C 5V a 3,3V para Arduino, por exemplo, Fonte de alimentação 12V 3A DC - aquelas para iluminação LED funcionam muito bem!

NPE CABLE Ant + para ponte BLE

Clipe para impressão 3D para a ponte CABLE

Módulo de exibição de LCD OLED de 1,3 com interface IIC I2C 128x32 3,3 V

Etapa 1: Algumas Matemáticas

Precisamos calcular a inclinação que está sendo simulada. Eu esperava que o treinador anunciasse esses dados junto com a velocidade, potência, cadência, etc., no entanto, o treinador simplesmente define a resistência para manter a potência de acordo com o software do tablet, computador etc. sendo usado para controlá-la. Eu não tinha como capturar facilmente a 'nota simulada' do software, então eu teria que trabalhar de trás para frente …

As forças que atuam na bicicleta e no piloto são uma combinação de perdas resistivas e a potência necessária para subir a colina. O treinador relata velocidade e potência. Se pudermos encontrar as perdas resistivas em uma determinada velocidade, então a energia restante está sendo usada para subir a colina. A força de subida depende do peso da bicicleta e do piloto e da velocidade de subida e, portanto, podemos trabalhar de volta para a inclinação.

Primeiro, usei o incrível https://bikecalculator.com para encontrar alguns pontos de dados para perda de potência resistiva em velocidades típicas. Em seguida, transformei o domínio da velocidade para produzir uma relação linear e encontrei a linha de melhor ajuste. Tomando a equação da linha, podemos agora calcular a potência (W) a partir da resistência = (0,0102 * (Speedkmh ^ 2,8)) + 9,428.

Obtenha o poder da resistência do poder medido para dar poder de 'escalar'.

Conhecemos a velocidade de subida em km / he a convertemos em unidades SI de m / s (divida por 3,6).

A inclinação é encontrada em: Incline (%) = ((PowerClimbing / (PesoKg * g)) / Velocidade) * 100

onde aceleração de queda livre g = 9,8m / s / s ou 9,8 N / kg

Etapa 2: Obtenha alguns dados

O cálculo da inclinação requer velocidade e potência. Usei um Arduino Nano 33 IoT para me conectar ao treinador via BLE para receber isso. Fiquei muito preso inicialmente, pois a versão v.1.1.2 atual da biblioteca nativa ArduinoBLE para este módulo não lida com autenticação de nenhuma forma, o que significa que a maioria (?) Sensores BLE comerciais não irão emparelhar com ela.

A solução foi usar um cabo NPE ANT + para ponte BLE (https://npe-inc.com/cableinfo/) que mantém o BLE embutido do treinador livre para o aplicativo de treinamento se comunicar e não requer autenticação no BLE lado.

A característica de potência BLE é bastante direta, pois a potência em watts está contida no segundo e terceiro bytes dos dados transmitidos como um inteiro de 16 bits (little endian, isto é, o octeto menos significativo primeiro). Eu apliquei um filtro de média móvel para dar uma potência média de 3s - assim como meu computador de bicicleta mostra - pois isso é menos irregular.

if (powerCharacteristic.valueUpdated ()) {

// Defina uma matriz para o valor uint8_t holdpowervalues [6] = {0, 0, 0, 0, 0, 0}; // Lê o valor no array powerCharacteristic.readValue (holdpowervalues, 6); // A energia é retornada como watts na localização 2 e 3 (loc 0 e 1 são sinalizadores de 8 bits) byte rawpowerValue2 = holdpowervalues [2]; // power menos sig byte em HEX byte rawpowerValue3 = holdpowervalues [3]; // power mais sig byte em HEX long rawpowerTotal = (rawpowerValue2 + (rawpowerValue3 * 256)); // Use o filtro de média móvel para fornecer '3s de potência' powerTrainer = movingAadiseFilter_power.process (rawpowerTotal);

A característica de velocidade BLE (Cycling Speed and Cadence) é uma daquelas coisas que faz você se perguntar o que diabos o SIG estava fumando quando escreveu a especificação.

A característica retorna uma matriz de 16 bytes que não contém velocidade nem cadência. Em vez disso, você obtém as revoluções da roda e da manivela (totais) e o tempo desde os dados do último evento em 1.024 segundos. Então, mais matemática. Ah, e os bytes nem sempre estão presentes, portanto, há um byte de sinalizador no início. Ah, e os bytes são pequenos HEX endian, então você precisa ler para trás multiplicando o segundo byte por 256, o terceiro por 65536 etc. e, em seguida, adicioná-los. Para encontrar a velocidade, você precisa assumir uma circunferência padrão da roda de uma bicicleta para saber a distância….

if (speedCharacteristic.valueUpdated ()) {

// Este valor precisa de uma matriz de 16 bytes uint8_t holdvalues [16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Mas vou ler apenas os 7 primeiros speedCharacteristic.readValue (holdvalues, 7); byte rawValue0 = holdvalues [0]; // sinalizadores binários 8 bits int byte rawValue1 = holdvalues [1]; // revoluções byte menos significativo em HEX byte rawValue2 = holdvalues [2]; // revoluções próximo byte mais significativo em HEX byte rawValue3 = holdvalues [3]; // revoluções próximo byte mais significativo em HEX byte rawValue4 = holdvalues [4]; // rotações byte mais significativo em HEX byte rawValue5 = holdvalues [5]; // tempo desde o último evento de roda menos sig byte byte rawValue6 = holdvalues [6]; // tempo desde o último evento de roda byte mais sigiloso if (firstData) {// Obter rotações de roda cumulativas como little endian hex em loc 2, 3 e 4 (octeto menos significativo primeiro) WheelRevs1 = (rawValue1 + (rawValue2 * 256) + (rawValue3 * 65536) + (rawValue4 * 16777216)); // Obter o tempo desde o último evento de roda em 1024º de segundo Time_1 = (rawValue5 + (rawValue6 * 256)); firstData = false; } else {// Obtém o segundo conjunto de dados long WheelRevsTemp = (rawValue1 + (rawValue2 * 256) + (rawValue3 * 65536) + (rawValue4 * 16777216)); longo TimeTemp = (rawValue5 + (rawValue6 * 256)); if (WheelRevsTemp> WheelRevs1) {// certifique-se de que a bicicleta está se movendo WheelRevs2 = WheelRevsTemp; Time_2 = TimeTemp; firstData = true;}

// Encontre a diferença de distância em cm e converta para km float distanceTravelled = ((WheelRevs2 - WheelRevs1) * wheelCircCM);

float kmTravelled = distanceTravelled / 1000000;

// Encontre o tempo em 1.024 segundos e converta para horas

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

// Encontre a velocidade kmh

speedKMH = (kmTravelled / timeHrs);

O esboço do Arduino está hospedado no GitHub (https://github.com/mockendon/opengradesim).

Etapa 3: Hardware 1, o atuador linear

O eixo passante na minha bicicleta de estrada com freio a disco especifica um eixo de 19,2 mm para liberar o eixo passante de 12 mm com 100 mm entre os garfos.

O tubo de alumínio 10swg de 3/4 de polegada é um encaixe perfeito e um bom sujeito chamado Dave no ebay (https://www.ebay.co.uk/str/aluminiumonline) fornecido e corte no comprimento certo para mim por alguns quilos.

O atuador tem uma barra de 20 mm com um orifício de 6 mm, de modo que a parte impressa em 3D liga o tubo de alumínio a uma barra de aço de 6 mm e, como as forças são de 90% de compressão, alguns PLA / ABS estão à altura do desafio.

Se você executar uma configuração de liberação rápida padrão, algo como isto (https://www.amazon.co.uk/Sharplace-Quick-Release-Conversion-Adapter/dp/B079DCY344) evitaria ter que reprojetar este componente.

A bota é projetada para caber no bloco de raiser fornecido com meu treinador Tacx, mas provavelmente caberia em muitos raisers semelhantes ou você pode apenas editar o arquivo TinkerCad para atender às suas necessidades.

Etapa 4: Hardware 2 - o H-Bridge

Essas placas de ponte L298N H que são muito comuns online têm um regulador de 5 V integrado que é ótimo para alimentar o Arduino com a fonte de alimentação de 12 V necessária para o atuador linear. Infelizmente, a placa Arduino Nano IoT sinaliza 3,3 V, daí a necessidade de um conversor de nível lógico (ou um optoisolador, uma vez que os sinais são unidirecionais apenas).

A caixa é projetada para aceitar os conectores de energia comumente usados em aplicações de iluminação LED. Eu cortei um cabo de extensão USB para tornar possível conectar / desconectar a unidade principal do Arduino facilmente e enquanto eu estava certo de usar as linhas de energia para energia e as linhas de dados para a sinalização de 3,3 V, honestamente aconselharia CONTRA isso como eu odeio que alguém frite suas portas USB ou periféricos conectando-os por engano!

Etapa 5: Hardware 3 a Eletrônica de Controle (Arduino)

O case para o Arduino OLED e o conversor de nível lógico tem uma montagem tipo Garmin de 1/2 volta padrão na parte traseira para permitir que seja montado com segurança na bicicleta. Uma montagem 'frontal' permitirá que a unidade seja inclinada para cima ou para baixo para 'zero' a posição do acelerômetro ou uma linha de código apenas para zero automático no início seria fácil de adicionar.

A caixa tem um local para um teclado de membrana - usado para definir o peso combinado do ciclista e da bicicleta. Você pode apenas definir isso programaticamente, especialmente se você não compartilhar um treinador com ninguém.

Pode ser bom implementar um modo 'manual'. Talvez o pressionamento de ambos os botões possa iniciar um modo manual e, em seguida, os botões possam aumentar / diminuir a inclinação. Vou adicionar isso à lista de tarefas!

O arquivo STL do caso está, novamente, disponível no Thingiverse (consulte a seção de suprimentos para obter o link).

O esboço do Arduino está hospedado no GitHub (https://github.com/mockendon/opengradesim).

Você pode imprimir um pequeno clipe legal para sua ponte de CABO aqui

Etapa 6: 'As quedas traseiras'

Muitas pessoas levantaram a questão da fricção da queda traseira enquanto a bicicleta se move. Alguns treinadores têm um eixo que se move (como o Kickr), mas muitos não.

Atualmente, minha melhor solução para mim é montar alguns rolamentos rígidos de ranhura 61800-2RS padrão (cerca de £ 2 cada) nos adaptadores de liberação rápida e, em seguida, montar as saídas de eixo direto sobre eles (veja as fotos) com um espeto QR de tamanho grande

Os rolamentos precisam de uma arruela de calço fino, por exemplo, M12 16 mm 0,3 mm entre o adaptador e o rolamento.

Eles se encaixam perfeitamente e giram com a bicicleta e o espeto independentemente do treinador.

No momento, isso muda o deslocamento no lado da unidade em alguns mm, então você precisa reindexar

Estou projetando peças personalizadas (ver plano em pdf) para usinar (no torno do meu futuro cunhado quando ele tiver uma hora para ajudar!). Eles ainda não foram testados !!! Mas retificar 1 mm da superfície interna do adaptador QR do lado da unidade de estoque é uma solução rápida, sem ferramentas especiais;)