DIY Indoor Bike Smart Trainer: 5 Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:10

Panimula

Ang proyektong ito ay nagsimula bilang isang simpleng pagbabago sa isang Schwinn IC Elite na panloob na bisikleta na gumagamit ng isang simpleng tornilyo at nadama mga pad para sa mga setting ng paglaban. Ang problemang nais kong malutas ay ang pitch ng turnilyo na malaki, kaya't ang saklaw mula sa hindi makapag-pedal sa gulong na umiikot na ganap na malaya ay isang pares lamang na degree sa tombol ng paglaban. Sa una ay binago ko ang tornilyo sa M6, ngunit pagkatapos ay kailangan kong gumawa ng isang hawakan ng pinto, kaya bakit hindi na lang gumamit ng kaliwa sa NEMA 17 stepper mottor upang baguhin ang paglaban? Kung mayroon nang ilang electronics, bakit hindi magdagdag ng isang crank power meter at isang koneksyon sa bluetooth sa isang computer upang makagawa ng isang matalinong tagapagsanay?

Pinatunayan nitong mas mahirap kaysa sa inaasahan, dahil walang mga halimbawa sa kung paano tularan ang isang metro ng kuryente na may isang arduino at bluetooth. Natapos ko ang paggastos sa paligid ng 20h sa pag-program at pagbibigay kahulugan sa mga pagtutukoy ng BLE GATT. Inaasahan kong sa pamamagitan ng pagbibigay ng isang halimbawa matutulungan ko ang isang tao na huwag sayangin ang labis na oras sa pagsubok na maunawaan kung ano ang eksaktong ibig sabihin ng "Data ng Uri ng AD ng Uri ng Serbisyo" …

Software

Ang buong proyekto ay nasa GitHub:

github.com/kswiorek/ble-ftms

Masidhing inirerekumenda ko ang paggamit ng Visual Studio na may isang plugin ng VisualGDB kung plano mong gumawa ng isang bagay na mas seryoso kaysa sa kopyahin lamang ang pag-paste ng aking code.

Kung mayroon kang mga katanungan tungkol sa programa, mangyaring magtanong, alam ko na ang aking mga minimalistic na komento ay maaaring hindi masyadong makatulong.

Mga Kredito

Salamat sa stoppi71 para sa kanyang gabay sa kung paano gumawa ng isang power meter. Ginawa ko ang crank ayon sa kanyang disenyo.

Mga Pantustos:

Ang mga materyales para sa proyektong ito ay lubos na nakasalalay sa anong bisikleta ang binabago mo, ngunit may ilang mga unibersal na bahagi.

Kakatuwang tao:

1. Module ng ESP32
2. HX711 Timbang sensor ADC
3. Mga gauge ng salaan
4. MPU - gyroscope
5. Isang maliit na baterya ng Li-Po (mga 750mAh)
6. Heat shrink manggas
7. A4988 Stepper driver
8. 5V regulator
9. Isang jack ng arduino barrel
10. 12V arduino power supply

Console:

1. NEMA 17 stepper (kailangang maging malakas,> 0.4Nm)
2. M6 tungkod
3. 12864 lcd
4. WeMos LOLIN32
5. Mga switch sa taktika

Kagamitan

Para sa paggawa nito marahil ay maaari kang makawala sa paggamit lamang ng isang 3D printer, subalit maaari kang makatipid ng maraming oras sa pamamagitan ng pagputol ng kaso ng laser, at maaari ka ring gumawa ng mga PCB. Ang DXF at mga gerber file ay nasa GitHub, kaya maaari mong i-order ang mga iyon nang lokal. Ang tagabitay mula sa sinulid na tungkod patungo sa motor ay nakabukas sa isang lathe at maaaring ito lamang ang problema, dahil ang bahagi ay kailangang maging malakas upang hilahin ang mga pad, ngunit walang maraming puwang sa partikular na bisikleta.

Mula nang gawin ang unang bisikleta, kumuha ako ng isang milling machine na nagbibigay-daan sa akin na gumawa ng mga puwang para sa mga sensor sa crank. Ginagawa nitong medyo madali ang pagdikit sa kanila at pinoprotektahan din ito kung may matamaan sa pihitan. (Ilang beses akong nahulog sa mga sensors na ito kaya nais kong maging ligtas.)

Hakbang 1: Ang Crank:

Mahusay na sundin lamang ang tutorial na ito:

Karaniwang kailangan mong idikit ang mga sensor sa crank sa apat na lugar at ikonekta ang mga iyon sa mga gilid ng board.

Ang mga tamang koneksyon ay naroon na kaya kailangan mo lang maghinang ng mga pares ng mga wire nang direkta sa walong pad na ito sa pisara.

Upang kumonekta sa mga sensor gamitin ang pinakamaliit na wire na posible - ang mga pad ay napakadaling iangat. Kailangan mong idikit muna ang mga sensor at iwanan ang sapat lamang sa kanila sa labas upang maghinang, pagkatapos ay takpan ang natitirang epoxy. Kung susubukan mong maghinang bago idikit, sila ay nakakulot at masisira.

Upang tipunin ang PCB:

1. Ipasok ang mga goldpins mula sa ilalim (sa gilid na may mga bakas) sa lahat ng mga butas maliban sa mga patayo na malapit sa ilalim.
2. Ilagay ang tatlong mga board (ESP32 sa itaas, pagkatapos ay ang MPU, ang HX711 sa ilalim) upang ang mga goldpins ay dumikit sa parehong mga butas.
3. Ihihinang ang mga header sa mga board sa itaas
4. Gupitin ang mga goldpins mula sa ibaba. (Subukang gupitin muna ang mga ito bago ang pagpupulong, upang malaman mo ang iyong "mga goldpins" ay hindi bakal sa loob - ginagawang imposible silang gupitin at kailangan mong i-file o gilingin ang mga ito)
5. solder ang natitirang mga goldpins sa ilalim ng board.
6. I-upload ang firmware para sa crank

Ang huling hakbang ay i-pack ang buong crank na may init na pag-urong ng manggas.

Ang pamamaraang ito ng paggawa ng board ay hindi perpekto, dahil ang mga board ay tumatagal ng maraming puwang kung saan maaari kang magkasya sa iba pang mga bagay. Ang pinakamahusay na maghinang ng direkta sa lahat ng mga bahagi sa board, ngunit kulang ako sa kasanayang maghinang sa maliit na SMD na ito mismo. Kakailanganin kong mag-order na ito ay tipunin, at marahil ay makakagawa ako ng ilang mga pagkakamali at magtatapos sa pag-order sa kanila ng tatlong beses at naghihintay sa isang taon bago sila dumating.

Kung ang isang tao ay maaaring mag-disenyo ng board, Magaling kung mayroon itong ilang proteksyon sa baterya na circutry at isang sensor na magpapasara sa ESP kung ang crank ay nagsimulang gumalaw.

MAHALAGA

Ang sensor ng HX711 bilang default ay nakatakda sa 10Hz - mas mabagal ito para sa pagsukat ng kuryente. Kailangan mong iangat ang pin 15 mula sa board at ikonekta ito sa pin 16. Itinutulak nito ang pin na TAAS at nagbibigay-daan sa 80Hz mode. Ang 80Hz na ito, itinatakda ang rate ng buong arduino loop.

Paggamit

Ang ESP32 ay na-program upang matulog makalipas ang 30s na walang koneksyon na bluetooth device. Upang ibalik ito, kailangan mong pindutin ang pindutan ng pag-reset. Ang mga sensor ay pinapagana din mula sa isang digital pin, na nagiging Mababang sa mode ng pagtulog. Kung nais mong subukan ang mga sensor na may halimbawang code mula sa mga aklatan kailangan mong himukin ang PIN na TAAS at maghintay nang kaunti bago mag-on ang mga sensor.

Pagkatapos ng pagpupulong ang mga sensor ay dapat na naka-calibrate sa pamamagitan ng pagbabasa ng halaga na walang lakas at pagkatapos ay may inilapat na timbang (Gumamit ako ng 12kg o 16kg kettlebell na nakasabit sa pedal). Ang mga halagang ito ay kailangang ilagay sa code ng powerCrank.

Mahusay na mapunit ang crank bago ang bawat pagsakay - hindi ito dapat makapagpahamak sa sarili kapag ang isang tao ay nagmamaneho, ngunit mas mahusay na ligtas kaysa sa paumanhin at posible na mapunit ito nang isang beses bawat pag-on. Kung napansin mo ang ilang mga kakaibang antas ng kuryente kailangan mong ulitin ang prosesong ito:

1. Ilagay ang crank diretso hanggang sa magsimula ang kislap.
2. Pagkatapos ng ilang segundo ang ilaw ay mananatili sa - huwag hawakan ito pagkatapos
3. Kapag pinatay ang ilaw itinatakda nito ang kasalukuyang puwersa na nakita bilang isang bagong 0.

Kung nais mong gamitin lamang ang crank, nang walang console, ang code ay narito sa github. Lahat ng iba pa gumagana nang pareho.

Hakbang 2: Ang Console

Ang kaso ay pinutol mula sa 3mm acrylic, ang mga pindutan ay naka-print sa 3D at may mga spacer para sa LCD, gupitin mula sa 5mm acrylic. Ito ay nakadikit ng mainit na pandikit (dumikit ito nang maayos sa acrylic) at mayroong naka-print na 3D na "bracket" upang hawakan ang PCB sa LCD. Ang mga pin para sa LCD ay solder mula sa ilalim na bahagi upang hindi ito makagambala sa ESP.

Ang ESP ay soldered na nakabaligtad, kaya't ang USB port ay umaangkop sa kaso

Ang magkakahiwalay na pindutan na PCB ay nakadikit ng mainit na pandikit, kaya ang mga pindutan ay nakunan sa kanilang mga butas, ngunit pinindot pa rin nila ang mga switch. Ang mga pindutan ay konektado sa board na may mga konektor ng JST PH 2.0 at ang pagkakasunud-sunod ng pin ay madaling maibawas mula sa eskematiko

Napakahalaga na mai-mount ang driver ng stepper sa tamang oryentasyon (ang potensyomiter na malapit sa ESP)

Ang buong bahagi para sa SD card ay hindi pinagana, dahil walang ginamit ito sa unang bersyon. Ang code ay kailangang i-update sa ilang mga setting ng UI tulad ng timbang ng rider at setting ng kahirapan.

Ang console ay naka-mount gamit ang lasercut "arm" at zipties. Ang maliliit na ngipin ay naghuhukay sa mga handlebar at hawak ang console.

Hakbang 3: Ang Motor

Pinipigilan ng motor ang sarili sa lugar ng adjustor knob na may naka-print na bracket na 3D. Sa baras nito ay naka-mount ang isang coupler - ang isang gilid ay may isang 5mm na butas na may mga itinakdang mga tornilyo upang hawakan ang baras, ang iba pa ay may isang M6 na thread na may mga itinakdang mga tornilyo upang i-lock ito. Kung nais mo, maaari mo itong gawin sa isang drill press mula sa ilang 10mm na stock na bilog. Hindi ito kailangang maging napaka tumpak dahil ang motor ay hindi masyadong naka-mount.

Ang isang piraso ng M6 na sinulid na tungkod ay naka-screw sa coupler at hinihila nito ang isang tanso na M6 nut. Na-machine ko ito, ngunit maaari itong madaling gawin mula sa isang piraso ng tanso na may isang file. Maaari mo ring magwelding ng ilang mga piraso sa isang normal na kulay ng nuwes, upang hindi ito paikutin. Ang isang naka-print na nut ng 3D ay maaari ding maging solusyon.

Ang thread ay kailangang mas pinong kaysa sa stock screw. Ang pitch nito ay tungkol sa 1.3mm, at para sa M6 ito ay 0.8mm. Ang motor ay walang sapat na metalikang kuwintas upang ibalik ang turnilyo ng stock.

Ang nut ay kailangang maayos na lubricated, dahil ang motor ay bahagya na maaaring i-on ang tornilyo sa mas mataas na mga setting

Hakbang 4: Pag-configure

Upang mag-upload ng code sa ESP32 mula sa Arduino IDE kailangan mong sundin ang tutorial na ito:

Ang board ay "WeMos LOLIN32", ngunit gumagana rin ang "Dev module"

Iminumungkahi ko ang paggamit ng Visual Studio, ngunit madalas itong masira.

Bago pa gamitin

Ang crank ay kailangang i-set up alinsunod sa hakbang na "Crank"

Gamit ang "nRF Connect" app kailangan mong suriin ang MAC address ng crank ESP32 at itakda ito sa BLE.h file.

Sa linya 19 ng panloob naBike.ino kailangan mong itakda, kung gaano karaming mga pag-ikot ng tornilyo ang kinakailangan upang maitakda ang paglaban mula sa ganap na maluwag sa maximum. (Ang "maximum" ay paksa ayon sa layunin, inaayos mo ang kahirapan sa setting na ito.)

Ang matalinong tagapagsanay ay mayroong "virtual gears" upang mai-set up ang mga ito nang tama, kailangan mong i-calibrate ito sa mga linya 28 at 29. Kailangan mong mag-pedal na may isang pare-pareho na cadence sa isang naibigay na setting ng paglaban, pagkatapos basahin ang lakas at itakda ito sa file. Ulitin muli ito sa isa pang setting.

Ang kaliwang pindutan sa kaliwa ay lilipat mula sa ERG mode (ganap na paglaban) sa mode ng simulation (virtual gears). Ang simulation mode na walang koneksyon sa computer ay walang ginagawa dahil walang data ng simulation.

Ang linya 36. ay nagtatakda ng mga virtual gears - ang bilang at mga ratio. Kalkulahin mo ang mga ito sa pamamagitan ng paghahati ng bilang ng mga ngipin sa front gear sa bilang ng mga ngipin sa likurang gear.

Sa linya 12. inilalagay mo ang bigat ng sumasakay at ang bisikleta (Sa [mga newton], pinaparami ng masa ang pagbilis ng gravitational!)

Ang buong bahagi ng pisika na ito ay marahil ay kumplikado at kahit na hindi ko matandaan kung ano ang eksaktong ginagawa nito, ngunit kinakalkula ko ang kinakailangang metalikang kuwintas upang hilahin ang siklista paakyat o isang bagay na tulad nito (kaya't ang pagkakalibrate).

Ang mga parameter na ito ay lubos na nasasaklaw, kailangan mong i-set up ang mga ito pagkatapos ng ilang mga pagsakay upang gumana nang tama.

Ang debug COM port ay nagpapadala ng direktang binary data na natanggap ng Bluetooth sa mga quote ( ) at data ng simulation.

Ang configurator

Dahil ang pagsasaayos ng sinasabing makatotohanang pisika ay naging isang malaking abala upang makaramdam ito ng makatotohanang, lumikha ako ng isang configurator ng GUI na dapat payagan ang mga gumagamit na tukuyin ang grapikong pagpapaandar na nagko-convert mula sa baitang ng burol hanggang sa ganap na antas ng paglaban. Hindi pa ito ganap na natatapos at wala akong pagkakataong subukan ito, ngunit sa darating na buwan ay magko-convert ako ng isa pang bisikleta, kaya't polish ko ito pagkatapos.

Sa tab na "Gears" maaari mong itakda ang ratio ng bawat gear sa pamamagitan ng paglipat ng mga slider. Kailangan mong kopyahin ang bit ng code upang mapalitan ang mga tinukoy na gears sa code.

Sa tab na "Grado" bibigyan ka ng isang graph ng isang linear function (oo, lumalabas na ang pinaka-kinamumuhian na paksa sa matematika ay talagang kapaki-pakinabang) na kumukuha ng marka (patayong axis) at naglalabas ng ganap na mga hakbang sa paglaban (pahalang na axis). Pupunta ako sa matematika ng kaunti kalaunan para sa mga interesado.

Maaaring tukuyin ng gumagamit ang pagpapaandar na ito gamit ang dalawang puntos na nakalagay dito. Sa kanan ay may isang lugar upang baguhin ang kasalukuyang gear. Ang napiling gear, tulad ng maaari mong isipin, ay binabago ang paraan, kung paano ang mga mapa ng grado hanggang sa paglaban - sa mas mababang mga gears mas madaling mag-pedal paakyat. Ang paglipat ng slider ay nagbabago sa ika-2 coefficient, na nakakaimpluwensya kung paano binago ng napiling gear ang pagpapaandar. Ito ay pinakamadaling upang i-play sa ito ng ilang sandali upang makita kung paano ito kumilos. Maaaring kailanganin mong subukan ang ilang iba't ibang mga setting upang makita kung ano ang pinakamahusay na gumagana para sa iyo.

Ito ay nakasulat sa Python 3 at dapat na gumana sa mga default na aklatan. Upang magamit ito kailangan mong i-uncomment kaagad ang mga linya pagkatapos ng "pag-aayuno ang mga linyang ito upang magamit ang configurator". Tulad ng sinabi ko, hindi ito nasubukan, kaya maaaring may ilang mga pagkakamali, ngunit kung may dumating, mangyaring sumulat ng isang komento o magbukas ng isang isyu, upang maitama ko ito.

Ang matematika (at pisika)

Ang tanging paraan lamang na maaaring iparamdam ng taga-kontrol na ikaw ay paakyat ay sa pamamagitan ng pag-on ng resistensya. Kailangan naming i-convert ang grado sa bilang ng mga pag-ikot. Upang gawing mas madaling i-set up, ang buong saklaw mula sa ganap na maluwag hanggang sa hindi ma-on ang crank ay nahahati sa 40 mga hakbang, ang parehong ginamit sa mode na ERG, ngunit sa oras na ito ay gumagamit ito ng mga totoong numero sa halip na mga integer. Ginagawa ito sa isang simpleng pagpapaandar sa mapa - maaari mo itong tingnan sa code. Ngayon kami ay isang hakbang na mas mataas - sa halip na makitungo sa mga rebolusyon ng tornilyo, nakikipag-usap kami sa mga haka-haka na hakbang.

Ngayon paano talaga ito gumagana kapag umakyat ka sa isang bisikleta (sa pag-aakalang pare-pareho ang bilis)? Malinaw na kailangang mayroong ilang puwersa na itulak ka pataas, o kung hindi ka ay gumulong. Ang puwersang ito, tulad ng sinasabi sa amin ng unang batas ng paggalaw, ay dapat na pantay ang laki ngunit kabaligtaran sa direksyon ng puwersa na hinihila ka pababa, upang ikaw ay magkatulad na galaw. Ito ay nagmula sa alitan sa pagitan ng gulong at lupa at kung iguhit mo ang diagram ng mga puwersang ito, kailangang pantay ang bigat ng bisikleta at ang sakay ulitin ang grado:

F = Fg * G

Ngayon kung ano ang nag-aplay ng gulong sa puwersang ito? Habang nakikipag-usap kami sa mga gears at gulong, mas madaling mag-isip sa mga tuntunin ng metalikang kuwintas, na kung saan ay ang puwersang beses na nag-radius:

t = F * R

Tulad ng mga kasangkot na gears, nagbabahagi ka ng isang metalikang kuwintas sa crank, na kumukuha sa kadena at pinaliliko ang gulong. Ang metalikang kuwintas na kinakailangan upang paikutin ang gulong ay maparami ng ratio ng gear:

tp = tw * gr

at pabalik mula sa formula ng metalikang kuwintas nakuha namin ang lakas na kinakailangan upang buksan ang pedal

Fp = tp / r

Ito ay isang bagay na masusukat natin gamit ang power meter sa crank. Tulad ng dinamikong alitan ay tuwid na nauugnay sa puwersa at dahil ang partikular na bisikleta na ito ay gumagamit ng mga bukal upang maibigay ang puwersang ito, ito ay linear sa paggalaw ng tornilyo.

Ang lakas ay lakas ng beses sa bilis (sa pag-aakala ng parehong direksyon ng mga vector)

P = F * V

at ang linear na tulin ng pedal ay nauugnay sa angular na tulin:

V = ω * r

at sa gayon maaari nating kalkulahin ang lakas na kinakailangan upang buksan ang mga pedal sa isang itinakdang antas ng paglaban. Tulad ng lahat ng bagay na may kaugnayan sa linear, maaari naming gamitin ang mga proporsyon upang gawin ito.

Mahalaga ito kung ano ang kailangan ng software upang makalkula sa pagkakalibrate at paggamit ng isang rotabout na paraan upang makuha sa amin ang isang kumplikadong pinaghalong, ngunit isang linear function na nauugnay sa grade sa paglaban. Sinulat ko ang lahat sa papel na kinakalkula ang pangwakas na equation at lahat ng mga pare-pareho ay naging tatlong mga coefficients.

Ito ay panteknikal na isang pagpapaandar ng 3D na kumakatawan sa isang eroplano (sa palagay ko) na kumukuha ng marka at ang ratio ng gear bilang mga argumento, at ang tatlong mga koepisyent na ito ay nauugnay sa mga kinakailangan upang tukuyin ang isang eroplano, ngunit dahil ang mga gears ay magkakaiba ang mga numero, mas madali ito upang gawin itong isang parameter sa halip na harapin ang mga pagpapakitang at iba pa. Ang ika-1 at ika-3 na mga koepisyent ay maaaring tukuyin sa pamamagitan ng isang solong linya at (-1) * ang ika-2 coefiffic ay ang X coordinate ng punto, kung saan ang linya ay "umiikot" sa paligid kapag binabago ang mga gears.

Sa visualization na ito ang mga argumento ay kinakatawan ng patayong linya at ang mga halaga ng pahalang, at alam ko na maaaring nakakainis ito, ngunit mas madaling maunawaan ito para sa akin at mas akma ito sa GUI. Marahil iyon ang dahilan kung bakit gumuhit ang mga ekonomista ng kanilang mga grap sa ganitong paraan.

Hakbang 5: Tapusin

Ngayon ay kailangan mo ng ilang mga app upang sumakay sa iyong bagong trainer (na naka-save sa iyo sa paligid ng $ 900:)). Narito ang aking mga opinyon sa ilan sa mga ito.

• RGT Cycling - sa aking palagay ang pinakamahusay - mayroon itong isang ganap na libreng pagpipilian, ngunit may kaunting mga track. Pinakamahusay ang pakikitungo sa bahagi ng koneksyon, dahil kumokonekta ang iyong telepono sa pamamagitan ng bluetooth at ipinapakita ng PC ang track. Gumagamit ng makatotohanang video kasama ang isang siklista ng AR
• Rouvy - maraming mga track, bayad na subscription lamang, sa ilang kadahilanan hindi gumagana ang PC app dito, kailangan mong gamitin ang iyong telepono. Maaaring may mga problema kapag ang iyong laptop ay gumagamit ng parehong card para sa bluetooth at WiFi, madalas itong napapagod at ayaw mag-load
• Ang Zwift - isang animated na laro, binabayaran lamang, gumagana nang mahusay sa trainer, ngunit ang UI ay medyo primitive - ang launcher ay gumagamit ng Internet Explorer upang ipakita ang menu.

Kung nasiyahan ka sa pagbuo (o hindi), mangyaring sabihin sa akin sa mga komento at kung mayroon kang anumang mga katanungan maaari kang magtanong dito o magsumite ng isang isyu sa github. Masaya kong ipaliwanag ang lahat dahil medyo kumplikado ito.