從沒有中斷引腳的傳感器讀取數據的最佳方法，並且在測量准備好之前需要一些時間

Question

我正在嘗試將壓力傳感器 (MS5803-14BA) 與我的板 (NUCLEO-STM32L073RZ) 連接起來。

根據數據表（第 3 頁），壓力傳感器需要幾毫秒才能准備好讀取測量值。 對於我的項目，我對轉換原始數據需要大約 10 毫秒的最高分辨率感興趣。

不幸的是，這個壓力傳感器沒有任何中斷引腳可以用來查看測量何時准備就緒，因此我暫時解決了在請求新數據后延遲的問題。

我不喜歡我當前的解決方案，因為在這 10 毫秒內我可以讓 mcu 處理其他事情（我的板上還有其他幾個傳感器），但是沒有任何中斷引腳，我不確定是什么解決這個問題的最好方法。

我想到了另一個解決方案：使用一個每隔 20 毫秒觸發一次並執行以下操作的計時器：

1.a Read the current value stored in the registers (discarding the first value)
1.b Ask for a new value

這樣，在下一次迭代中，我只需要讀取上一次迭代結束時請求的值。

我不喜歡的是我的測量結果總是 20 毫秒。 直到延遲保持 20 毫秒，它應該仍然可以，但是如果我需要降低速率，使用我的解決方案讀取的“年齡”會增加。

你對如何處理這個問題有任何其他想法嗎？

謝謝你。

注意：如果您需要查看我當前的實現，請告訴我。

Answer 1

這不是“如何讀取傳感器”的問題，而是“如何進行非阻塞協作多任務”的問題。 假設您運行的是裸機（沒有操作系統，例如 FreeRTOS），您有兩個不錯的選擇。

首先，數據表顯示您最多需要等待 9.04 毫秒，即 9040 us。

現在，這是您的協作式多任務處理選項：

1. 發送命令告訴設備進行 ADC 轉換（即：進行模擬測量），然后配置一個硬件定時器，在 9040 秒后准確地中斷您。 在您的 ISR 中，您可以設置一個標志來告訴您的主循環發送讀取命令來讀取結果，或者您可以直接在 ISR 內發送讀取命令。

2. 在主循環中使用基於非阻塞時間戳的協作多任務處理。 這可能需要一個基本的狀態機。 發送轉換命令，然后繼續做其他事情。 當您的時間戳表明它已經足夠長時，發送讀取命令以從傳感器讀取轉換結果。

上面的第 1 條是我處理時間緊迫任務的首選方法。 然而，這不是時間緊迫的，一點點抖動也不會產生任何影響，所以上面的數字 2 是我首選的通用裸機協作多任務處理方法，所以讓我們這樣做。

這是一個示例程序，用於演示基於時間戳的裸機協作多任務處理的原理，適用於您需要的特定情況：

1. 請求數據樣本（在外部傳感器中啟動 ADC 轉換）
2. 等待 9040 us 以完成轉換
3. 從外部傳感器讀取數據樣本（現在 ADC 轉換已完成）

代碼：

enum sensorState_t 
{
    SENSOR_START_CONVERSION,
    SENSOR_WAIT,
    SENSOR_GET_CONVERSION
}

int main(void)
{
    doSetupStuff();
    configureHardwareTimer(); // required for getMicros() to work

    while (1)
    {
        //
        // COOPERATIVE TASK #1
        // Read the under-water pressure sensor as fast as permitted by the datasheet
        //
        static sensorState_t sensorState = SENSOR_START_CONVERSION; // initialize state machine
        static uint32_t task1_tStart; // us; start time
        static uint32_t sensorVal; // the sensor value you are trying to obtain 
        static bool newSensorVal = false; // set to true whenever a new value arrives
        switch (sensorState)
        {
            case SENSOR_START_CONVERSION:
            {
                startConversion(); // send command to sensor to start ADC conversion
                task1_tStart = getMicros(); // get a microsecond time stamp
                sensorState = SENSOR_WAIT; // next state 
                break;
            }
            case SENSOR_WAIT:
            {
                const uint32_t DESIRED_WAIT_TIME = 9040; // us
                uint32_t tNow = getMicros();
                if (tNow - task1_tStart >= DESIRED_WAIT_TIME)
                {
                    sensorState = SENSOR_GET_CONVERSION; // next state
                }
                break;
            }
            case SENSOR_GET_CONVERSION:
            {
                sensorVal = readConvertedResult(); // send command to read value from the sensor
                newSensorVal = true;
                sensorState = SENSOR_START_CONVERSION; // next state 
                break;
            }
        }

        //
        // COOPERATIVE TASK #2
        // use the under-water pressure sensor data right when it comes in (this will be an event-based task
        // whose running frequency depends on the rate of new data coming in, for example)
        //
        if (newSensorVal == true)
        {
            newSensorVal = false; // reset this flag 

            // use the sensorVal data here now for whatever you need it for
        }


        //
        // COOPERATIVE TASK #3
        //


        //
        // COOPERATIVE TASK #4
        //


        // etc etc

    } // end of while (1)
} // end of main

對於另一個非常簡單的基於時間戳的多任務示例，請參閱Arduino 的“無延遲閃爍”示例。

一般基於時間戳的裸機協同多任務架構注意事項：

取決於你如何做這一切，最終，你基本上會得到這種類型的代碼布局，它只是以固定的時間間隔運行每個任務。 每個任務都應該是非阻塞的，以確保它不會與其他任務的運行間隔發生沖突。 裸機上的非阻塞意味着“不要使用浪費時鍾的延遲、忙循環或其他類型的輪詢、重復、計數或忙延遲！”。 （這與基於操作系統（OS-based）的系統上的“阻塞”相反，這意味着“將時鍾返回給調度程序，讓它在此任務“休眠”時運行另一個線程。”記住：裸機意味着沒有操作系統！）。 相反，如果某些東西還沒有准備好運行，只需通過狀態機保存您的狀態，退出此任務的代碼（這是“合作”部分，因為您的任務必須通過返回自願放棄處理器），然后讓另一個任務運行！

這是基本架構，展示了一種簡單的基於時間戳的方法，可以讓 3 個任務以獨立的固定頻率運行，而不依賴於任何中斷，並且抖動最小，這是由於我采用徹底和有條理的方法來檢查時間戳並更新每次運行時的開始時間。

1、 main()函數和主循環的定義：

int main(void)
{
    doSetupStuff();
    configureHardwareTimer();

    while (1)
    {
        doTask1();
        doTask2();
        doTask3();
    }
}

2、 doTask()函數的定義：

// Task 1: Let's run this one at 100 Hz (every 10ms)
void doTask1(void)
{
    const uint32_t DT_DESIRED_US = 10000; // 10000us = 10ms, or 100Hz run freq
    static uint32_t t_start_us = getMicros();
    uint32_t t_now_us = getMicros();
    uint32_t dt_us = t_now_us - t_start_us;

    // See if it's time to run this Task
    if (dt_us >= DT_DESIRED_US)
    {
        // 1. Add DT_DESIRED_US to t_start_us rather than setting t_start_us to t_now_us (which many 
        // people do) in order to ***avoid introducing artificial jitter into the timing!***
        t_start_us += DT_DESIRED_US;
        // 2. Handle edge case where it's already time to run again because just completing one of the main
        // "scheduler" loops in the main() function takes longer than DT_DESIRED_US; in other words, here
        // we are seeing that t_start_us is lagging too far behind (more than one DT_DESIRED_US time width
        // from t_now_us), so we are "fast-forwarding" t_start_us up to the point where it is exactly 
        // 1 DT_DESIRED_US time width back now, thereby causing this task to instantly run again the 
        // next time it is called (trying as hard as we can to run at the specified frequency) while 
        // at the same time protecting t_start_us from lagging farther and farther behind, as that would
        // eventually cause buggy and incorrect behavior when the (unsigned) timestamps start to roll over
        // back to zero.
        dt_us = t_now_us - t_start_us; // calculate new time delta with newly-updated t_start_us
        if (dt_us >= DT_DESIRED_US)
        {
            t_start_us = t_now_us - DT_DESIRED_US;
        }

        // PERFORM THIS TASK'S OPERATIONS HERE!

    }
}

// Task 2: Let's run this one at 1000 Hz (every 1ms)
void doTask2(void)
{
    const uint32_t DT_DESIRED_US = 1000; // 1000us = 1ms, or 1000Hz run freq
    static uint32_t t_start_us = getMicros();
    uint32_t t_now_us = getMicros();
    uint32_t dt_us = t_now_us - t_start_us;

    // See if it's time to run this Task
    if (dt_us >= DT_DESIRED_US)
    {
        t_start_us += DT_DESIRED_US;
        dt_us = t_now_us - t_start_us; // calculate new time delta with newly-updated t_start_us
        if (dt_us >= DT_DESIRED_US)
        {
            t_start_us = t_now_us - DT_DESIRED_US;
        }

        // PERFORM THIS TASK'S OPERATIONS HERE!

    }
}

// Task 3: Let's run this one at 10 Hz (every 100ms)
void doTask3(void)
{
    const uint32_t DT_DESIRED_US = 100000; // 100000us = 100ms, or 10Hz run freq
    static uint32_t t_start_us = getMicros();
    uint32_t t_now_us = getMicros();
    uint32_t dt_us = t_now_us - t_start_us;

    // See if it's time to run this Task
    if (dt_us >= DT_DESIRED_US)
    {
        t_start_us += DT_DESIRED_US;
        dt_us = t_now_us - t_start_us; // calculate new time delta with newly-updated t_start_us
        if (dt_us >= DT_DESIRED_US)
        {
            t_start_us = t_now_us - DT_DESIRED_US;
        }

        // PERFORM THIS TASK'S OPERATIONS HERE!

    }
}

上面的代碼運行良好，但正如您所見，它非常多余，並且設置新任務有點煩人。 通過簡單地定義一個宏CREATE_TASK_TIMER() ，這項工作可以更加自動化，並且更容易完成，如下所示，為我們完成所有冗余的計時內容和時間戳變量創建：

/// @brief      A function-like macro to get a certain set of events to run at a desired, fixed 
///             interval period or frequency.
/// @details    This is a timestamp-based time polling technique frequently used in bare-metal
///             programming as a basic means of achieving cooperative multi-tasking. Note 
///             that getting the timing details right is difficult, hence one reason this macro 
///             is so useful. The other reason is that this maro significantly reduces the number of
///             lines of code you need to write to introduce a new timestamp-based cooperative
///             task. The technique used herein achieves a perfect desired period (or freq) 
///             on average, as it centers the jitter inherent in any polling technique around 
///             the desired time delta set-point, rather than always lagging as many other 
///             approaches do.
///             
///             USAGE EX:
///             ```
///             // Create a task timer to run at 500 Hz (every 2000 us, or 2 ms; 1/0.002 sec = 500 Hz)
///             const uint32_t PERIOD_US = 2000; // 2000 us pd --> 500 Hz freq
///             bool time_to_run;
///             CREATE_TASK_TIMER(PERIOD_US, time_to_run);
///             if (time_to_run)
///             {
///                 run_task_2();
///             }
///             ```
///
///             Source: Gabriel Staples 
///             https://stackoverflow.com/questions/50028821/best-way-to-read-from-a-sensors-that-doesnt-have-interrupt-pin-and-require-some/50032992#50032992
/// @param[in]  dt_desired_us   The desired delta time period, in microseconds; note: pd = 1/freq;
///                             the type must be `uint32_t`
/// @param[out] time_to_run     A `bool` whose scope will enter *into* the brace-based scope block
///                             below; used as an *output* flag to the caller: this variable will 
///                             be set to true if it is time to run your code, according to the 
///                             timestamps, and will be set to false otherwise
/// @return     NA--this is not a true function
#define CREATE_TASK_TIMER(dt_desired_us, time_to_run)                                                                  \
{ /* Use scoping braces to allow multiple calls of this macro all in one outer scope while */                          \
  /* allowing each variable created below to be treated as unique to its own scope */                                  \
    time_to_run = false;                                                                                               \
                                                                                                                       \
    /* set the desired run pd / freq */                                                                                \
    const uint32_t DT_DESIRED_US = dt_desired_us;                                                                      \
    static uint32_t t_start_us = getMicros();                                                                          \
    uint32_t t_now_us = getMicros();                                                                                   \
    uint32_t dt_us = t_now_us - t_start_us;                                                                            \
                                                                                                                       \
    /* See if it's time to run this Task */                                                                            \
    if (dt_us >= DT_DESIRED_US)                                                                                        \
    {                                                                                                                  \
        /* 1. Add DT_DESIRED_US to t_start_us rather than setting t_start_us to t_now_us (which many */                \
        /* people do) in order to ***avoid introducing artificial jitter into the timing!*** */                        \
        t_start_us += DT_DESIRED_US;                                                                                   \
        /* 2. Handle edge case where it's already time to run again because just completing one of the main */         \
        /* "scheduler" loops in the main() function takes longer than DT_DESIRED_US; in other words, here */           \
        /* we are seeing that t_start_us is lagging too far behind (more than one DT_DESIRED_US time width */          \
        /* from t_now_us), so we are "fast-forwarding" t_start_us up to the point where it is exactly */               \
        /* 1 DT_DESIRED_US time width back now, thereby causing this task to instantly run again the */                \
        /* next time it is called (trying as hard as we can to run at the specified frequency) while */                \
        /* at the same time protecting t_start_us from lagging farther and farther behind, as that would */            \
        /* eventually cause buggy and incorrect behavior when the (unsigned) timestamps start to roll over */          \
        /* back to zero. */                                                                                            \
        dt_us = t_now_us - t_start_us; /* calculate new time delta with newly-updated t_start_us */                    \
        if (dt_us >= DT_DESIRED_US)                                                                                    \
        {                                                                                                              \
            t_start_us = t_now_us - DT_DESIRED_US;                                                                     \
        }                                                                                                              \
                                                                                                                       \
        time_to_run = true;                                                                                            \
    }                                                                                                                  \
}

現在，有多種方法可以使用它，但為了這個演示，為了保持真正干凈的main()循環代碼，如下所示：

int main(void)
{
    doSetupStuff();
    configureHardwareTimer();

    while (1)
    {
        doTask1();
        doTask2();
        doTask3();
    }
}

讓我們像這樣使用CREATE_TASK_TIMER()宏。 如您所見，代碼現在更清晰，更容易設置新任務。 這是我的首選方法，因為它創建了上面顯示的非常干凈的主循環，只有各種doTask()調用，這些調用也很容易編寫和維護：

// Task 1: Let's run this one at 100 Hz (every 10ms, or 10000us)
void doTask1(void)
{
    bool time_to_run;
    const uint32_t DT_DESIRED_US = 10000; // 10000us = 10ms, or 100Hz run freq
    CREATE_TASK_TIMER(DT_DESIRED_US, time_to_run);
    if (time_to_run)
    {
        // PERFORM THIS TASK'S OPERATIONS HERE!
    }
}

// Task 2: Let's run this one at 1000 Hz (every 1ms)
void doTask2(void)
{
    bool time_to_run;
    const uint32_t DT_DESIRED_US = 1000; // 1000us = 1ms, or 1000Hz run freq
    CREATE_TASK_TIMER(DT_DESIRED_US, time_to_run);
    if (time_to_run)
    {
        // PERFORM THIS TASK'S OPERATIONS HERE!
    }
}

// Task 3: Let's run this one at 10 Hz (every 100ms)
void doTask3(void)
{
    bool time_to_run;
    const uint32_t DT_DESIRED_US = 100000; // 100000us = 100ms, or 10Hz run freq
    CREATE_TASK_TIMER(DT_DESIRED_US, time_to_run);
    if (time_to_run)
    {
        // PERFORM THIS TASK'S OPERATIONS HERE!
    }
}

但是，或者，您可以更像這樣構建代碼，它同樣工作並產生相同的效果，只是方式略有不同：

#include <stdbool.h>
#include <stdint.h>

#define TASK1_PD_US (10000)     // 10ms pd, or 100 Hz run freq 
#define TASK2_PD_US (1000)      // 1ms pd, or 1000 Hz run freq 
#define TASK3_PD_US (100000)    // 100ms pd, or 10 Hz run freq 

// Task 1: Let's run this one at 100 Hz (every 10ms, or 10000us)
void doTask1(void)
{
    // PERFORM THIS TASK'S OPERATIONS HERE!
}

// Task 2: Let's run this one at 1000 Hz (every 1ms)
void doTask2(void)
{
    // PERFORM THIS TASK'S OPERATIONS HERE!
}

// Task 3: Let's run this one at 10 Hz (every 100ms)
void doTask3(void)
{
    // PERFORM THIS TASK'S OPERATIONS HERE!
}

int main(void)
{
    doSetupStuff();
    configureHardwareTimer();

    while (1)
    {
        bool time_to_run;

        CREATE_TASK_TIMER(TASK1_PD_US, time_to_run);
        if (time_to_run)
        {
            doTask1();
        }

        CREATE_TASK_TIMER(TASK2_PD_US, time_to_run);
        if (time_to_run)
        {
            doTask2();
        }

        CREATE_TASK_TIMER(TASK3_PD_US, time_to_run);
        if (time_to_run)
        {
            doTask3();
        }
    }
}

嵌入式裸機微控制器編程的藝術（和樂趣！）的一部分在於確定您希望如何交錯每個任務並使它們一起運行，就好像它們並行運行一樣所涉及的技巧和獨創性。 使用上述格式之一作為起點，並適應您的特定情況。 可以根據需要以及特定應用程序的需要在任務之間或任務與中斷、任務與用戶等之間添加消息傳遞。

以下是如何配置定時器以用作 STM32F2 微控制器上的時間戳生成器的示例。

這顯示了上面使用的configureHardwareTimer()和getMicros()函數：

// Timer handle to be used for Timer 2 below
TIM_HandleTypeDef TimHandle;

// Configure Timer 2 to be used as a free-running 32-bit hardware timer for general-purpose use as a 1-us-resolution
// timestamp source
void configureHardwareTimer()
{
    // Timer clock must be enabled before you can configure it
    __HAL_RCC_TIM2_CLK_ENABLE();

    // Calculate prescaler
    // Here are some references to show how this is done:
    // 1) "STM32Cube_FW_F2_V1.7.0/Projects/STM32F207ZG-Nucleo/Examples/TIM/TIM_OnePulse/Src/main.c" shows the
    //    following (slightly modified) equation on line 95: `Prescaler = (TIMxCLK/TIMx_counter_clock) - 1`
    // 2) "STM32F20x and STM32F21x Reference Manual" states the following on pg 419: "14.4.11 TIMx prescaler (TIMx_PSC)"
    //    "The counter clock frequency CK_CNT is equal to fCK_PSC / (PSC[15:0] + 1)"
    //    This means that TIMx_counter_clock_freq = TIMxCLK/(prescaler + 1). Now, solve for prescaler and you
    //    get the exact same equation as above: `prescaler = TIMxCLK/TIMx_counter_clock_freq - 1`
    // Calculating TIMxCLK:
    // - We must divide SystemCoreClock (returned by HAL_RCC_GetHCLKFreq()) by 2 because TIM2 uses clock APB1
    // as its clock source, and on my board this is configured to be 1/2 of the SystemCoreClock.
    // - Note: To know which clock source each peripheral and timer uses, you can look at
    //  "Table 25. Peripheral current consumption" in the datasheet, p86-88.
    const uint32_t DESIRED_TIMER_FREQ = 1e6; // 1 MHz clock freq --> 1 us pd per tick, which is what I want
    uint32_t Tim2Clk = HAL_RCC_GetHCLKFreq() / 2;
    uint32_t prescaler = Tim2Clk / DESIRED_TIMER_FREQ - 1; // Don't forget the minus 1!

    // Configure timer
    // TIM2 is a 32-bit timer; See datasheet "Table 4. Timer feature comparison", p30-31
    TimHandle.Instance               = TIM2;
    TimHandle.Init.Period            = 0xFFFFFFFF; // Set pd to max possible for a 32-bit timer
    TimHandle.Init.Prescaler         = prescaler;
    TimHandle.Init.ClockDivision     = TIM_CLOCKDIVISION_DIV1;
    TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
    TimHandle.Init.RepetitionCounter = 0; // NA (has no significance) for this timer

    // Initialize the timer
    if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
    {
        // handle error condition
    }

    // Start the timer
    if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
    {
        // handle error condition
    }
}

// Get the 1 us count value on Timer 2.
// This timer will be used for general purpose hardware timing that does NOT rely on interrupts.
// Therefore, the counter will continue to increment even with interrupts disabled.
// The count value increments every 1 microsecond.
// Since it is a 32-bit counter it overflows every 2^32 counts, which means the highest value it can
// store is 2^32 - 1 = 4294967295. Overflows occur every 2^32 counts / 1 count/us / 1e6us/sec
// = ~4294.97 sec = ~71.6 min.
uint32_t getMicros()
{
    return __HAL_TIM_GET_COUNTER(&TimHandle);
}

參考：

1. https://www.arduino.cc/en/tutorial/BlinkWithoutDelay
2. Doxygen： 在 Doxygen 中引用參數的正確方法是什么？
3. 用於錯誤處理的基於枚舉的錯誤代碼： C 代碼中的錯誤處理
4. C 中的其他架構風格，例如通過不透明指針的“基於對象的”C： 不透明的 C 結構：它們應該如何聲明？

Answer 2

首先感謝您的建議。 我試圖分析你提出的每一個可能的解決方案。

Peter 提出的解決方案看起來很有趣，但我不得不說，在多次瀏覽數據表后，我認為這是不可行的。 我的考慮是基於以下事實。

使用范圍我看到在發送進行轉換的命令后立即收到確認。 有關溫度轉換，請參見下圖：

命令之后的確認位對我來說似乎很清楚。 在那之后，SDA 線（黃色）變高，因此我看不出如何利用它來檢測轉換何時准備就緒。

關於使用 SPI 時的解決方案，是的，SDO 在轉換過程中保持低電平，但我無法使用它：我需要堅持使用 I2C。 此外，我在該 SPI 總線上連接了其他傳感器，我同意 Gabriel Staples 所說的。

經過我的考慮，我選擇了 Gabriel Staples 提出的解決方案（考慮到，為了讀取壓力值，我還需要讀取和轉換溫度）。

我當前的解決方案基於具有 6 個狀態的狀態機。 在我的解決方案中，我區分了壓力轉換的等待時間和溫度轉換的等待時間，我的想法是如果我使用不太精確的溫度讀數，我可以嘗試查看壓力讀數下降了多少。

這是我目前的解決方案。 下面的函數在 main while 中被調用：

void MS5803_update()
{
  static uint32_t tStart; // us; start time

  switch (sensor_state)
  {
    case MS5803_REQUEST_TEMPERATURE:
    {
        MS5803_send_command(MS5803_CMD_ADC_CONV + TEMPERATURE + baro.resolution);
        tStart = HAL_GetTick();
        sensor_state = MS5803_WAIT_RAW_TEMPERATURE;
        break;
    }

    case MS5803_WAIT_RAW_TEMPERATURE:
    {
        uint32_t tNow = HAL_GetTick();
        if (tNow - tStart >= conversion_time)
        {
            sensor_state = MS5803_CONVERTING_TEMPERATURE;
        }
        break;
    }

    case MS5803_CONVERTING_TEMPERATURE:
    {
        MS5803_send_command(MS5803_CMD_ADC_READ);
        uint8_t raw_value[3]; // Read 24 bit
        MS5803_read_value(raw_value,3);
        temperature_raw = ((uint32_t)raw_value[0] << 16) + ((uint32_t)raw_value[1] << 8) + raw_value[2];
        sensor_state = MS5803_REQUEST_PRESSURE;
        break;
    }

    case MS5803_REQUEST_PRESSURE:
    {
        MS5803_send_command(MS5803_CMD_ADC_CONV + PRESSURE + baro.resolution);
        tStart = HAL_GetTick();
        sensor_state = MS5803_WAIT_RAW_PRESSURE;
        break;
    }

    case MS5803_WAIT_RAW_PRESSURE:
    {
        uint32_t tNow = HAL_GetTick();
        if (tNow - tStart >= conversion_time)
        {
            sensor_state = MS5803_CONVERTING_PRESSURE;
        }
        break;
    }

    case MS5803_CONVERTING_PRESSURE:
    {
        MS5803_send_command(MS5803_CMD_ADC_READ);
        uint8_t raw_value[3]; // Read 24 bit
        MS5803_read_value(raw_value,3);
        pressure_raw = ((uint32_t)raw_value[0] << 16) + ((uint32_t)raw_value[1] << 8) + raw_value[2];

        // Now I have both temperature and pressure raw and I can convert them
        MS5803_updateMeasurements();

        // Reset the state machine to perform a new measurement
        sensor_state = MS5803_REQUEST_TEMPERATURE;
        break;
    }
  }
}

我不會假裝我的解決方案更好。 我只是為了得到大家的意見而發布它。 注意：我仍在努力。 因此我不能保證沒有錯誤！

對於 PeterJ_01：我同意嚴格來說這不是一個教學門戶，但我相信這里的每個人都會提出問題來學習新事物或提高自己。 因此，如果您認為使用 ack 的解決方案更好，那么如果您能向我們展示您的想法草稿，那就太好了。 對我來說，這將是學習的新東西。

任何進一步的評論表示贊賞。