Better reporting and safer operation on mode switches

Author: psychogenic

src/ttboard/demoboard.py

@@ -452,6 +452,7 @@ def apply_user_config(self, design:Design):
             RPMode.ASIC_RP_CONTROL: True,
             RPMode.ASIC_MANUAL_INPUTS: True
         }
+        
         if not self.apply_configs:
             log.debug(f'apply user conf: disabled')
             # don't wanna

src/ttboard/pins/pins.py

@@ -144,16 +144,16 @@ def __init__(self, mode:int=RPMode.SAFE):
             self.pin_hk_csb = self.muxCtrl.ctrlpin.raw_pin 
             self._allpins['hk_csb'] = self.hk_csb
 
-        self.mode = mode 
         self._init_ioports()
+        self.mode = mode 
 
 
 
     def _init_ioports(self):
         # Note: these are named according the the ASICs point of view
         # we can write ui_in, we read uo_out
         port_defs = [
-            ('uo_out', platform.read_output_byte, platform.write_output_byte),
+            ('uo_out', platform.read_output_byte, None),
             ('ui_in', platform.read_input_byte, platform.write_input_byte),
             ('uio_in', platform.read_bidir_byte, platform.write_bidir_byte),
             ('uio_out', platform.read_bidir_byte, None)
@@ -181,21 +181,28 @@ def mode(self):
         return self._mode 
 
     @mode.setter
-    def mode(self, setTo:int):
+    def mode(self, set_mode:int):
         startupMap = {
             RPModeDEVELOPMENT.STANDALONE: self.begin_standalone,
             RPMode.ASIC_RP_CONTROL: self.begin_asiconboard,
             RPMode.ASIC_MANUAL_INPUTS: self.begin_asic_manual_inputs,
             RPMode.SAFE: self.begin_safe
         }
 
-        if setTo not in startupMap:
-            setTo = RPMode.SAFE 
+        if set_mode not in startupMap:
+            set_mode = RPMode.SAFE 
 
-        self._mode = setTo
-        log.info(f'Setting mode to {RPMode.to_string(setTo)}')
-        beginFunc = startupMap[setTo]
+        self._mode = set_mode
+        log.info(f'Setting mode to {RPMode.to_string(set_mode)}')
+        beginFunc = startupMap[set_mode]
         beginFunc()
+        if set_mode == RPMode.ASIC_RP_CONTROL:
+            self.ui_in.byte_write = platform.write_input_byte
+            self.uio_in.byte_write = platform.write_bidir_byte
+        else:
+            self.ui_in.byte_write = None 
+            self.uio_in.byte_write = None
+            
 
     def begin_inputs_all(self):
 

src/ttboard/ports/io.py

@@ -15,6 +15,32 @@ def __init__(self, name:str, read_byte_fn=None, write_byte_fn=None):
         self.port = port
 
 
+        self.byte_read = read_byte_fn 
+        self.byte_write = write_byte_fn
+    
+    @property 
+    def is_readable(self):
+        return self.port.is_readable 
+    
+    @property 
+    def is_writeable(self):
+        return self.port.is_readable
+    
+    @property 
+    def byte_read(self):
+        return self.port.byte_read
+    @byte_read.setter 
+    def byte_read(self, func):
+        self.port.byte_read = func
+    @property 
+    def byte_write(self):
+        return self.port.byte_write
+    
+    @byte_write.setter 
+    def byte_write(self, func):
+        self.port.byte_write = func
+        
+    
     def __repr__(self):
         val = hex(int(self.value)) if self.port.is_readable  else ''
         return f'<IO {self.port.name} {val}>'

src/ttboard/types/ioport.py

@@ -6,6 +6,8 @@
 '''
 
 from ttboard.types.range import Range
+import ttboard.log as logging
+log = logging.getLogger(__name__)
 
 class Port:    
     def __init__(self, name:str, read_byte_fn=None, write_byte_fn=None):
@@ -23,18 +25,21 @@ def is_writeable(self):
 
     def set_signal_val_int(self, vint:int):
         if self.byte_write is None:
-            raise RuntimeError('writes not supported')
+            log.error(f'writes not supported on {self.name}')
+            return
         self.byte_write(vint)
 
     def set_signal_val_binstr(self, vstr:str):
         if self.byte_write is None:
-            raise RuntimeError('writes not supported')
+            log.error(f'writes not supported on {self.name}')
+            return 
         self.byte_write(int(vstr, 2))
 
 
     def get_signal_val_binstr(self):
         if self.byte_read is None:
-            raise RuntimeError('reads not supported')
+            log.error(f'reads not supported on {self.name}')
+            return
         v = self.byte_read()
         return f'{v:08b}'