Multi-shuttle first boot and factory test support

Author: psychogenic

src/config.ini

@@ -13,7 +13,7 @@
 
 [DEFAULT]
 # project: project to load by default
-project = tt_um_test
+project = tt_um_factory_test
 
 # start in reset (bool)
 start_in_reset = no
@@ -41,7 +41,10 @@ clock_frequency = 10
 start_in_reset = no
 input_byte = 1
 
-
+[tt_um_factory_test]
+clock_frequency = 10
+start_in_reset = no
+input_byte = 1
 
 
 [tt_um_psychogenic_neptuneproportional]

src/first_boot.ini

@@ -8,7 +8,6 @@
 #  - ERROR
 log_level = INFO
 
-
 # if 'no', go through all tests
 abort_runs_on_error = no
 
@@ -28,18 +27,29 @@ command = setup_somehow()
 
 [run_01_bidir_test]
 message = Basic comms, mux, bidir and output pin test
-command = test_bidirs(0xff)
+command = test_bidirs_03p5(0xff)
+shuttle = tt03p5
+
 
 [run_02_test_clocking]
 message = Test clocking a project manual style
-command = test_clocking(0x42)
+command = test_clocking_03p5(0x42)
+shuttle = tt03p5
+
+[run_01_factory_test]
+message = TT04 factory test
+command = test_clocking_04(0x42)
+shuttle = tt04
+
+
 
 ## SUCCESS ##
 [onsuccess]
 # runs if all previous operations succeeded
 message = All good: running on success command
 command = firstboot_completed()
 
+
 ## FAILURE ###
 [onfail]
 message = Issue with first boot

src/ttboard/boot/first.py

@@ -179,6 +179,14 @@ def run(self):
         keep_running_tests = True
         for section in sorted(self.config.sections):
             if keep_running_tests and section.startswith('run_'):
+                if self.config.has_option(section, 'shuttle'):
+                    shuttle = self.config.get(section, 'shuttle')
+                    if shuttle is not None and len(shuttle) and shuttle != demoboard.chip_ROM.shuttle:
+                        self.log_message(f'Section {section} is for shuttle {shuttle}, we are {demoboard.chip_ROM.shuttle}: skipping')
+                        continue 
+                    
+                self.log_message(f'Found section {section} to run')
+                
                 context['tests'][section] = True
                 if not RunOperation(demoboard, section, self.config).execute(context):
                     self.log_error(f'Execution of {section} failed')
@@ -187,6 +195,7 @@ def run(self):
                     if abort_runs_on_err:
                         self.log_error(f'And abort_runs_on_error is set, aborting.')
                         keep_running_tests = False
+                        
 
         if num_fails:
             if self.config.has_section('onfail'):
@@ -195,6 +204,7 @@ def run(self):
 
         if self.config.has_section('onsuccess'):
             should_delete_op = RunOperation(demoboard, 'onsuccess', self.config)
+            self.log_message('Running onsuccess')
             if not should_delete_op.execute(context):
                 self.log_error('Could not execute onsuccess???')
                 self.run_complete(False)

src/ttboard/boot/firstboot_operations.py

@@ -51,7 +51,14 @@ def firstboot_completed():
     # can only happen if all tests ([run_*] sections)
     # run and return True
     print("Done first boot")
-    say_hello(180, times=2)
+    tt = get_demoboard()
+    if tt.chip_ROM.shuttle == 'tt03p5':
+        print("CHIPROM shuttle is 03p5, saying hello")
+        say_hello_03p5(180, times=2)
+    else:
+        print(f"CHIPROM shuttle {tt.chip_ROM.shuttle}, saying hello")
+        say_hello(180, times=2)
+        
     return True
 
 
@@ -68,11 +75,11 @@ def firstboot_failure():
     print()
 
 
-def test_bidirs(max_idx:int, delay_interval_ms:int=1):
+def test_bidirs_03p5(max_idx:int, delay_interval_ms:int=1):
     # a test, must return True to consider a pass
     tt = get_demoboard()
     print(f'Testing bidirs up to {max_idx} on {tt}')
-    err = shut_tests.factory_test_bidirs(tt, max_idx, delay_interval_ms)
+    err = shut_tests.factory_test_bidirs_03p5(tt, max_idx, delay_interval_ms)
 
     if err is not None:
         log.error(err)
@@ -81,12 +88,21 @@ def test_bidirs(max_idx:int, delay_interval_ms:int=1):
     return True
 
 
+def test_clocking_04(max_idx:int=30, delay_interval_ms:int=50):
+    tt = get_demoboard()
+    print(f'Testing manual clocking up to {max_idx} on {tt}')
+    err = shut_tests.factory_test_clocking_04(tt, max_idx, delay_interval_ms)
+    if err is not None:
+        log.error(err)
+        return False 
+    
+    return True
 
-def test_clocking(max_idx:int=30, delay_interval_ms:int=50):
+def test_clocking_03p5(max_idx:int=30, delay_interval_ms:int=50):
     # a test, must return True to consider a pass
     tt = get_demoboard()
     print(f'Testing manual clocking up to {max_idx} on {tt}')
-    err = shut_tests.factory_test_clocking(tt, max_idx, delay_interval_ms)
+    err = shut_tests.factory_test_clocking_03p5(tt, max_idx, delay_interval_ms)
     if err is not None:
         log.error(err)
         return False 
@@ -96,27 +112,70 @@ def test_clocking(max_idx:int=30, delay_interval_ms:int=50):
 
 
 
+def say_hello(delay_interval_ms:int=200, times:int=1):
+    
+    hello_values = [0x74, 0x79, 0x30, 0x30, 0x5c, 0, 0]
+    tt = get_demoboard()
+    try:
+        tt.shuttle.factory_test.enable()
+    except:
+        print('Failed to load factory test?')
+        return 
+    
+        
+    tt.mode = RPMode.ASIC_RP_CONTROL # make sure we're controlling everything
+    
+    tt.in0(0) # want this low
+    tt.clock_project_PWM(1e3) # clock it real good
+    
+    log.info('First boot: saying hello')
+    # for bp in tt.bidirs:
+    #    bp.mode = Pins.OUT
+    #    bp(0) # start low
+    for _i in range(times):
+        for v in hello_values:
+            tt.input_byte = v
+            time.sleep_ms(delay_interval_ms)
+            
+            tt.input_byte = 0
+            time.sleep_ms(int(delay_interval_ms/10))
+        
+        tt.input_byte = 0
+        time.sleep_ms(int(delay_interval_ms/2))
+        
+    tt.clock_project_stop()
+    
+    return True
+
 
-def say_hello(delay_interval_ms:int=100, times:int=1):
+def say_hello_03p5(delay_interval_ms:int=200, times:int=1):
     # a test, must return True to consider a pass
-    print(f'Saying hello')
-    
-    hello_values = [0x74, 0x79, 0x30, 0x30, 0x5c, 0, 0x50, 0x10, 0x78, 0x77]
+    hello_values = [0x74, 0x79, 0x30, 0x30, 0x5c, 0, 0]
     tt = get_demoboard()
-    tt.shuttle.tt_um_test.enable()
+    try:
+        tt.shuttle.factory_test.enable()
+    except:
+        print('Failed to load factory test?')
+        return 
+    
+        
     tt.mode = RPMode.ASIC_RP_CONTROL # make sure we're controlling everything
 
     tt.in0(0) # want this low
     tt.clock_project_PWM(1e3) # clock it real good
 
     log.info('First boot: saying hello')
-    for bp in tt.bidirs:
-        bp.mode = Pins.OUT
-        bp(0) # start low
+    # for bp in tt.bidirs:
+    #    bp.mode = Pins.OUT
+    #    bp(0) # start low
+    
+    tt.bidir_mode = [Pins.OUT] * 8
+    tt.bidir_byte = 0
 
     for _i in range(times):
         for v in hello_values:
             tt.bidir_byte = v
+            log.warn(f'Wrote {v} to bidir, waiting {delay_interval_ms}')
             time.sleep_ms(delay_interval_ms)
 
             tt.bidir_byte = 0
@@ -128,8 +187,7 @@ def say_hello(delay_interval_ms:int=100, times:int=1):
 
 
     # reset everything
-    for bp in tt.bidirs:
-        bp.mode = Pins.IN
+    tt.bidir_mode = [Pins.IN] * 8
 
     tt.clock_project_stop()
 

src/ttboard/boot/post.py

@@ -78,7 +78,7 @@ def write_pin(cls, pin:str, value:int):
 
     @classmethod 
     def dotest_buttons_held(cls):
-        cls.write_pin('hk_csb', 1)
+        cls.write_pin('hk_csb', 1) # make sure mux is pointed right way
         if cls.read_pin('rp_projclk') and not cls.read_pin('sdi_nprojectrst'):
             log.info('POST "do test" buttons held')
             return True 

src/ttboard/demoboard.py

@@ -127,6 +127,10 @@ def load_default_project(self):
                 log.warn(f'Default project is unknown "{self.user_config.default_project}"')
 
 
+    @property 
+    def chip_ROM(self):
+        return self.shuttle.chip_ROM
+    
     @property 
     def mode(self):
         return self.pins.mode 

src/ttboard/project_mux.py

@@ -81,6 +81,7 @@ def __init__(self, pins:Pins, shuttle_index_file:str=None):
         self.enabled = None
         self.design_enabled_callback = None
         self.shuttle_index_file = shuttle_index_file
+        self._chip_rom = None
 
     def reset(self):
         log.debug('Resetting project mux')
@@ -126,12 +127,33 @@ def reset_and_clock_mux(self, count:int):
     @property 
     def pins(self) -> Pins:
         return self.p
+    
+    @property 
+    def chip_ROM(self) -> ChipROM:
+        if self._chip_rom is None:
+            self._chip_rom = ChipROM(self)
+        
+        return self._chip_rom
+    
+    
+    @property 
+    def factory_test(self) -> Design:
+        try:
+            shuttle = self.chip_ROM.shuttle
+            if  shuttle == 'tt03p5':
+                return self.tt_um_test
+            return self.tt_um_factory_test
+        
+        except:
+            pass 
+        return None
+            
     @property
     def projects(self):
         if self._design_index is None:
             if self.shuttle_index_file is None:
                 log.debug('No shuttle index file specified, loading rom')
-                rom = ChipROM(self)
+                rom = self.chip_ROM
                 log.info(f'Chip reported by ROM is {rom.shuttle} commit {rom.commit}')
                 shuttle_file = f'/shuttles/{rom.shuttle}.json'
                 self.shuttle_index_file = shuttle_file

src/ttboard/util/shuttle_tests.py

@@ -12,7 +12,7 @@
 import ttboard.logging as logging
 log = logging.getLogger(__name__)
 
-def factory_test_bidirs(tt:DemoBoard, max_idx:int=255, delay_interval_ms:int=1):
+def factory_test_bidirs_03p5(tt:DemoBoard, max_idx:int=255, delay_interval_ms:int=1):
     '''
         Tests project comms and bidir pins by using tt_um_test to reflect 
         bidir to output.
@@ -62,7 +62,31 @@ def factory_test_bidirs(tt:DemoBoard, max_idx:int=255, delay_interval_ms:int=1):
     return None
 
 
-def factory_test_clocking(tt:DemoBoard, max_idx:int=30, delay_interval_ms:int=50):
+def clock_and_compare_output(tt:DemoBoard, max_idx:int, delay_interval_ms:int):
+    err_count = 0
+    for i in range(max_idx):
+        tt.clock_project_once()
+        time.sleep_ms(delay_interval_ms)
+        out_byte = tt.output_byte
+        
+        # give ourselves a little jitter room, in case we're a step
+        # behind as has happened for reasons unclear
+        if out_byte != i and out_byte != (i+1) and out_byte != (i-1):
+            log.warn(f'MISMATCH between expected count {i} and output {out_byte}')
+            err_count += 1
+        else:
+            log.debug(f'Clock count {i}, got {out_byte}')
+    
+    
+    if err_count:
+        err_msg = f'{err_count}/{max_idx} mismatches during counting test'
+        log.error(err_msg)
+        return err_msg 
+    
+    log.info('RP2040 clocking acting pretty nicely')
+    return None
+    
+def factory_test_clocking_03p5(tt:DemoBoard, max_idx:int=30, delay_interval_ms:int=50):
     '''
         Tests project comms, clocking and output pins by using tt_um_test to 
         count clock ticks.
@@ -82,26 +106,22 @@ def factory_test_clocking(tt:DemoBoard, max_idx:int=30, delay_interval_ms:int=50
     tt.input_byte = 1
     tt.clock_project_stop()
     tt.reset_project(False)
+    return clock_and_compare_output(tt, max_idx, delay_interval_ms)
+
+
+def factory_test_clocking_04(tt:DemoBoard, max_idx:int=30, delay_interval_ms:int=50):
 
-    err_count = 0
-    for i in range(max_idx):
-        tt.clock_project_once()
-        time.sleep_ms(delay_interval_ms)
-        out_byte = tt.output_byte
-        
-        # give ourselves a little jitter room, in case we're a step
-        # behind as has happened for reasons unclear
-        if out_byte != i and out_byte != (i+1) and out_byte != (i-1):
-            log.warn(f'MISMATCH between expected count {i} and output {tt.output_byte}')
-            err_count += 1
+    log.info(f'Testing manual clocking up to {max_idx} on {tt}')
 
 
-    if err_count:
-        err_msg = f'{err_count}/{max_idx} mismatches during counting test'
-        log.error(err_msg)
-        return err_msg 
+    # select the project from the shuttle
+    tt.shuttle.tt_um_factory_test.enable()
+    tt.mode = RPMode.ASIC_RP_CONTROL # make sure we're controlling everything
 
-    log.info('RP2040 clocking acting pretty nicely')
-    return None
-
-
+    
+    tt.reset_project(True)
+    tt.input_byte = 1
+    tt.clock_project_stop()
+    tt.reset_project(False)
+    
+    return clock_and_compare_output(tt, max_idx, delay_interval_ms)