Handle CAN frames properly (#175)

Author: dfederm

src/ZWave.Serial/Logging.cs

@@ -101,4 +101,10 @@ internal static partial class Logging
         Level = LogLevel.Warning,
         Message = "Serial API frame transmission failed (attempt #{attempt})")]
     public static partial void LogSerialApiFrameTransmissionRetry(this ILogger logger, int attempt);
+
+    [LoggerMessage(
+        EventId = 117,
+        Level = LogLevel.Trace,
+        Message = "Received CAN during frame delivery; deferring retransmission until the chip's data frame is processed")]
+    public static partial void LogSerialApiCanDuringFrameDelivery(this ILogger logger);
 }

src/ZWave.Serial/ZWaveSerialPortCoordinator.cs

@@ -45,6 +45,12 @@ public sealed class ZWaveSerialPortCoordinator : IAsyncDisposable
 
     private TaskCompletionSource<bool>? _frameDeliveryResultTaskSource;
 
+    // Tracks whether a CAN was received during the current frame delivery attempt.
+    // Per spec 3.4.3, on CAN the chip drops our frame but has its own data frame to send.
+    // We defer signaling delivery failure until the chip's data frame is processed, giving
+    // the chip retransmission priority. The 1600ms ACK timeout acts as a fallback.
+    private bool _pendingCanDeliveryFailure;
+
     public ZWaveSerialPortCoordinator(
         ILogger logger,
         string portName,
@@ -137,7 +143,6 @@ private async Task ReadAsync()
                         {
                             case FrameType.ACK:
                             case FrameType.NAK:
-                            case FrameType.CAN:
                             {
                                 _logger.LogSerialApiFrameReceived(frame);
 
@@ -153,6 +158,27 @@ private async Task ReadAsync()
 
                                 break;
                             }
+                            case FrameType.CAN:
+                            {
+                                _logger.LogSerialApiFrameReceived(frame);
+
+                                if (_frameDeliveryResultTaskSource != null)
+                                {
+                                    // Spec 3.4.3 (Figure 3.9): CAN means the chip detected a collision
+                                    // and dropped our frame. The chip has priority to retransmit its own
+                                    // data frame. Defer signaling delivery failure until we process and
+                                    // ACK the chip's data frame, then the host can retransmit.
+                                    _pendingCanDeliveryFailure = true;
+                                    _logger.LogSerialApiCanDuringFrameDelivery();
+                                }
+                                else
+                                {
+                                    // We received a frame delivery notification unexpectedly. Just ignore.
+                                    _logger.LogSerialApiUnexpectedFrame(frame);
+                                }
+
+                                break;
+                            }
                             case FrameType.Data:
                             {
                                 DataFrame dataFrame = frame.ToDataFrame();
@@ -165,6 +191,15 @@ private async Task ReadAsync()
                                     SendFrame(Frame.ACK);
 
                                     await _dataFrameReceiveChannelWriter.WriteAsync(dataFrame, cancellationToken);
+
+                                    // Spec 3.4.3 (Figure 3.9): After a CAN, the chip retransmits its
+                                    // data frame. Now that we've processed and ACKed it, signal delivery
+                                    // failure so the host can retransmit with backoff.
+                                    if (_pendingCanDeliveryFailure && _frameDeliveryResultTaskSource != null)
+                                    {
+                                        _frameDeliveryResultTaskSource.SetResult(false);
+                                        _pendingCanDeliveryFailure = false;
+                                    }
                                 }
                                 else
                                 {
@@ -248,6 +283,7 @@ private async Task WriteAsync()
                     await Task.Delay(waitTimeMillis, cancellationToken);
                 }
 
+                _pendingCanDeliveryFailure = false;
                 _frameDeliveryResultTaskSource = new TaskCompletionSource<bool>();
 
                 // While writing frames, lock to ensure no frames are read and processed.
@@ -295,7 +331,7 @@ private async Task WriteAsync()
                     break;
                 }
 
-                // In the case of a NAK or CAN, retransmit our data frame.
+                // In the case of a NAK or timeout, retransmit our data frame.
                 _logger.LogSerialApiFrameTransmissionRetry(transmissionAttempt + 1);
             }