reworked pattern generator

python/slsdet/pattern_generator.py

@@ -0,0 +1,215 @@
+from . import Pattern
+from .bits import setbit, clearbit, flipbit
+import textwrap
+
+class PatternGenerator:
+    """
+    Class to generate a pattern for the SLS detector. Intents to as closely as possible 
+    mimic the old pattern generation in the C code.
+    """
+    def __init__(self, verbose = False):
+        self.pattern = Pattern()
+        self.iaddr = 0
+        self.verbose = verbose
+
+    def clear_pattern(self):
+        """
+        Clear the pattern and reset the address to 0.
+        """
+        self.pattern[:] = 0
+        self.iaddr = 0
+
+    def SB(self, *bits):
+        """
+        Set one or multiple bits. Change will take affect with the next PW.
+        """
+        for bit in bits:
+            self.pattern.word[self.iaddr] = setbit(bit, self.pattern.word[self.iaddr])
+        return self.pattern.word[self.iaddr]
+ 
+    def CB(self, *bits):
+        """
+        Clear one or multiple bits. Change will take affect with the next PW.
+        """
+        for bit in bits:
+            self.pattern.word[self.iaddr] = clearbit(bit, self.pattern.word[self.iaddr])
+        return self.pattern.word[self.iaddr]
+    
+    def FB(self, *bits):
+        """
+        Flip one or multiple bits. Change will take affect with the next PW.
+        """
+        for bit in bits:
+            self.pattern.word[self.iaddr] = flipbit(bit, self.pattern.word[self.iaddr])
+        return self.pattern.word[self.iaddr]
+
+    def _pw(self):
+        if self.verbose:
+            print(f'{self.iaddr:#06x} {self.pattern.word[self.iaddr]:#018x}') 
+        
+        # Increment the address before the next word since limits are inclusive
+        self.pattern.limits[1] = self.iaddr
+        self.iaddr += 1
+        self.pattern.word[self.iaddr] = self.pattern.word[self.iaddr - 1]
+
+    def PW(self, x = 1):
+        for _ in range(x):
+            self._pw()
+
+    def CLOCKS(self, bits, repeats = 1, clock_duration = 1):
+        """
+        Generate clock pulses on the specified bits.
+
+        Parameters
+        ----------
+        bit_mask : int
+            Bitmask selecting which clock line(s) to pulse.
+        repeats : int, optional
+            Number of full clock cycles to generate (default 1).
+        half_period : int, optional
+            Hold time for each half of the cycle (default 1).
+        verbose : bool, optional
+            If True, print timing/debug info during the wait (default False).
+        """
+        for _ in range(repeats):
+            self.FB(*bits)
+            self.PW(clock_duration)
+            self.FB(*bits)
+            self.PW(clock_duration)
+
+    def serializer(self, value, ser_in_bit, clk_bit, nbits, msb_first = True, length = 1):
+        """
+        Serialize `value` into a shift register via ser_in_bit/clk_bit.
+
+        Parameters
+        ----------
+        value : int
+            Value to serialize.
+        ser_in_bit : int
+            Control bit corresponding to serial in.
+        clk_bit : int
+            Control bit corresponding to the clock.
+        nbits : int
+            Number of bits of the target register to load.
+        msb_first : bool, optional
+            Push in the MSB first if True (default), else LSB first.
+        length : int, optional
+            Duration of each PW in the pattern (default 1).
+        """
+        bit_order = range(nbits - 1, -1, -1) if msb_first else range(nbits)
+
+        self.CB(ser_in_bit, clk_bit)
+        self.PW(length)  # initial line with clk and serIn low
+
+        for i in bit_order:
+            if value & (1 << i):
+                self.SB(ser_in_bit)
+            else:
+                self.CB(ser_in_bit)
+            self.PW(length)
+            self.SB(clk_bit)
+            self.PW(length)
+            self.CB(clk_bit)
+            self.PW(length)
+
+        self.CB(ser_in_bit, clk_bit)
+        self.PW(length)  # final line with clk and serIn low
+
+
+    #NOT IMPLEMENTED YET
+    #TODO! What should setstop do? Or can we remove it? 
+    #def setstop():
+
+    def setoutput(self, *bits):
+       for bit in bits:
+           self.pattern.ioctrl = setbit(bit, self.pattern.ioctrl)
+    
+    def setinput(self, *bits):
+       for bit in bits:
+           self.pattern.ioctrl = clearbit(bit, self.pattern.ioctrl)
+
+    #TODO! What should setclk do? Or can we remove it?
+    # def setclk(bit):
+    #    self.clkctrl=self.setbit(bit,self.clkctrl)
+
+    #def setclks(self, *args):
+    #    for i in args:
+    #        self.setclk(i)
+
+    def setnloop(self, i, reps):
+        self.pattern.nloop[i] = reps
+
+    def setstartloop(self, i):
+        """
+        Set startloop[i] to the current address.
+        """
+        self.pattern.startloop[i] = self.iaddr
+
+    def setstoploop(self, i):
+        """
+        Set stoploop[i] to the current address.
+        """
+        self.pattern.stoploop[i] = self.iaddr
+
+    def setstart(self):
+        """
+        Set start of pattern to the current address.
+        """
+        self.pattern.limits[0] = self.iaddr
+
+    def setstop(self):
+        """
+        Set stop of pattern to the current address.
+        """
+        self.pattern.limits[1] = self.iaddr
+        
+    def setwaitpoint(self, i):
+        """
+        Set wait[i] to the current address.
+        """
+        self.pattern.wait[i] = self.iaddr
+
+    def setwaittime(self, i, t):
+        """
+        Set waittime[i] to t.
+        """
+        self.pattern.waittime[i] = t
+
+    def setwait(self, i, t):
+        """
+        Set wait[i] to the current address and waittime[i] to t.
+        """
+        self.setwait(i)
+        self.setwaittime(i, t)
+    
+    def __repr__(self):
+        return textwrap.dedent(f"""\
+                            PatternGenerator:
+                                patlimits: {self.pattern.limits}
+                                startloop: {self.pattern.startloop}
+                                stoploop: {self.pattern.stoploop}
+                                nloop: {self.pattern.nloop}
+                                wait: {self.pattern.wait}
+                                waittime: {self.pattern.waittime}""")
+
+    def __str__(self):
+        return self.pattern.str()
+    
+    def export_pattern(self):
+        """
+        Generate the pattern and return it as a Pattern object.
+        """
+        return self.pattern.copy()
+
+    def load_pattern(self, fname):
+        """Load pattern from text file"""
+        iaddr = self.pattern.load(fname)
+
+        # Assume an empty pattern if the first and only word is zero
+        if iaddr == 1 and self.pattern.word[0] == 0:
+            iaddr = 0
+        self.iaddr = iaddr
+
+        # Set (last + 1) word to the last word
+        if iaddr > 0:
+            self.pattern.word[iaddr] = self.pattern.word[iaddr - 1]