Add Gravograph IS post processor

OpenNest.Posts.GravographIS/GravographISPort.cs

@@ -0,0 +1,99 @@
+using System;
+using System.IO.Ports;
+using System.Threading;
+
+namespace OpenNest.Posts.GravographIS
+{
+    /// <summary>
+    /// Serial streamer for the Gravograph IS8000. 9600 8-N-1; flow control is
+    /// configurable and defaults to RTS/CTS (the controller is buffered and drops
+    /// CTS to apply backpressure). The job is sent in modest chunks rather than as
+    /// one giant write so the handshake can pause the write mid-stream.
+    /// </summary>
+    public sealed class GravographISPort : IDisposable
+    {
+        private SerialPort port;
+
+        public const int DefaultBaudRate = 9600;
+        public const int DefaultChunkSize = 256;
+        public const int DefaultWriteTimeoutMs = 30000;
+
+        public int ChunkSize { get; set; } = DefaultChunkSize;
+        public int WriteTimeoutMs { get; set; } = DefaultWriteTimeoutMs;
+
+        public bool IsOpen => port != null && port.IsOpen;
+
+        /// <summary>
+        /// Opens the port at the controller's required line settings (9600 8-N-1)
+        /// with the given <paramref name="handshake"/>. Throws if the port is
+        /// already open or if opening fails.
+        /// </summary>
+        public void Open(string portName, Handshake handshake = Handshake.RequestToSend)
+        {
+            if (string.IsNullOrWhiteSpace(portName))
+                throw new ArgumentException("Port name is required.", nameof(portName));
+            if (port != null)
+                throw new InvalidOperationException("Port is already open.");
+
+            port = new SerialPort(portName, DefaultBaudRate, Parity.None, 8, StopBits.One)
+            {
+                Handshake = handshake,
+                WriteTimeout = WriteTimeoutMs,
+                ReadTimeout = WriteTimeoutMs,
+                // DTR/RTS are needed for some USB-serial bridges and for RTS/CTS flow:
+                DtrEnable = true,
+                RtsEnable = handshake != Handshake.RequestToSend &&
+                            handshake != Handshake.RequestToSendXOnXOff,
+            };
+
+            port.Open();
+        }
+
+        /// <summary>
+        /// Streams the encoded job to the port in chunks. Cancellable. The chunked
+        /// write is intentional — Write() blocks until the OS accepts the bytes,
+        /// which with RTS/CTS or XOn/XOff yields cleanly when the controller's
+        /// buffer is full.
+        /// </summary>
+        public void StreamJob(byte[] data, CancellationToken cancellationToken = default)
+        {
+            if (data == null) throw new ArgumentNullException(nameof(data));
+            if (port == null || !port.IsOpen)
+                throw new InvalidOperationException("Port is not open.");
+
+            var chunk = ChunkSize > 0 ? ChunkSize : DefaultChunkSize;
+            var offset = 0;
+
+            while (offset < data.Length)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                var count = System.Math.Min(chunk, data.Length - offset);
+                port.Write(data, offset, count);
+                offset += count;
+            }
+
+            // Block until the OS has handed the last bytes to the line. SerialPort
+            // doesn't expose flush-and-drain directly; BaseStream.Flush is a no-op
+            // on Windows, so this is best-effort.
+            try { port.BaseStream.Flush(); }
+            catch { /* ignored — Flush is advisory on SerialPort */ }
+        }
+
+        public void Close()
+        {
+            if (port == null) return;
+            try
+            {
+                if (port.IsOpen) port.Close();
+            }
+            finally
+            {
+                port.Dispose();
+                port = null;
+            }
+        }
+
+        public void Dispose() => Close();
+    }
+}