Add "Read" button for configuration variables (and WIP writing code, hidden until next commit).

Author: Poikilos

examples/examples_gui.py

@@ -453,14 +453,15 @@ def _gui(self, parent):
             command=self.cdiConnectClicked,
         )
         self.cdi_connect_button.grid(row=self.cdi_row, column=0)
+        self.cdi_row += 1
 
         self.cdi_refresh_button = ttk.Button(
             self.cdi_tab,
             text="Refresh",
             command=self.cdiRefreshClicked,
             state=tk.DISABLED,  # enabled on connect success callback
         )
-        self.cdi_refresh_button.grid(row=self.cdi_row, column=1)
+        self.cdi_refresh_button.grid(row=self.cdi_row, column=0)
         self.cdi_row += 1
 
         self.cdiSettingFrame = ttk.Frame(self.cdi_tab)
@@ -502,7 +503,7 @@ def _gui(self, parent):
 
     def setupNetwork(self):
         self.network = OpenLCBNetwork(self.getValue('localNodeID'))
-        self.cdi_form = CDIForm(self.network.canLink, self.cdi_tab)
+        self.cdi_form = CDIForm(self.cdi_tab, self.network.canLink, self)
         self.cdi_form.setSettingsContainer(self.cdiSettingFrame)
         self.cdi_form.setStatusCallback(self.setStatus)
         # ^ formerly OpenLCBNetwork() subclass
@@ -609,7 +610,6 @@ def cdiConnectClicked(self):
         # This thread may end quickly after connection since
         #   start_receiving starts a thread.
         self.cdi_connect_button.configure(state=tk.DISABLED)
-        self.cdi_connect_button.configure(state=tk.DISABLED)
 
     def cdiRefreshClicked(self):
         self.cdi_connect_button.configure(state=tk.DISABLED)

examples/tkexamples/cdiform.py

@@ -9,6 +9,7 @@
 
 Contributors: Poikilos
 """
+from functools import partial
 import logging
 import os
 import sys
@@ -23,6 +24,9 @@
 from xml.etree import ElementTree as ET
 
 from openlcb.cdivar import CLASSNAME_TYPES, CDIVar
+from openlcb.memoryservice import MemoryReadMemo
+from openlcb.nodeid import NodeID
+from openlcb.openlcbnetwork import OpenLCBNetwork
 
 
 if __name__ == "__main__":
@@ -67,22 +71,30 @@ class CDIForm(ttk.Frame, XMLDataProcessor):
     Args:
         parent (TkWidget): Typically a ttk.Frame or tk.Frame with "root"
             attribute set.
+        linkLayer (LinkLayer): Typically a CanLink instance.
     """
     def __init__(self, *args, **kwargs):
-        assert isinstance(args[0], LinkLayer), \
+        assert issubclass(type(args[1]), LinkLayer), \
             "Expected LinkLayer/subclass got {}".format(type(args[0]).__name__)
-        linkLayer = args[0]
-        args = args[1:]  # remove first argument (only for GUI)
+        linkLayer = args[1]
+        assert issubclass(type(args[0]), tk.Widget)
         XMLDataProcessor.__init__(self, linkLayer, MemorySpace.CDI)
-        ttk.Frame.__init__(self, *args, **kwargs)
+        ttk.Frame.__init__(self, *args[:1], **kwargs)
         self._top_widgets = []
         if len(args) < 1:
             raise ValueError("at least one argument (parent) is required")
         self.parent = args[0]
-        self.root = args[0]
+        self.mainform = args[2]
+        self.root = args[2]
+        assert hasattr(self.mainform, 'network'), \
+            "mainform must have 'network' OpenLCBNetwork"
+        assert hasattr(self.mainform, 'settings'), \
+            "mainform must have 'settings' dictionary with at least 'farNodeID'"
         self._status_callback = None
         if hasattr(self.parent, 'root'):
             self.root = self.parent.root
+        elif hasattr(self.mainform, 'root'):
+            self.root = self.mainform.root
         self._container = self  # where to put visible widgets
         self._treeview = None  # type: ttk.Treeview|None
         self._treeMemos = {}  # type: Dict[str, CDIMemo]
@@ -178,7 +190,7 @@ def onTreeSelect(self, event: tk.Event):
             cm = self._treeMemos[iid]
             # print(f"type(item)={type(item)}")
             # raise NotImplementedError(item)
-            # print(f"cm={cm}")
+            print(f"cm={cm}")
             self.clearSettingWidgets()
             if cm.tag not in CLASSNAME_TYPES:
                 # Non-value (such as segment or group)
@@ -199,7 +211,7 @@ def onTreeSelect(self, event: tk.Event):
             tkvar = None
             v_widget = None
             mapToValue = cm.valueMap()
-            self.mapToValue = mapToValue
+            # self.mapToValue = mapToValue
             if mapToValue:
                 tkvar = tk.StringVar(self.root)
                 v_widget = ttk.Combobox(self.cdiSettingFrame,
@@ -215,22 +227,58 @@ def onTreeSelect(self, event: tk.Event):
                     raise TypeError("Device should not specify max for {}"
                                     .format(cdivar.className))
                 v_widget = ttk.LabeledScale(self.cdiSettingFrame,
-                                            variable=tkvar)
+                                            variable=tkvar,
+                                            from_=cdivar.min,
+                                            to=cdivar.max)
                 # ^ widget.scale is ttk.Scale, widget.label is ttk.Label
                 # ^ a.k.a. Slider (if not using Tk)
                 v_widget.scale.cdivar = cdivar
                 v_widget.scale.tip = nameLabel.tip
+
+                def update_label_width(*args):
+                    # Fix label being too small to show value:
+                    v_widget.label.configure(width=len(str(int(tkvar.get()))) + 2)  # noqa: E501
+                tkvar.trace_add('write', update_label_width)
             else:
                 tkvar = tk.StringVar(self.root)
                 v_widget = ttk.Entry(self.cdiSettingFrame, textvariable=tkvar)
             v_widget.grid(column=1, row=self.cdiSettingRow)
             self.cdiSettingRow += 1
             self.cdiSettingWidgets.append(v_widget)
             if cdivar.default is not None:
-                tkvar.set(cdivar.default)
+                defaultStr = cdivar.default
+                if mapToValue:
+                    mapToStr = cm.keyMap()
+                    assert mapToStr
+                    defaultStr = mapToStr[str(cdivar.default.value())]
+                tkvar.set(defaultStr)
             v_widget.cdivar = cdivar
             v_widget.tip = nameLabel.tip
+            try:
+                v_widget.configure(state='readonly')  # readonly until refresh
+            except tk.TclError:
+                pass  # N/A such as for Scale
+            #   so that previous value is known.
+
+            # Write and Read buttons
+            writeButton = ttk.Button(
+                self.cdiSettingFrame,
+                text="Write",
+                command=partial(self.onWriteValueClicked, v_widget, tkvar,
+                                cdivar, mapToValue=mapToValue),
+            )
+            # writeButton.grid(column=0, row=self.cdiSettingRow)
+
+            readButton = ttk.Button(
+                self.cdiSettingFrame,
+                text="Read",
+                command=partial(self.onReadValueClicked, v_widget, tkvar,
+                                cdivar, mapToValue=mapToValue),
+            )
+            readButton.grid(column=1, row=self.cdiSettingRow)
+            self.cdiSettingRow += 1
 
+            # Show the address
             address_str = ""
             if address_str is not None:
                 address_str = str(cm.address)
@@ -241,9 +289,96 @@ def onTreeSelect(self, event: tk.Event):
             self.cdiSettingWidgets.append(a_widget)
             self.cdiSettingWidgets.append(av_widget)
             self.cdiSettingRow += 1
-
             break
 
+    def onReadValueClicked(self, v_widget: tk.Widget,
+                           tkvar: Union[tk.StringVar, tk.IntVar, tk.DoubleVar],
+                           cdivar: CDIVar, mapToValue=None):
+        print("read:"
+              f" space={cdivar.space}={hex(cdivar.space)}"
+              f" address={cdivar.address}={hex(cdivar.address)}"
+              f" size={cdivar.size}={hex(cdivar.size)}")
+        # read 64 bytes from the CDI space starting at address zero
+        assert hasattr(self.mainform, 'settings'), \
+            "mainform must have 'settings' dictionary"
+        assert 'farNodeID' in self.mainform.settings, \
+            "mainform 'settings' dictionary is missing 'farNodeID'"
+        farNodeIDStr = self.mainform.settings['farNodeID']
+
+        memMemo = MemoryReadMemo(NodeID(farNodeIDStr),
+                                 cdivar.size, cdivar.space,
+                                 cdivar.address, self.memoryReadFail,
+                                 self.memoryReadSuccess)
+        memMemo.widget = v_widget
+        memMemo.tkvar = tkvar
+        memMemo.cdivar = cdivar
+        memMemo.mapToValue = mapToValue
+        network = self.mainform.network  # type: OpenLCBNetwork
+        network._memoryService.requestMemoryRead(memMemo)
+
+    def memoryReadFail(self, memo: MemoryReadMemo):
+        self.setStatus("Memory read...error.")
+
+    def memoryReadSuccess(self, memo: MemoryReadMemo):
+        self.setStatus("Memory read...success.")
+        widget = None  # type: tk.Widget | None
+        tkvar = None  # type: tk.StringVar | tk.IntVar | tk.DoubleVar | None
+        cdivar = None  # type: CDIVar | None
+        if hasattr(memo, 'widget'):
+            widget = memo.widget
+            try:
+                # widget['state'] = tk.NORMAL
+                widget.configure(state=tk.NORMAL)
+            except tk.TclError:
+                pass  # N/A (such as Scale)
+        value = None
+        mapToValue = None
+        found = None
+        if hasattr(memo, 'cdivar'):
+            cdivar = memo.cdivar
+            assert cdivar is not None
+            cdivar.setData(memo.data)
+            value = cdivar.value()
+            if (value is not None) and hasattr(memo, 'mapToValue'):
+                mapToValue = memo.mapToValue
+                if mapToValue:
+                    for k, v in mapToValue.items():
+                        # if str(v.value()) == str(value):
+                        if v.value() == value:
+                            value = k  # key is the user-facing string
+                            found = value
+                            break
+                    if found is None:
+                        logger.warning(
+                            f"Found no matching value for {repr(value)} in {mapToValue}")
+                    else:
+                        logger.warning(
+                            f"Found matching value {repr(value)} for {found}")
+                else:
+                    logger.debug(
+                        f"There is no value map. Using {repr(value)} directly")
+            else:
+                logger.debug(
+                    f"There is no value map. Using {repr(value)} directly")
+        else:
+            logger.warning("There is no cdivar.")
+        if hasattr(memo, 'tkvar'):
+            tkvar = memo.tkvar
+            if value is not None:
+                if isinstance(tkvar, tk.StringVar):
+                    print(f"Set StringVar to {repr(value)}")
+                    tkvar.set(str(value))
+                else:
+                    print(f"Set {type(tkvar).__name__} to {repr(value)}"
+                          f" ({cdivar.data})")
+                    # Assume input already matches type of tk var
+                    tkvar.set(value)
+
+    def onWriteValueClicked(self, v_widget: tk.Widget,
+                            tkvar: Union[tk.StringVar, tk.IntVar, tk.DoubleVar],  # noqa: E501
+                            cdivar: CDIVar, mapToValue=None):
+        print(f"TODO: write: {cdivar.className}({repr(tkvar.get())})")
+
     def clearSettingWidgets(self):
         for widget in self.cdiSettingWidgets:
             widget.grid_forget()

openlcb/cdimemo.py

@@ -278,10 +278,11 @@ def toXMLEnd(self):
         return memoRepr
 
     def valueMap(self):
-        # type: () -> Union[dict, None]
+        # type: () -> Union[dict[str, CDIVar], None]
         """Map each relation in a dict.
-        Property and value are swapped to make the result a lookup
-        table where the key is the user-facing caption.
+        The "property" and "value" are swapped to make the result a
+        lookup table where the user-facing caption ("value") is used as
+        the key.
         """
         mapMemo = self.getChildByTag("map")
         if mapMemo is None:
@@ -315,7 +316,9 @@ def valueMap(self):
                 logger.warning(f"expected only one value {repr(value)}"
                                f" (property {repr(prop)}) in relation for"
                                f" {self.getChildContent('name')}")
-            results[value] = prop  # reverse to make it a lookup by caption
+            propVar = self.toCDIVar()
+            propVar.setFromString(prop)
+            results[value] = propVar  # reverse to make it a lookup by caption
         return results
 
     def keyMap(self):
@@ -328,7 +331,10 @@ def keyMap(self):
             return None
         results = OrderedDict()
         for k, v in tmp.items():
-            results[v] = k
+            vStr = v.value()
+            assert vStr is not None
+            vStr = str(vStr)
+            results[vStr] = k
         return results
 
     def getChildByTag(self, tag):

openlcb/cdivar.py

@@ -535,6 +535,13 @@ def set(self, other: Union['CDIVar', int, float]):
                     f"Tried to set {self.className} to a(n)"
                     f" {type(other).__name__}")
 
+    def setFromString(self, valueStr):
+        """Use this only for types that can be cast from str
+        (Or implement manual parsing).
+        """
+        value = CLASSNAME_TYPES[self.className](valueStr)
+        self.set(value)
+
     def getData(self):
         return self.data
 

openlcb/memoryservice.py

@@ -247,8 +247,13 @@ def __init__(self, nodeID: NodeID, size: int, space: int, address: int,
         self.error = None  # type: str|None
         self.errorCode = None  # type: int|None
         self.nodeID = nodeID
+        assert isinstance(size, int)
         self.size = size
+        if isinstance(space, MemorySpace):
+            space = space.value
+        assert isinstance(space, int)
         self.space = space
+        assert isinstance(address, int)
         self.address = address
         self.rejectedReply = rejectedReply
         self.dataReply = dataReply