Add time limited matching.

Author: GrandFatherADI

README.md

@@ -17,15 +17,33 @@ supported.
 Install **ReSearch** by clicking "Install" on the **Re Search** entry in the
 Extensions panel.
 
-Use the Analyzers side panel to use a Re Search analyzer with a suitable low
-level analyser. At present the Async Serial analyzer is well supported. I2C
-partial support has been added, but not thoroughly tested. Untested support for
-other LLAs may be added in the future.
-
-In the ReSearch Settings dialog select the required input analyzer then set the
-regular expression match string. Python regular expression syntax is used for
-the match string. Note that the provided match is not checked for syntax errors
-(a badly formed string will generate a somewhat cryptic error dialog in Logic!)
+Use the Analyzers side panel to add a Re Search analyzer.
+
+In the ReSearch Settings dialog select the LLA. At present the Async Serial
+analyzer is well supported. I2C partial support has been added, but is not
+thoroughly tested. Support for other LLAs may be added in the future.
+
+### Match
+
+Use the Match setting to set teh regular expression. Python regular expression
+syntax is used for the match string. Note that the provided match is not checked
+for syntax errors (a badly formed string will generate a somewhat cryptic error
+dialog in Logic!).
+
+Note that trailing wild card matches are generally not useful as the match is
+performed when each character is added to the target string. For example, `fox.*`
+will match `fox`, at which point all characters up to and including `fox` will
+be dropped. Anchor the end of the expression with a non-wild pattern. Often a
+positive look ahead match (`(?= ...)`) is useful as an anchor.
+
+### Max span (s)
+
+Use the **Max span (s)** setting to specify the maximum width in seconds allowed
+for a match. This can be used to match only within a block of text when there is
+significant time between blocks for example. It also makes the matching process
+run faster because it can ignore anything that is too old.
+
+Setting **Max span (s)** to `0` or leaving it blank turns this feature off.
 
 ## Data Rendering
 

ReSearch.png

@@ -1,6 +1,7 @@
 import re
 from datetime import datetime
-from saleae.analyzers import HighLevelAnalyzer, AnalyzerFrame, StringSetting
+from saleae.analyzers import HighLevelAnalyzer, AnalyzerFrame
+from saleae.analyzers import NumberSetting, StringSetting
 from saleae.data import GraphTimeDelta as GTD
 
 kTimeZero = datetime(1, 1, 1)
@@ -73,11 +74,37 @@ def Drop(self, lastIndex):
             # the string. Trim the string and update the block start time
             startEpoch = block.start
             endEpoch = block.end
-            charTime = (endEpoch - startEpoch) / strLen
             delChars = lastIndex - blockStartIndex
-            block.start = startEpoch + GTD(charTime * delChars)
+            block.start = startEpoch + GTD(block.charTime * delChars)
             block.str = block.str[lastIndex - blockStartIndex : ]
-            block.charTime = charTime
+            return
+
+    def DropBefore(self, timeDelta):
+        # Remove all blocks before the end time of the last block - timeDelta
+        if not len(self.blocks):
+            return
+
+        # Calculate the cut off time
+        cutOffTime = self.blocks[-1].end - GTD(timeDelta)
+
+        while len(self.blocks):
+            block = self.blocks[0]
+            strLen = len(block.str)
+
+            if block.start > cutOffTime:
+                # Whole block is within allowed time span. Done
+                return
+
+            if block.end < cutOffTime:
+                # None of the block is within the allowed time span. Drop it.
+                del self.blocks[0]
+                continue
+
+            # The block spans the start of the allowed time span. Trim the
+            # block.
+            delCount = int((float(cutOffTime - block.start) + block.charTime) / block.charTime)
+            block.start += GTD(delCount * block.charTime)
+            block.str = block.str[delCount : ]
             return
 
     def Match(self, drop = False):
@@ -142,6 +169,7 @@ def Match(self, drop = False):
 class ReSearch(HighLevelAnalyzer):
 
     kMatch = StringSetting(label = "Match")
+    kMatchTime = StringSetting(label = "Max span (s)")
 
     result_types = {
         "Matched": {"format": "{{{data.Matched}}}"},
@@ -188,9 +216,7 @@ def AddData(self, params):
         if 'address' in params.data and params.data["address"]:
             asStr = '@' + hex(params.data["data"][0]) + ' '
 
-        elif self.haveAddress \
-            or params.data["data"][0] > 127 \
-            or params.data["data"][0] < 32:
+        elif self.haveAddress or params.data["data"][0] > 127:
             # I2C or other bus protocol with addressed devices or the character
             # from an async serial analyzer is outside the ASCII range
             asStr = hex(params.data["data"][0]) + ' '
@@ -218,6 +244,11 @@ def __init__(self):
         self.isSource = False
         self.Reset()
 
+        if not len(self.kMatchTime):
+            self.kMatchTime = "0"
+
+        self.kMatchTime = float(str(self.kMatchTime))
+
         # handlers return True if a match should be attempted
         self.handlerDispatch = {
             "address": self.AddAddress,
@@ -238,6 +269,9 @@ def decode(self, newFrame: AnalyzerFrame):
         if not self.handlerDispatch[newFrame.type](newFrame):
             return
 
+        if self.kMatchTime:
+            self.blocks.DropBefore(self.kMatchTime)
+
         match = self.blocks.Match(drop = True)
 
         if not match:

ReSearch.py

@@ -1,5 +1,5 @@
 {
-  "version": "1.2",
+  "version": "1.3",
   "apiVersion": "1.0.0",
   "author": "Peter Jaquiery",
   "description": "Match text in async serial logging",