Logs now flush after a configurable number of seconds (defaulting to …

…2 secs).
Threetwosevensixseven · Dec 15, 2019 · 2e8d0f4 · 2e8d0f4
1 parent c013629
commit 2e8d0f4
Show file tree

Hide file tree

Showing 3 changed files with 75 additions and 59 deletions.
diff --git a/UARTLogger/Settings.cs b/UARTLogger/Settings.cs
@@ -12,15 +12,18 @@ namespace UARTLogger
 {
     public class Settings
     {
+        private const int FLUSH_DEFAULT = 2;
         public bool EnableESPLogging { get; set; }
         public bool EnablePiLogging { get; set; }
         public bool TruncateLogsOnStartup { get; set; }
         public string ESPLogFile { get; set; }
         public string PiLogFile { get; set; }
+        public int FlushLogsAfterSecs { get; set; }
 
         public Settings()
         {
             ESPLogFile = PiLogFile = string.Empty;
+            FlushLogsAfterSecs = FLUSH_DEFAULT;
         }
 
         public string ToXML()
@@ -59,6 +62,8 @@ public static Settings Load(string OptionalFileNameAndPath = null)
             {
                 settings = new Settings();
             }
+            if (settings.FlushLogsAfterSecs <= 0)
+                settings.FlushLogsAfterSecs = FLUSH_DEFAULT;
             return settings;
         }
 

diff --git a/UARTLogger/UARTBuffer.cs b/UARTLogger/UARTBuffer.cs
@@ -3,6 +3,7 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace UARTLogger
@@ -13,17 +14,22 @@ public class UARTBuffer : IDisposable
         private Queue<byte> buffer;
         private UARTStates state;
         private UARTTargets target;
+        private object sync;
+        private Timer timer;
 
         public UARTBuffer(Settings Settings)
         {
             settings = Settings;
             buffer = new Queue<byte>();
             state = UARTStates.Reading;
             target = UARTTargets.ESP;
+            sync = new object();
+            timer = new Timer(timerElapsed, this, settings.FlushLogsAfterSecs * 1000, Timeout.Infinite);      
         }
 
         public void Log(byte Value, UARTStates NewState)
         {
+            timer.Change(settings.FlushLogsAfterSecs * 1000, Timeout.Infinite);
             if (state != NewState)
             {
                 Flush();
@@ -34,6 +40,7 @@ public void Log(byte Value, UARTStates NewState)
 
         public void ChangeUARTType(UARTTargets NewTarget)
         {
+            timer.Change(settings.FlushLogsAfterSecs * 1000, Timeout.Infinite);
             if (NewTarget != target)
             {
                 Flush();
@@ -43,69 +50,78 @@ public void ChangeUARTType(UARTTargets NewTarget)
 
         private void Flush()
         {
-            if (!settings.EnableESPLogging && target == UARTTargets.ESP)
+            lock (sync)
             {
-                buffer = new Queue<byte>();
-                return;
-            }
-            else if (!settings.EnablePiLogging && target == UARTTargets.Pi)
-            {
-                buffer = new Queue<byte>();
-                return;
-            }
+                if (!settings.EnableESPLogging && target == UARTTargets.ESP)
+                {
+                    buffer = new Queue<byte>();
+                    return;
+                }
+                else if (!settings.EnablePiLogging && target == UARTTargets.Pi)
+                {
+                    buffer = new Queue<byte>();
+                    return;
+                }
 
-            if (buffer.Count > 0)
-            {
-                // Write header
-                string action = state == UARTStates.Reading ? "Read " : "Written ";
-                string prep = state == UARTStates.Reading ? "from " : "to ";
-                string plural = buffer.Count == 1 ? "" : "s";
-                var now = DateTime.Now;
-                var sb = new StringBuilder();
-                sb.AppendLine();
-                sb.Append("[");
-                sb.Append(now.ToShortDateString());
-                sb.Append(" ");
-                sb.Append(now.ToLongTimeString());
-                sb.Append("] ");
-                sb.Append(action);
-                sb.Append(buffer.Count);
-                sb.Append(" byte");
-                sb.Append(plural);
-                sb.Append(" ");
-                sb.Append(prep);
-                sb.Append(target.ToString());
-                sb.AppendLine(":");
-
-                // Write data rows
-                int rowCount = 0;
-                string hex = "";
-                string asc = "";
-                while(buffer.Count > 0)
+                if (buffer.Count > 0)
                 {
-                    if (rowCount == 0)
-                    {
-                        hex = "    ";
-                        asc = "";
-                    }
-                    byte b = buffer.Dequeue();
-                    hex += b.ToString("x2") + " ";
-                    asc += SpectrumCharset.ToASCII(b);
-                    rowCount++;
-                    if (rowCount >= 16 || buffer.Count == 0)
+                    // Write header
+                    string action = state == UARTStates.Reading ? "Read " : "Written ";
+                    string prep = state == UARTStates.Reading ? "from " : "to ";
+                    string plural = buffer.Count == 1 ? "" : "s";
+                    var now = DateTime.Now;
+                    var sb = new StringBuilder();
+                    sb.AppendLine();
+                    sb.Append("[");
+                    sb.Append(now.ToShortDateString());
+                    sb.Append(" ");
+                    sb.Append(now.ToLongTimeString());
+                    sb.Append("] ");
+                    sb.Append(action);
+                    sb.Append(buffer.Count);
+                    sb.Append(" byte");
+                    sb.Append(plural);
+                    sb.Append(" ");
+                    sb.Append(prep);
+                    sb.Append(target.ToString());
+                    sb.AppendLine(":");
+
+                    // Write data rows
+                    int rowCount = 0;
+                    string hex = "";
+                    string asc = "";
+                    while (buffer.Count > 0)
                     {
-                        sb.Append(hex.PadRight(54));
-                        sb.Append(asc);
-                        sb.AppendLine();
-                        rowCount = 0;
+                        if (rowCount == 0)
+                        {
+                            hex = "    ";
+                            asc = "";
+                        }
+                        byte b = buffer.Dequeue();
+                        hex += b.ToString("x2") + " ";
+                        asc += SpectrumCharset.ToASCII(b);
+                        rowCount++;
+                        if (rowCount >= 16 || buffer.Count == 0)
+                        {
+                            sb.Append(hex.PadRight(54));
+                            sb.Append(asc);
+                            sb.AppendLine();
+                            rowCount = 0;
+                        }
                     }
-                }
 
-                // Log result
-                Debug.Write(sb.ToString());
+                    // Log result
+                    Debug.Write(sb.ToString());
+                }
             }
         }
 
+        private void timerElapsed(object Buffer)
+        {
+            if (Buffer is UARTBuffer)
+                ((UARTBuffer)Buffer).Flush();
+        }
+
         #region IDisposable
 
         private bool disposedValue = false; // To detect redundant calls

diff --git a/UARTLogger/UARTLogger_Device.cs b/UARTLogger/UARTLogger_Device.cs
@@ -26,11 +26,6 @@ public List<sIO> Init(iCSpect _CSpect)
             Settings = Settings.Load();
             Buffer = new UARTBuffer(Settings);
 
-            // Read current setting of UART control
-            byte b = CSpect.InPort(PORT_UART_CONTROL);
-            // Returns 255 on first read, so assume we start off as ESP
-            //CurrentUARTType = (_value & 64) == 0 ? UARTTypes.ESP : UARTTypes.Pi;
-
             // create a list of the ports we're interested in, but only if we're logging
             List<sIO> ports = new List<sIO>();
             if (Settings.EnableESPLogging || Settings.EnableESPLogging)