working bitwise change extraction

Author: siddacious

register_decoder/decoder.py

@@ -82,18 +82,16 @@ def decode(self, row_num, row):
         ########### Decode #################
         self.decode_bytes(rw, b0, b1)
 
-
-
     def decode_bytes(self, rw, b0, b1):
         if b1 is None:
-            self._single_byte_decode(rw, b0)
+            self.single_byte_decode(rw, b0)
         elif rw == "WRITE":
-            self._decode_set_value(rw, b0, b1)
+            self.decode_set_value(rw, b0, b1)
         else:
             #raise RuntimeError("Multi-byte reads not supported")
             return
 
-    def _single_byte_decode(self, rw, b0):
+    def single_byte_decode(self, rw, b0):
 
         if rw == "WRITE":
             current_register = self.register_map[self.current_bank][b0]
@@ -120,7 +118,7 @@ def _single_byte_decode(self, rw, b0):
             else:
                 raise ("UNEXPECTED READ WITHOUT PRECEDING WRITE")
 
-    def _decode_set_value(self, rw, reg_addr, value_byte):
+    def decode_set_value(self, rw, reg_addr, value_byte):
         current_register = self.register_map[self.current_bank][reg_addr]
         bitfields = self.load_bitfields(current_register)
 
@@ -134,53 +132,75 @@ def _decode_set_value(self, rw, reg_addr, value_byte):
         old_value = current_register['last_read_value']
 
         print("")
-        self._decode_bitfields(current_register, value_byte)
+        self.decode_by_bitfield(current_register, value_byte)
         print("")
 
-    def _decode_bitfields(self, current_register, new_value):
+    def decode_by_bitfield(self, current_register, new_value):
         old_value = current_register['last_read_value']
         bitfields = self.load_bitfields(current_register)
 
+        self.print_bitfield_changes(old_value, new_value, bitfields)
+
+    def print_bitfield_changes(self, old_value, new_value, bitfields):
         unset_bitmask, set_bitmask = self.bitwise_diff(old_value, new_value)
-        for bf_name, bf_mask, bf_shift in bitfields:
-            newp("'%s' =>%s"%(bf_name, format(bf_mask, "#010b")), 3)
+        for bitfield in bitfields:
+            bf_change_str = self.bitfield_change_str(bitfield, unset_bitmask, set_bitmask, new_value)
+            if bf_change_str:
+                print(bf_change_str)
+
+    def bitfield_change_str(self, bitfield, unset_bitmask, set_bitmask, new_value):
+        bf_name, bf_mask, bf_shift = bitfield
+        change_str = None
+        #newp("'%s' =>%s"%(bf_name, format(bf_mask, "#010b")), 3)
+        if bf_mask == 0b1:
+            if (bf_mask & unset_bitmask):
+                change_str = "\t\t%s was unset"%bf_name
+            if (bf_mask & set_bitmask):
+                change_str = "\t\t%s was set"%bf_name
+        else:
             if (bf_mask & unset_bitmask) or (bf_mask & set_bitmask):
-                newp("%s was changed"%bf_name)
-                continue
+                bf_value = (bf_mask & new_value)>>bf_shift
+                change_str = "\t\t%s was changed to %s"%(bf_name, hex(bf_value))
+
+        return change_str
 
-    # in: bitswise diffs? current_reg current value
     def load_bitfields(self, current_register):
         if 'bitfields' not in current_register:
             bitfields = []
-            prev_bitfield = None
+            prev_bitfield_name = None
             for idx in range(8):
                 bitfield_def = current_register[idx]
-                bitfield = self.bitfield_def_to_bitfield(bitfield_def, idx)
-                if prev_bitfield == bitfield or (not bitfield[0]):
+                bitfield_name, bitfield_mask, bitfield_shift = self.bitfield_def_to_bitfield(bitfield_def, idx)
+
+                if not bitfield_name or (prev_bitfield_name == bitfield_name):
                     continue
-                bitfields.append(bitfield)
-                prev_bitfield = bitfield
+                # print("name:", bitfield_name, "mask: %s shift: %d"%(format(bitfield_mask,"#010b"), bitfield_shift))
+                bitfields.append((bitfield_name, bitfield_mask, bitfield_shift))
+                prev_bitfield_name = bitfield_name
             current_register['bitfields'] = bitfields
         return current_register['bitfields']
         bitfields
 
     def bitfield_def_to_bitfield(self, bitfield_def, shift):
         match = re.fullmatch(BITFIELD_REGEX, bitfield_def)
-        # NAMED BITFIELD UPDATED
         if match: #
             bitfield_name, bf_end, bf_start = match.groups()
             bf_end = int(bf_end)
             bf_start = int(bf_start)
-            bitfield_width_exponent = (bf_end-bf_start)+1
-            # (2^2)-1 =>> (2**2)-1 = 4-1 =>> 3 -> 0b11 or 2^3 -1 = 8-1 = 7 -> 0b111
-            bitfield_mask = (2**bitfield_width_exponent)-1
-            print("name:", bitfield_name, "mask: %s idx: %d"%(format(bitfield_mask,"#010b"), shift))
+            bitfield_mask = self.bitfield_range_to_mask(bf_start, bf_end)
         # SINGLE BIT W/ NAME
         else:
             bitfield_name = bitfield_def
             bitfield_mask = (1 << shift)
         return (bitfield_name, bitfield_mask, shift)
 
+    def bitfield_range_to_mask(self, bf_start, bf_end):
+        bitfield_width = (bf_end-bf_start)+1
+        # (2^2)-1 => 4-1 => 3 -> 0b11
+        # (2^3)-1 => 8-1 => 7 -> 0b111
+        bitfield_mask = (2**bitfield_width)-1
+        return bitfield_mask
+
     # https://stackoverflow.com/questions/50705563/proper-way-to-do-bitwise-difference-python-2-7
     # b_minus_a = b & ~a
     # a_minus_b = a & ~b