基于.NET 4.0的串口响应等待TimerCallback实现技术问询

Hey there, let's work through this serial port communication challenge you're dealing with in your .NET 4.0 project. That huge range of response times—from 30ms all the way to 30 seconds—definitely makes a naive polling approach like your current TimerCallback messy. Let's break down better, more reliable solutions tailored to your scenario:

Polling every 500ms is inefficient, can miss partial responses, and doesn't play nice with such variable timeouts. Instead, use the SerialPort.DataReceived event paired with TaskCompletionSource to wait asynchronously for each command's response, with a configurable timeout.

Here's a simplified implementation:

private TaskCompletionSource<string> _currentResponseTcs;
private readonly SerialPort _serialPort;
private readonly StringBuilder _responseBuffer = new StringBuilder();
// Adjust this to match your device's response end marker (e.g., \r\n, a specific byte sequence)
private const string ResponseTerminator = "\r\n";

public SerialDeviceCommunicator(string portName, int baudRate)
{
    _serialPort = new SerialPort(portName, baudRate)
    {
        ReadTimeout = 500, // Short timeout for partial reads
        WriteTimeout = 1000
    };
    _serialPort.DataReceived += OnSerialDataReceived;
    _serialPort.Open();
}

private void OnSerialDataReceived(object sender, SerialDataReceivedEventArgs e)
{
    try
    {
        var incomingData = _serialPort.ReadExisting();
        _responseBuffer.Append(incomingData);

        // Check if we've received a complete response
        var terminatorIndex = _responseBuffer.ToString().IndexOf(ResponseTerminator, StringComparison.Ordinal);
        if (terminatorIndex != -1)
        {
            var fullResponse = _responseBuffer.ToString(0, terminatorIndex + ResponseTerminator.Length);
            _responseBuffer.Remove(0, terminatorIndex + ResponseTerminator.Length);

            // Validate the response before signaling completion
            if (IsResponseValid(fullResponse))
            {
                _currentResponseTcs?.TrySetResult(fullResponse);
            }
        }
    }
    catch (Exception ex)
    {
        _currentResponseTcs?.TrySetException(ex);
    }
}

public async Task<string> SendCommandAsync(string command, int maxTimeoutMs = 30000)
{
    // Reset the task completion source for the new command
    _currentResponseTcs = new TaskCompletionSource<string>();
    
    // Send the command to the device
    _serialPort.WriteLine(command);

    // Wait for either the response or the timeout
    var timeoutTask = Task.Delay(maxTimeoutMs);
    var completedTask = await Task.WhenAny(_currentResponseTcs.Task, timeoutTask);

    if (completedTask == timeoutTask)
    {
        _currentResponseTcs.TrySetCanceled();
        throw new TimeoutException($"No valid response received for command '{command}' within {maxTimeoutMs}ms");
    }

    return await _currentResponseTcs.Task;
}

// Implement your validation logic here
private bool IsResponseValid(string response)
{
    // Example: Check for a valid checksum, expected prefix, etc.
    return !string.IsNullOrWhiteSpace(response) && response.StartsWith("OK");
}

Since you need to send the next command only after validating the previous response, a thread-safe queue ensures commands are processed in order without race conditions:

private readonly Queue<string> _commandQueue = new Queue<string>();
private readonly SemaphoreSlim _queueLock = new SemaphoreSlim(1, 1);
private bool _isProcessingQueue;

public async Task EnqueueCommand(string command)
{
    await _queueLock.WaitAsync();
    try
    {
        _commandQueue.Enqueue(command);
        if (!_isProcessingQueue)
        {
            _isProcessingQueue = true;
            await ProcessCommandQueue();
        }
    }
    finally
    {
        _queueLock.Release();
    }
}

private async Task ProcessCommandQueue()
{
    while (true)
    {
        await _queueLock.WaitAsync();
        var hasCommand = _commandQueue.Count > 0;
        var currentCommand = hasCommand ? _commandQueue.Dequeue() : null;
        await _queueLock.Release();

        if (!hasCommand)
        {
            _isProcessingQueue = false;
            break;
        }

        try
        {
            var response = await SendCommandAsync(currentCommand);
            // Handle the valid response (log, update UI, etc.)
            Console.WriteLine($"Success: Command '{currentCommand}' -> Response: {response}");
        }
        catch (TimeoutException ex)
        {
            // Handle timeout (retry the command? Log and continue?)
            Console.WriteLine($"Failed: {ex.Message}");
            // Optional: Re-enqueue the command for retry
            // await EnqueueCommand(currentCommand);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error processing command '{currentCommand}': {ex.Message}");
        }
    }
}

If you're stuck with the timer approach for some reason, fix these common pitfalls:

• Thread Safety: Wrap all serial port access and response checking in a lock statement to avoid race conditions between the timer thread and the serial port thread.
• Track Command State: Don't just check for "any response"—track which command you're waiting for, so you don't accidentally process a leftover response from a previous command.
• Avoid Spam: Don't re-send the command every time the timer fires unless you've explicitly determined the previous attempt timed out.

内容的提问来源于stack exchange，提问作者jacksbta