RT Critical Power
1.0.0
ฉันรู้สึกงงงวยกับสิ่งพิมพ์ที่อ้างว่า: เป็นไปได้ที่จะ วัด FTP ของคุณในหนึ่งนาที ใน Bikeradar Googling เพิ่มเติมเปิดเผยว่า Baronbiosys.com ได้พัฒนา XERT-APP ที่อ้างว่าสิ่งนี้:
วิธีการใช้เทคนิคที่ซับซ้อนและการจดจำรูปแบบเพื่อกำหนด FTP ของคุณ ในขณะที่ในอดีตคุณจำเป็นต้องทดสอบโดยใช้โปรโตคอล FTP 20 นาทีหรือตรวจสอบมูลค่าของข้อมูลหลายเดือนเพื่อให้ได้ค่า FTP ที่สมจริงวิธีนี้ช่วยให้คุณสามารถกำหนด FTP ของคุณในวันนั้นหรือแม้กระทั่งในขณะนั้น CF Baronbiosys
หลังจากติดตั้ง แอพ XERT บน Garmin ของฉัน (830) ฉันได้รับประสบการณ์จนกระทั่งใช้เวลาทดลองใช้ฟรีซึ่งจะทำการประเมิน FTP ได้ดีอย่างน่าทึ่ง Dcrainmaker ตรวจสอบแล้วและค่อนข้างดีเกี่ยวกับประสิทธิภาพและความแม่นยำและข้อสรุป:
ในขณะที่ที่นี่มันเป็นความจริงที่ว่าฉันได้รับข้อเสนอแนะ FTP แบบเรียลไทม์ที่ไม่เหมือนใคร ฉันสามารถออกไปนั่งและเริ่มเห็นค่าเหล่านี้กำหนดในขณะที่ฉันพยายามอย่างหนัก ไม่มีชั่วโมงรอหรือแม้แต่นาทีต่อมา ฉันไม่ทราบถึงแพลตฟอร์มหรือแอพอื่น ๆ ที่ทำเช่นนั้น cf dcrainmaker
ฉันตัดสินใจที่จะพัฒนารหัส C ++ สำหรับแอปพลิเคชันการฝึกอบรมในร่มที่ทำงานบนบอร์ด Express Arduino NRF52840 และที่ใกล้เคียงที่สุดกับฟังก์ชั่นของ แอพ XERT (สำหรับ Garmin Connect) มันกลายเป็นส่วนสำคัญของโครงการขนาดใหญ่: การไหลเวียนของอากาศ ต่อไปนี้เป็นคำอธิบายของวิทยาศาสตร์และคณิตศาสตร์ที่อยู่เบื้องหลังพื้นฐาน
เป็นที่ชัดเจนสำหรับฉันว่า แอป XERT นั้นขึ้นอยู่กับการลดลงของ ความสามารถในการทำงานแบบไม่ใช้ออกซิเจน ( AWC ) หรือ ความสามารถในการสำรอง ( FRC ) เพื่อให้ง่ายสมมติว่านักปั่นจักรยานมีจำนวนที่กำหนด ความสามารถในการทำงานที่ จำกัด (พลังงานสำรอง) เก็บไว้ภายในตอนเริ่มต้นของการนั่ง พลังงานจำนวนนี้เป็นที่รู้จักกันในแง่ทางคณิตศาสตร์ว่า W ' (ออกเสียง W Prime ) มันเป็นพลังงานและวัดในจูลส์ ในขณะที่คุณกำลังขี่ที่ความเข้มต่ำ W ' ยังคงอยู่ในระดับเต็มเนื่องจากไม่ได้ใช้จ่ายและคุณสามารถขี่ต่อไปได้อย่างเข้มข้นนี้เป็นเวลานาน แต่ถ้าคุณผลักดันให้หนักขึ้นคุณจะเริ่มใช้พลังงานนี้ ขีด จำกัด ที่คุณจะเริ่มใช้พลังงานสำรองนี้เรียกว่า Critical Power ( CP ) หากคุณกดคันเร่งหนักกว่า CP W ' จะลดลง ทันทีที่กำลังผลิต (วัตต์) ของคุณต่ำกว่า CP , W ' จะ“ งอกใหม่” และพลังงานสำรองจะเพิ่มขึ้นอีกครั้ง เมื่อคุณขี่นานพอที่จะอยู่ด้านล่าง CP W ' จะเข้าใกล้ระดับ 100% อีกครั้ง อย่างไรก็ตามเมื่อคุณทำงานหนักและนานพอที่จะอยู่เหนือ CP W ' จะหมดลงอย่างสมบูรณ์และคุณจะหมดแรงในขณะนี้ (aka t lim )! รูปแบบของ W ' แสดงเป็น " สมดุล W' " ในอัลกอริทึมของ Dr. Skiba (2) อีกพารามิเตอร์ของอัลกอริทึมคือ เอกภาพ ที่กำหนดความเร็วที่ w ' กำลังสร้างใหม่เมื่อพลังงานต่ำกว่า CP
CP ถูกกำหนดให้เป็นความเข้มของการออกกำลังกายสูงสุดที่สามารถรักษาได้เป็นระยะเวลานานโดยทั่วไปเป็นเวลา 45 ถึง 60 นาที การทำงานของเกณฑ์การทำงาน ( FTP ) เป็นที่รู้จักกันดีในการขี่จักรยานเพื่อการพักผ่อนหย่อนใจและได้รับการกำหนดให้เป็นกำลังไฟเฉลี่ยสูงสุดที่สามารถรักษาได้เป็นเวลา 60 นาที (1) ด้วยความคล้ายคลึงกันอย่างมากในคำจำกัดความเราถือว่าการขี่จักรยานที่ไม่ใช่ชนชั้นสูงไม่มีความแตกต่างอย่างมีนัยสำคัญระหว่างค่า CP และ FTP !
อัลกอริทึมที่ต้องดำเนินการคืออัลกอริทึมดร. Skiba ดั้งเดิม (2) และการเพิ่มประสิทธิภาพ (การประมาณ) ของอัลกอริทึม Skiba ที่สำคัญโดย Dave Waterworth (3) Aart Goossens เผยแพร่รหัส (ใน Python) และข้อมูลอธิบายเกี่ยวกับ GitHub (4) ที่ช่วยให้เข้าใจและใช้อัลกอริทึมที่แตกต่างกันในการตั้งค่า Arduino ข้อมูลต่อไปนี้ได้รับการถอดความจากงานต้นฉบับของเขาเพื่อให้ผู้อ่านมีความเข้าใจในพื้นหลังทางคณิตศาสตร์ของอัลกอริทึมดูงานของเขาที่: Aart goosens @ github
อัลกอริทึม Skiba ที่สำคัญเป็นอัลกอริทึมที่รู้จักกันดีที่สุดในการคำนวณ ยอดคงเหลือของ W และได้รับการตรวจสอบทางวิทยาศาสตร์ (5) สมการสำหรับอัลกอริทึมคือ: 
โดยที่ w ' bal (t) เท่ากับ w' bal ในเวลา t , w ' คือ ปริมาณของพลังงานที่ มี อยู่เหนือ CP (พลังงานวิกฤต), เวลาที่คำนวณ bal , u ตัววนซ้ำของการรวม, w' exp (u) จำนวน พลังงาน ที่ ใช้ในเวลาที่ คุณ ใช้ในเวลา ตัวเลข 546, -0.01 และ 316 ถูกกำหนดทดลองในบทความต้นฉบับของ Skiba และไม่เปลี่ยนแปลงระหว่างบุคคล D CP คือความแตกต่างระหว่าง CP และกำลังเฉลี่ยของช่วงเวลาที่พลังงานต่ำกว่า CP D CP สามารถคำนวณได้แบบไดนามิก (ค่าเฉลี่ยจนถึงเวลา t ) หรือคำนวณหนึ่งครั้งสำหรับการออกกำลังกายทั้งหมดและใช้เป็นค่าคงที่ Skiba แนะนำให้ใช้ค่าคงที่สำหรับ d cp - P (T) คือพลังงานที่ผลิตในเวลา t
นักคณิตศาสตร์ Dave Waterworth (3) ช่วยผู้พัฒนาหลักของ Golden Cheetah, Mark Liversedge เพื่อพัฒนาการเพิ่มประสิทธิภาพของอัลกอริทึม Skiba (6) การปฏิรูปนี้ใกล้เคียงกับอัลกอริทึม Skiba ดังนั้นผลลัพธ์อาจแตกต่างกันเล็กน้อยในกรณีที่รุนแรงเท่านั้นโดยเฉพาะอย่างยิ่งเมื่อ ( เอกภาพ ) มีขนาดเล็กมากเมื่อเทียบกับเวลาตัวอย่าง ส่วนหนึ่งของ W ' Bal Integral ของสมการของ Skiba ถูกเขียนใหม่โดย Waterworth ถึง: 
โดยที่ S (t) เป็นผลรวมที่วิ่งในเวลา t หลังจากเริ่มต้นสัญลักษณ์อื่น ๆ เป็นไปตามสมการก่อนหน้า Tau (ʈ w ' ) และ w' exp (t) คำนวณด้วยสมการดั้งเดิมที่นำเสนอโดย Skiba อัลกอริทึม Skiba ที่สำคัญค่อนข้างแพงในการคำนวณแม้ในคอมพิวเตอร์ที่รวดเร็วเนื่องจากการรวมจะต้องทำซ้ำทุกครั้งที่ T อีกครั้ง ข้อได้เปรียบที่ยิ่งใหญ่ของการเพิ่มประสิทธิภาพ Waterworth คือตอนนี้สามารถคำนวณ ความสมดุล ได้ตามเวลาจริง: ในระหว่างการนั่งและไม่เพียง แต่หลังจากนั้น! นอกจากนี้ยังมีประโยชน์มากเมื่อต้องการกำหนด พลังที่สำคัญ ในระหว่างการออกกำลังกาย HIIT หรือการออกกำลังกายที่มีพลังเมื่อ ยอดคงเหลือของ W กลายเป็นลบและหมดลง!
ในทางคณิตศาสตร์ความสัมพันธ์-ระยะเวลาการใช้พลังงานถูกอธิบายว่าเป็นฟังก์ชันไฮเพอร์โบลิก 4 จุดที่แตกต่างกันบนเส้นโค้งแสดงถึงจุดในเวลา ( t lim ) เมื่อถึงอำนาจสูงสุดที่สอดคล้องกันสูงสุดเหนือ CP ถึงและความอ่อนเพลียเกิดขึ้น เมื่อพิจารณาถึงความทนทานต่อการออกกำลังกาย Asymptote พลังงานเรียกว่า CP (วัตต์) ค่าคงที่ความโค้งเป็นที่รู้จักกันในชื่อ W ' (เช่น W Prime ) มันถูกวัดในหน่วยงานที่ทำ (จูล) ขอให้สังเกตว่าพื้นที่สีเทาทั้ง 4 ซึ่งเป็นตัวแทนของ W ' นั้นแตกต่างกันในรูปแบบ แต่มีขนาดเท่ากัน ความสัมพันธ์ระยะเวลาการใช้พลังงานไฮเพอร์โบลิกนี้สามารถเปลี่ยนเป็นความสัมพันธ์เชิงเส้นได้หากงานทำเสร็จสิ้นการพล็อตกับเวลาเช่นความชันของเส้นเท่ากับ CP และการสกัดกั้นเท่ากับ w ' ควรเน้นว่าความสัมพันธ์-ระยะเวลาอำนาจอธิบายถึงความทนทานต่อการออกกำลังกาย แต่ไม่ได้อธิบาย อย่างไรก็ตามการตอบสนองทางสรีรวิทยาต่อการออกกำลังกายที่ดำเนินการด้านล่างและสูงกว่า CP อาจให้ข้อมูลเชิงลึกที่สำคัญเกี่ยวกับกระบวนการเหนื่อยล้า เดิม CP ถูกกำหนดให้เป็นกำลังไฟภายนอกที่สามารถยั่งยืน“ ไม่มีกำหนด” หรือเป็นเวลานานมากโดยไม่มีความเหนื่อยล้า คำจำกัดความนี้ควรได้รับการพิจารณาทางทฤษฎีอย่างไรก็ตามเนื่องจากไม่มีการออกกำลังกายใด ๆ ที่สามารถดำเนินการได้อย่างไม่มีกำหนด ตอนนี้เป็นที่เข้าใจกันว่า CP แยกเอาต์พุตพลังงานซึ่งความทนทานต่อการออกกำลังกายนั้นมีข้อ จำกัด อย่างคาดเดาได้ (พลังการออกกำลังกาย> CP ) เวลาที่เกิดขึ้นจริงในการแพ้ ( t lim ) สำหรับการออกกำลังกายที่ดำเนินการข้างต้น CP ถูกกำหนดไว้ดังนั้นจึงคาดการณ์อย่างใกล้ชิดโดยสมการ:
t lim = w ′/(p-cp)
สมการนี้เน้นว่าเวลาในการแพ้เหนือ CP เป็นฟังก์ชั่นของความใกล้ชิดของกำลังไฟ ( P ) ที่ยั่งยืนกับ CP และขนาดของ W ' เมื่อ P สูงกว่า CP อย่างมากปริมาณงานคงที่ที่แสดงโดยพารามิเตอร์ W ' จะถูกใช้อย่างรวดเร็วและ T lim จะสั้น ควร อยู่ ใกล้กับ CP แล้ว w ' จะ' ใช้ 'ช้ากว่าและ t lim จะนานกว่า การพิจารณาที่สำคัญที่นี่คือ W ' ถือว่าเป็นค่าคงที่สำหรับ P ทั้งหมดข้างต้น CP โมเดล ' พารามิเตอร์สองพารามิเตอร์ ' นี้จึงหมายความว่าประสิทธิภาพการออกกำลังกายแบบสัมบูรณ์นั้นขึ้นอยู่กับค่าของ CP (ในวัตต์) และค่าของ W ' (ในจูล) พารามิเตอร์ทั้ง CP และ W ' อาจแตกต่างกันอย่างมากในหมู่บุคคลในฐานะหน้าที่ของสุขภาพ/โรคอายุการออกกำลังกายและการฝึกอบรม
// ------------ W' Balance calculation -------------------
// Global variables related to Cycling Power and W-Prime
uint16_t TAWC_Mode = 1 ; // Track Anaerobic Capacity Depletion Mode == TRUE -> APPLY and SHOW
uint16_t CP60 = 160 ; // Your (estimate of) Critical Power, more or less the same as FTP
uint16_t eCP = CP60; // Algorithmic estimate of Critical Power during intense workout
uint16_t w_prime_usr = 7500 ; // Your (estimate of) W-prime or a base value
uint16_t ew_prime_mod = w_prime_usr; // First order estimate of W-prime modified during intense workout
uint16_t ew_prime_test = w_prime_usr; // 20-min-test algorithmic estimate (20 minute @ 5% above eCP) of W-prime for a given eCP!
long int w_prime_balance = 0 ; // Can be negative !!!
bool IsShowWprimeValuesDominant = false ; // Boolean that determines to show W Prime data on Oled or not
// ------------------------------------------------------- // ------------------------ W'Balance Functions -----------------------------------
uint16_t CalculateAveragePowerBelowCP ( uint16_t iPower, uint16_t iCP);
void CalculateAveragePowerAboveCP ( uint16_t iPower, uint16_t &iavPwr, unsigned long &iCpACp);
double tau_w_prime_balance ( uint16_t iPower, uint16_t iCP);
void w_prime_balance_waterworth ( uint16_t iPower, uint16_t iCP, uint16_t iw_prime);
void ConstrainW_PrimeValue ( uint16_t &iCP, uint16_t &iw_prime);
uint16_t GetCPfromTwoParameterAlgorithm ( uint16_t iav_Power, unsigned long iT_lim, uint16_t iw_prime);
uint16_t GetWPrimefromTwoParameterAlgorithm ( uint16_t iav_Power, double iT_lim, uint16_t iCP);
// ------------------------ W'Balance Functions ------------------------------------ uint16_t CalculateAveragePowerBelowCP ( uint16_t iPower, uint16_t iCP){
// calculate avg_power_below_cp real time using a running sum and counter
static unsigned long int CountPowerBelowCP = 0 ;
static unsigned long int SumPowerBelowCP = 0 ;
if (iPower < iCP) {
SumPowerBelowCP += ( unsigned long int )iPower;
CountPowerBelowCP++;
}
return uint16_t (SumPowerBelowCP/CountPowerBelowCP); // average power below CP
} // end calculate avg_power_below_cp
void CalculateAveragePowerAboveCP ( uint16_t iPower, uint16_t &iavPwr, unsigned long int &iCpACp){
// calculate avg_power_above_cp real time using a running sum and counter
// returning the values by C++ reference!
static unsigned long int SumPowerAboveCP = 0 ;
SumPowerAboveCP += ( unsigned long int )iPower;
iCpACp++;
iavPwr = uint16_t (SumPowerAboveCP/iCpACp); // average power above CP
} // end calculate avg_power_above_cp
double tau_w_prime_balance ( uint16_t iPower, uint16_t iCP){
uint16_t avg_power_below_cp = CalculateAveragePowerBelowCP (iPower, iCP);
double delta_cp = double (iCP - avg_power_below_cp);
return ( double ( 546.00 ) * exp (- 0.01 * delta_cp) + double ( 316.00 ));
} // end Tau W Prime Balance
void w_prime_balance_waterworth ( uint16_t iPower, uint16_t iCP, uint16_t iw_prime) {
// Most power meters measure power, torque a.o. in a high frequency (20-60 Hz) but
// transmit (BLE) datasets to a monitoring device in much lower frequency: 1-4 times per second.
int power_above_cp = 0 ; // Power > CP
static double T_lim = 0 ; // Time (duration) while Power is above CP, the summed value of every sample time value P > CP
double w_prime_expended = 0.0 ; // Expended energy in Joules
double ExpTerm1 = 0.0 , ExpTerm2 = 0.0 ;
static double TimeSpent = 0.0 ; // Total Time spent in the workout, the summed value of every sample time value
static double running_sum = 0.0 ;
static unsigned long int CountPowerAboveCP = 0 ; // Count the Power readings above CP
static uint16_t avPower = 0 ; // Average power above CP
const long int NextLevelStep = 1000 ; // Stepsize of the next level of w-prime modification --> 1000 Joules step
static long int NextUpdateLevel = 0 ; // The next level at which to update eCP, e_w_prime_mod and ew_prime_test
// Quarq Dfour Zero Spider power meter sends between 2 and 1.2 power readings per second, dependent of POWER level !!!
// We assume that the sample frequency (number of samples per second) is VARIABLE !!!
// Determine the individual sample time in seconds, it may/will vary during the workout !!!
static unsigned long PrevReadingTime = 0 ;
double SampleTime = double ( millis ()-PrevReadingTime)/ 1000 ; // Time or duration since the previous sample, convert from millis to seconds
PrevReadingTime = millis (); // Update for the next sample
double tau = tau_w_prime_balance (iPower, iCP); // Determine the value for tau
TimeSpent += SampleTime ; // The summed value of all sample time values during the workout
power_above_cp = (iPower - iCP);
# ifdef DEBUGAIR
Serial. printf ( " Time:%6.1f ST: %4.2f tau: %f " , TimeSpent, SampleTime , tau);
# endif
// w_prime is energy and measured in Joules = Watt*second
// Determine the expended energy above CP since the previous measurement (--> i.e. during sample time)
w_prime_expended = double ( max ( 0 , power_above_cp))*SampleTime; // Determine (Watts_above_CP) * (its duration in seconds) = expended energy in Joules!
// Calculate some terms of the equation
ExpTerm1 = exp (TimeSpent/tau); // Exponential term1
ExpTerm2 = exp (-TimeSpent/tau); // Exponential term2
# ifdef DEBUGAIR
Serial. printf ( " W prime expended: %3.0f exp-term1: %f exp-term2: %f " , w_prime_expended , ExpTerm1, ExpTerm2);
# endif
running_sum = running_sum + (w_prime_expended*ExpTerm1); // Determine the running sum
# ifdef DEBUGAIR
Serial. printf ( " Running Sum: %f " , running_sum);
# endif
w_prime_balance = ( long int )( ( double )iw_prime - (running_sum*ExpTerm2) ) ; // Determine w prime balance and cast from double to int
# ifdef DEBUGAIR
Serial. printf ( " w_prime_balance: %d " , w_prime_balance);
# endif
// --------------- extra --------------------------------------------------------------------------------------
// Workout starts at a certain W'= ##,### Joules and CP = ### watts, set by the user; the algorithm increases CP and W' stepwise
// to more realistic values every time when W'balance is depleted to a certain level; -> 2-Parameter Algorithm updates CP and W'
if (power_above_cp > 0 ) {
CalculateAveragePowerAboveCP (iPower, avPower, CountPowerAboveCP); // Average power above CP is to be calculated for future use
T_lim += SampleTime ; // Time to exhaustion: the accurate sum of every second spent above CP, calculated for future use
}
# ifdef DEBUGAIR
Serial. printf ( " [%d] n " , CountPowerAboveCP);
# endif
// When working above CP, the moment comes that we need to update eCP and ew_prime !!
if ( (w_prime_balance < NextUpdateLevel) && (w_prime_expended > 0 ) ) { // W' balance is further depleted --> test for an update moment
NextUpdateLevel -= NextLevelStep; // Move down another level of depletion, update eCP, ew_prime_mod and ew_prime_test
eCP = GetCPfromTwoParameterAlgorithm (avPower, T_lim, iw_prime); // Estimate a new eCP value
ew_prime_mod = w_prime_usr - NextUpdateLevel; // Adjust ew_prime_modified to the next level of depletion to be checked
ew_prime_test = GetWPrimefromTwoParameterAlgorithm ( uint16_t (eCP* 1.045 ), double ( 1200 ), eCP); // 20-Min-test estimate for W-Prime
# ifdef DEBUGAIR
Serial. printf ( " Update of eCP - ew_prime %5d - avPower: %3d - T-lim:%6.1f --> eCP: %3d " , ew_prime_mod, avPower, T_lim, eCP);
Serial. printf ( " --> Test estimate of W-Prime: %d n " , ew_prime_test );
# endif
}
// -----------------extra -------------------------------------------------------------------------------
} // end
// Check and Set starting value of w_prime to realistic numbers!!
void ConstrainW_PrimeValue ( uint16_t &iCP, uint16_t &iw_prime) {
if (iCP < 100 ) { iCP = 100 ; } // Update to lowest level that we allow for
// First determine the "minimal" value for W_Prime according to a 20-min-test estimate, given the iCP value!
uint16_t w_prime_estimate = GetWPrimefromTwoParameterAlgorithm ( uint16_t (iCP* 1.045 ), double ( 1200 ), iCP);
if (iw_prime < w_prime_estimate) { iw_prime = w_prime_estimate; } // Update iw_prime to a realistic level
return ;
} // end
uint16_t GetCPfromTwoParameterAlgorithm ( uint16_t iav_Power, double iT_lim, uint16_t iw_prime) {
uint16_t WprimeDivTlim = uint16_t ( double (iw_prime)/iT_lim ); // type cast for correct calculations
if (iav_Power > WprimeDivTlim){ // test for out of scope
return (iav_Power - WprimeDivTlim); // Solve 2-parameter algorithm to estimate CP
} else {
return eCP; // Something went wrong do'nt allow an update of CP
}
} // end
uint16_t GetWPrimefromTwoParameterAlgorithm ( uint16_t iav_Power, double iT_lim, uint16_t iCP) {
if (iav_Power > iCP){ // test for out of scope
return (iav_Power-iCP)*(( uint16_t )iT_lim); // Solve 2-parameter algorithm to estimate new W-Prime
} else {
return w_prime_usr; // Something went wrong don't allow an update of w_prime
}
} // end
รหัสได้ถูกรวมเข้ากับโครงการขนาดใหญ่ที่เรียกว่า AirFlow การตั้งค่าหรือการเปลี่ยนฐาน CP และ W Prime ของคุณเป็นส่วนสำคัญของแอพ Airflow Companion! อุปกรณ์สมาร์ท การไหลของอากาศ จะปรับแต่งความเร็วอากาศที่ร้องขออย่างต่อเนื่องของพัดลมระบายความร้อนเพื่อความสมดุลความร้อนที่เสถียรในทุกขั้นตอนของการออกกำลังกายปั่นจักรยานในร่มอุ่นเครื่องช่วงความเข้มการฟื้นตัวเป็นระยะ ๆ และที่คูลดาวน์ นักปั่นจักรยานไม่มีสัญญาณรบกวนทางเวย์และสามารถมีสมาธิกับความต้องการของการออกกำลังกายเทรนเนอร์เครื่องเขียนได้อย่างเต็มที่หันหน้าเข้าหากระแสลมในอุดมคติที่จะทำให้เขาเย็นลงอย่างเหมาะสม นอกจากนี้นักปั่นจักรยานจะได้รับข้อมูลเชิงลึก (เป็นโบนัส) ในการพัฒนา พลังที่สำคัญ ของเขา/เธอเมื่อความเข้มการฝึกอบรมนั้นรุนแรงและยาวพอ! CPU Express Express Arduino NRF52480 ที่ใช้นั้นมีประสิทธิภาพมากจนการคำนวณแบบเรียลไทม์ของ CP และ W Prime สามารถทำได้โดยการคำนวณทั้งหมดสำหรับการกำหนดเงื่อนไขสมดุลความร้อนและการตั้งค่าแฟน ๆ ให้เหมาะสมกับความสามารถในการเป่าที่เหมาะสม
นักปั่นจักรยาน (คุณสมบัติ: CP = 140 วัตต์ และ W Prime = 7.2 kJ ) กำลังออกกำลังกายอย่างเข้มข้นด้วยระยะเวลาและความเข้มดังที่แสดงในรูป W Prime หมดไปหลายครั้งในช่วงช่วงเวลาแรก ค่าใหม่สำหรับ CP และ W Prime จะถูกประเมินโดยอัลกอริทึมในช่วงเวลาออกกำลังกายเฉพาะเมื่อเหมาะสม เรียกใช้วิดีโอเพื่อดูการลดลง 100% ของ W Prime และค่าโดยประมาณที่คำนวณใน เวลาจริง และนำเสนอบนหน้าจอ OLED ... สังเกตว่าแถบแนวนอนหดตัวอย่างไรเมื่อพลังงานสูงกว่า CP ที่ 175 และ 195 วัตต์ แถบนั้นเป็นสัดส่วนกับ ยอดคงเหลือของ W และนอกจากนี้สิ่งที่ "เหลืออยู่ในถัง" จะแสดงเป็นเปอร์เซ็นต์! การอ่านจะแสดงในลำดับการเร่งความเร็วและไม่สอดคล้องระยะเวลาที่ระบุระยะเวลาของการออกกำลังกาย! 
