从没有中断引脚的传感器读取数据的最佳方法，并且在测量准备好之前需要一些时间

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 的解决方案更好，那么如果您能向我们展示您的想法草稿，那就太好了。 对我来说，这将是学习的新东西。

任何进一步的评论表示赞赏。