ntf905: Add/rename required self.reset() method.

[libsigrokdecode.git] / decoders / amulet_ascii / pd.py

diff --git a/decoders/amulet_ascii/pd.py b/decoders/amulet_ascii/pd.py
index bd8c4d0e3729a84635853b5c7ad7136047e05a90..719532344727f98e566aeba51347644395b60907 100644 (file)
--- a/decoders/amulet_ascii/pd.py
+++ b/decoders/amulet_ascii/pd.py
@@ -19,19 +19,15 @@
 
 import sigrokdecode as srd
 from math import ceil
+from common.srdhelper import SrdIntEnum
 from .lists import *
 
 L = len(cmds)
 RX = 0
 TX = 1
-rxtx_channels = ('RX', 'TX')
 
-# Don't forget to keep this in sync with 'cmds' is lists.py.
-class Ann:
-    PAGE, GBV, GWV, GSV, GLV, GRPC, SBV, SWV, SSV, RPC, LINE, RECT, FRECT, \
-    PIXEL, GBVA, GWVA, SBVA, GBVR, GWVR, GSVR, GLVR, GRPCR, SBVR, SWVR, SSVR, \
-    RPCR, LINER, RECTR, FRECTR, PIXELR, GBVAR, GWVAR, SBVAR, ACK, NACK, SWVA, \
-    SWVAR, GCV, GCVR, SCV, SCVR, BIT, FIELD, WARN = range(L + 3)
+Ann = SrdIntEnum.from_list('Ann',
+    [c[0] for c in cmds.values()] + ['BIT', 'FIELD', 'WARN'])
 
 def cmd_annotation_classes():
     return tuple([tuple([cmd[0].lower(), cmd[1]]) for cmd in cmds.values()])
@@ -54,14 +50,14 @@ class Decoder(srd.Decoder):
     annotation_rows = (
         ('bits', 'Bits', (L + 0,)),
         ('fields', 'Fields', (L + 1,)),
-        ('commands', 'Commands', tuple(range(len(cmds)))),
+        ('commands', 'Commands', tuple(range(L))),
         ('warnings', 'Warnings', (L + 2,)),
     )
     options = (
         {'id': 'ms_chan', 'desc': 'Master -> slave channel',
-            'default': rxtx_channels[0], 'values': rxtx_channels},
+            'default': 'RX', 'values': ('RX', 'TX')},
         {'id': 'sm_chan', 'desc': 'Slave -> master channel',
-            'default': rxtx_channels[1], 'values': rxtx_channels},
+            'default': 'TX', 'values': ('RX', 'TX')},
     )
 
     def __init__(self):
@@ -105,14 +101,14 @@ class Decoder(srd.Decoder):
         if self.cmdstate == 2:
             self.ss_field = self.ss
             self.addr = chr(pdata)
-            self.putx([Ann.BIT, ['Address high nibble: %c' % (pdata),
-                 'Addr high 0x%c' % (pdata), 'Addr h 0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address high nibble: %c' % pdata,
+                 'Addr high 0x%c' % pdata, 'Addr h 0x%c' % pdata]])
         elif self.cmdstate == 3:
             self.es_field = self.es
             self.addr += chr(pdata)
             self.addr = int(self.addr, 16)
-            self.putx([Ann.BIT, ['Address low nibble: %c' % (pdata),
-                 'Addr low 0x%c' % (pdata), 'Addr l 0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address low nibble: %c' % pdata,
+                 'Addr low 0x%c' % pdata, 'Addr l 0x%c' % pdata]])
             self.putf([Ann.FIELD, ['Address: 0x%02X' % self.addr,
                 'Addr: 0x%02X' % self.addr, '0x%02X' % self.addr]])
 
@@ -151,13 +147,13 @@ class Decoder(srd.Decoder):
             # Null terminated string ends.
             self.es_field = self.es
             self.putx([Ann.BIT, ['NULL']])
-            self.putf([Ann.FIELD, ['Value: %s' % (self.value),
-                'Val: %s' % (self.value), '%s' % (self.value)]])
+            self.putf([Ann.FIELD, ['Value: %s' % self.value,
+                'Val: %s' % self.value, '%s' % self.value]])
             self.emit_cmd_end([ann_class, self.cmd_ann_list()])
             return
         if self.cmdstate > 3:
             self.value += chr(pdata)
-            self.putx([Ann.BIT, ['%c' % (pdata)]])
+            self.putx([Ann.BIT, ['%c' % pdata]])
         self.cmdstate += 1
 
     # Command handlers
@@ -187,8 +183,8 @@ class Decoder(srd.Decoder):
                 self.putf(Ann.WARN, ['Soft reset', 'Reset'])
             else:
                 page = chr(self.page[0]) + chr(self.page[1])
-                self.putf(Ann.FIELD, ['Page index: 0x%s' % (page),
-                                      'Page: 0x%s' % (page), '0x%s' % (page)])
+                self.putf(Ann.FIELD, ['Page index: 0x%s' % page,
+                                      'Page: 0x%s' % page, '0x%s' % page])
         elif self.cmdstate == 5:
             self.checksum += pdata
             if (self.checksum & 0xFF) != 0:
@@ -228,7 +224,7 @@ class Decoder(srd.Decoder):
         elif self.cmdstate == 3:
             self.flags += int(chr(pdata), 16)
             self.es_field = self.es
-            self.putf([Ann.FIELD, ['RPC flag: 0x%02X' % (self.flags)]])
+            self.putf([Ann.FIELD, ['RPC flag: 0x%02X' % self.flags]])
             self.emit_cmd_end([Ann.GRPC, self.cmd_ann_list()])
 
     # Get byte value array
@@ -289,13 +285,13 @@ class Decoder(srd.Decoder):
         if self.cmdstate == 2:
             self.addr = int(chr(pdata), 16) << 4
             self.ss_field = self.ss
-            self.putx([Ann.BIT, ['Address high nibble: %c' % (pdata),
-                 'Addr high 0x%c' % (pdata), '0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address high nibble: %c' % pdata,
+                 'Addr high 0x%c' % pdata, '0x%c' % pdata]])
         elif self.cmdstate == 3:
             self.addr += int(chr(pdata), 16)
             self.es_field = self.ss
-            self.putx([Ann.BIT, ['Address low nibble: %c' % (pdata),
-                 'Addr low 0x%c' % (pdata), '0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address low nibble: %c' % pdata,
+                 'Addr low 0x%c' % pdata, '0x%c' % pdata]])
             self.putf([Ann.FIELD, ['Address: 0x%02X' % self.addr,
                 'Addr: 0x%02X' % self.addr, '0x%02X' % self.addr]])
         elif stage == 2:
@@ -307,8 +303,8 @@ class Decoder(srd.Decoder):
         else:
             self.value += int(chr(pdata), 16)
             self.es_field = self.es
-            self.putf([Ann.FIELD, ['Value 0x%02X' % (self.value),
-                                   '0x%02X' % (self.value)]])
+            self.putf([Ann.FIELD, ['Value 0x%02X' % self.value,
+                                   '0x%02X' % self.value]])
         self.cmdstate += 1
 
     # Set word value array
@@ -317,13 +313,13 @@ class Decoder(srd.Decoder):
         if self.cmdstate == 2:
             self.addr = int(chr(pdata), 16) << 4
             self.ss_field = self.ss
-            self.putx([Ann.BIT, ['Address high nibble: %c' % (pdata),
-                  'Addr high 0x%c' % (pdata), '0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address high nibble: %c' % pdata,
+                  'Addr high 0x%c' % pdata, '0x%c' % pdata]])
         elif self.cmdstate == 3:
             self.addr += int(chr(pdata), 16)
             self.es_field = self.ss
-            self.putx([Ann.BIT, ['Address low nibble: %c' % (pdata),
-                 'Addr low 0x%c' % (pdata), '0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address low nibble: %c' % pdata,
+                 'Addr low 0x%c' % pdata, '0x%c' % pdata]])
             self.putf([Ann.FIELD, ['Address: 0x%02X' % self.addr,
                  'Addr: 0x%02X' % self.addr, '0x%02X' % self.addr]])
             self.value = 0
@@ -337,8 +333,8 @@ class Decoder(srd.Decoder):
                 self.ss_field = self.ss
             if nibble == 3:
                 self.es_field = self.es
-                self.putf([Ann.FIELD, ['Value 0x%04X' % (self.value),
-                                       '0x%04X' % (self.value)]])
+                self.putf([Ann.FIELD, ['Value 0x%04X' % self.value,
+                                       '0x%04X' % self.value]])
                 self.cmdstate += 1
 
     # Set color variable
@@ -370,8 +366,8 @@ class Decoder(srd.Decoder):
                 self.ss_field = self.ss
             elif nibble == 3:
                 self.es_field = self.es
-                self.putf([Ann.FIELD, ['Coordinate 0x%04X' % (self.coords[i])],
-                                      ['0x%04X' % (self.coords[i])]])
+                self.putf([Ann.FIELD, ['Coordinate 0x%04X' % self.coords[i]],
+                                      ['0x%04X' % self.coords[i]]])
 
     # TODO: There are actually two protocol revisions for drawing.
     # Both use 4 bytes for 16bit x and y pairs for start and end.
@@ -420,13 +416,13 @@ class Decoder(srd.Decoder):
         if self.cmdstate == 4:
             self.ss_field = self.ss
             self.value = int(chr(pdata), 16) << 4
-            self.putx([Ann.BIT, ['High nibble 0x%s' % (pdata), '0x%s' % (pdata)]])
+            self.putx([Ann.BIT, ['High nibble 0x%s' % pdata, '0x%s' % pdata]])
         elif self.cmdstate == 5:
             self.value += int(chr(pdata), 16)
-            self.putx([Ann.BIT, ['Low nibble 0x%s' % (pdata), '0x%s' % (pdata)]])
+            self.putx([Ann.BIT, ['Low nibble 0x%s' % pdata, '0x%s' % pdata]])
             self.es_field = self.es
-            self.putf([Ann.FIELD, ['Value: 0x%02X' % (self.value),
-                                   '0x%02X' % (self.value)]])
+            self.putf([Ann.FIELD, ['Value: 0x%02X' % self.value,
+                                   '0x%02X' % self.value]])
             self.emit_cmd_end([Ann.GBVR, self.cmd_ann_list()])
         self.cmdstate += 1
 
@@ -438,10 +434,10 @@ class Decoder(srd.Decoder):
                 self.value = 0
                 self.ss_field = self.ss
             self.value += int(chr(pdata), 16) << 12 - (4 * nibble)
-            self.putx([Ann.BIT, ['0x%s' % (pdata)]])
+            self.putx([Ann.BIT, ['0x%s' % pdata]])
             if nibble == 3:
-                self.putf([Ann.FIELD, ['Value: 0x%04x' % (self.value),
-                                       '0x%04X' % (self.value)]])
+                self.putf([Ann.FIELD, ['Value: 0x%04x' % self.value,
+                                       '0x%04X' % self.value]])
                 self.es_cmd = self.ss
                 self.emit_cmd_end([Ann.GWVR, self.cmd_ann_list()])
         self.cmdstate += 1
@@ -462,12 +458,12 @@ class Decoder(srd.Decoder):
                     return
                 self.value = int(chr(pdata), 16) << 4
                 self.ss_field = self.ss
-                self.putx([Ann.BIT, ['0x%s' % (pdata)]])
+                self.putx([Ann.BIT, ['0x%s' % pdata]])
             if nibble == 2:
                 self.value += int(chr(pdata), 16)
                 self.es_field = self.es
-                self.putx([Ann.BIT, ['0x%s' % (pdata)]])
-                self.putf([Ann.FIELD, ['0x%02X' % (self.value)]])
+                self.putx([Ann.BIT, ['0x%s' % pdata]])
+                self.putf([Ann.FIELD, ['0x%02X' % self.value]])
         self.cmdstate += 1
 
     def handle_sbvr(self, pdata):
@@ -546,13 +542,13 @@ class Decoder(srd.Decoder):
         if self.cmdstate == 2:
             self.addr = int(chr(pdata), 16) << 4
             self.ss_field = self.ss
-            self.putx([Ann.BIT, ['Address high nibble: %c' % (pdata),
-                 'Addr high 0x%c' % (pdata), '0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address high nibble: %c' % pdata,
+                 'Addr high 0x%c' % pdata, '0x%c' % pdata]])
         elif self.cmdstate == 3:
             self.addr += int(chr(pdata), 16)
             self.es_field = self.ss
-            self.putx([Ann.BIT, ['Address low nibble: %c' % (pdata),
-                 'Addr low 0x%c' % (pdata), '0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address low nibble: %c' % pdata,
+                 'Addr low 0x%c' % pdata, '0x%c' % pdata]])
             self.putf([Ann.FIELD, ['Address: 0x%02X' % self.addr,
                 'Addr: 0x%02X' % self.addr, '0x%02X' % self.addr]])
         elif stage == 2:
@@ -564,8 +560,8 @@ class Decoder(srd.Decoder):
         else:
             self.value += int(chr(pdata), 16)
             self.es_field = self.es
-            self.putf([Ann.FIELD, ['Value 0x%02X' % (self.value),
-                                   '0x%02X' % (self.value)]])
+            self.putf([Ann.FIELD, ['Value 0x%02X' % self.value,
+                                   '0x%02X' % self.value]])
         self.cmdstate += 1
 
     def handle_gwvar(self, pdata):
@@ -573,13 +569,13 @@ class Decoder(srd.Decoder):
         if self.cmdstate == 2:
             self.addr = int(chr(pdata), 16) << 4
             self.ss_field = self.ss
-            self.putx([Ann.BIT, ['Address high nibble: %c' % (pdata),
-                  'Addr high 0x%c' % (pdata), '0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address high nibble: %c' % pdata,
+                  'Addr high 0x%c' % pdata, '0x%c' % pdata]])
         elif self.cmdstate == 3:
             self.addr += int(chr(pdata), 16)
             self.es_field = self.ss
-            self.putx([Ann.BIT, ['Address low nibble: %c' % (pdata),
-                 'Addr low 0x%c' % (pdata), '0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address low nibble: %c' % pdata,
+                 'Addr low 0x%c' % pdata, '0x%c' % pdata]])
             self.putf([Ann.FIELD, ['Address: 0x%02X' % self.addr,
                  'Addr: 0x%02X' % self.addr, '0x%02X' % self.addr]])
             self.value = 0
@@ -593,8 +589,8 @@ class Decoder(srd.Decoder):
                 self.ss_field = self.ss
             if nibble == 3:
                 self.es_field = self.es
-                self.putf([Ann.FIELD, ['Value 0x%04X' % (self.value),
-                                       '0x%04X' % (self.value)]])
+                self.putf([Ann.FIELD, ['Value 0x%04X' % self.value,
+                                       '0x%04X' % self.value]])
                 self.cmdstate += 1
 
     # Get byte variable array reply
@@ -603,13 +599,13 @@ class Decoder(srd.Decoder):
         if self.cmdstate == 2:
             self.addr = int(chr(pdata), 16) << 4
             self.ss_field = self.ss
-            self.putx([Ann.BIT, ['Address high nibble: %c' % (pdata),
-                 'Addr high 0x%c' % (pdata), '0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address high nibble: %c' % pdata,
+                 'Addr high 0x%c' % pdata, '0x%c' % pdata]])
         elif self.cmdstate == 3:
             self.addr += int(chr(pdata), 16)
             self.es_field = self.ss
-            self.putx([Ann.BIT, ['Address low nibble: %c' % (pdata),
-                 'Addr low 0x%c' % (pdata), '0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address low nibble: %c' % pdata,
+                 'Addr low 0x%c' % pdata, '0x%c' % pdata]])
             self.putf([Ann.FIELD, ['Address: 0x%02X' % self.addr,
                 'Addr: 0x%02X' % self.addr, '0x%02X' % self.addr]])
         elif stage == 2:
@@ -621,8 +617,8 @@ class Decoder(srd.Decoder):
         else:
             self.value += int(chr(pdata), 16)
             self.es_field = self.es
-            self.putf([Ann.FIELD, ['Value 0x%02X' % (self.value),
-                                   '0x%02X' % (self.value)]])
+            self.putf([Ann.FIELD, ['Value 0x%02X' % self.value,
+                                   '0x%02X' % self.value]])
         self.cmdstate += 1
 
     # Set word variable array reply
@@ -631,13 +627,13 @@ class Decoder(srd.Decoder):
         if self.cmdstate == 2:
             self.addr = int(chr(pdata), 16) << 4
             self.ss_field = self.ss
-            self.putx([Ann.BIT, ['Address high nibble: %c' % (pdata),
-                  'Addr high 0x%c' % (pdata), '0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address high nibble: %c' % pdata,
+                  'Addr high 0x%c' % pdata, '0x%c' % pdata]])
         elif self.cmdstate == 3:
             self.addr += int(chr(pdata), 16)
             self.es_field = self.ss
-            self.putx([Ann.BIT, ['Address low nibble: %c' % (pdata),
-                 'Addr low 0x%c' % (pdata), '0x%c' % (pdata)]])
+            self.putx([Ann.BIT, ['Address low nibble: %c' % pdata,
+                 'Addr low 0x%c' % pdata, '0x%c' % pdata]])
             self.putf([Ann.FIELD, ['Address: 0x%02X' % self.addr,
                  'Addr: 0x%02X' % self.addr, '0x%02X' % self.addr]])
             self.value = 0
@@ -651,8 +647,8 @@ class Decoder(srd.Decoder):
                 self.ss_field = self.ss
             if nibble == 3:
                 self.es_field = self.es
-                self.putf([Ann.FIELD, ['Value 0x%04X' % (self.value),
-                                       '0x%04X' % (self.value)]])
+                self.putf([Ann.FIELD, ['Value 0x%04X' % self.value,
+                                       '0x%04X' % self.value]])
                 self.cmdstate += 1
 
     def handle_gcvr(self, pdata):
@@ -693,7 +689,7 @@ class Decoder(srd.Decoder):
                 self.state = pdata[0]
                 self.emit_cmd_byte()
                 self.cmdstate = 1
-            if (self.state is None):
+            if self.state is None:
                 self.state = pdata[0]
                 self.emit_cmd_byte()
                 self.cmdstate = 1