Integrated cmu_vcd (AntlrVCD) into SPI processing. Note that scalar v…

…alues are

passed as STRINGS to allow for x/X/z/Z values, and the observer (SPI.py here)
is responsible for handling them correctly.

SPI.py

@@ -18,7 +18,7 @@
 """
 
 import sys
-from vcd_reader import VcdEater
+from cmu_vcd import AntlrVCD
 
 class SPI (object):
 
@@ -37,6 +37,12 @@ def __init__(self, CPOL, CPHA, SCLK, CSN, MOSI):
     self.sequences = []
     self.current_sequence = None
 
+  def __coerce_to_int(self, multistate):
+    if multistate is None:
+      return None
+    v = int(multistate)
+    return v
+
   def register(self, vcd):
     self.vcd = vcd    
     vcd.reg_by_name(self.sclk_name, self.obs_sclk)
@@ -50,15 +56,18 @@ def _sample_mosi(self):
       self.current_sequence.append(self.mosi_state)
 
 
-  def obs_sclk(self, now, id, name, old_value, new_value, first):    
-    #print "%-6d %-8s/ %-30s: %10s -> %10s" % (now, id,name,old_value,new_value)
+  def obs_sclk(self, now, id, name, old_value, new_value, first):
+    old_value = self.__coerce_to_int(old_value)
+    new_value = self.__coerce_to_int(new_value)
+    #print "%-6d %-8s/ %-30s: %10s -> %10s" % (now, id,name,repr(old_value),repr(new_value))
     self.sclk_state = new_value
     #print "CPOL=%1d,CPHA=%d" % (self.CPOL, self.CPHA)
-
-
+
     rising = (old_value == 0 and new_value == 1)
     falling = (old_value == 1 and new_value == 0)
 
+    #print rising, falling
+
     if   (self.CPOL==0 and self.CPHA == 0 and rising):
       self._sample_mosi()
     elif (self.CPOL==0 and self.CPHA == 1 and falling):
@@ -71,6 +80,9 @@ def obs_sclk(self, now, id, name, old_value, new_value, first):
 
 
   def obs_csn(self, now, id, name, old_value, new_value, first):
+    old_value = self.__coerce_to_int(old_value)
+    new_value = self.__coerce_to_int(new_value)
+
     self.csn_state = new_value
     rising = (old_value == 0 and new_value == 1)
     falling = (old_value == 1 and new_value == 0)
@@ -100,6 +112,9 @@ def obs_csn(self, now, id, name, old_value, new_value, first):
 
 
   def obs_mosi(self, now, id, name, old_value, new_value, first):
+    old_value = self.__coerce_to_int(old_value)
+    new_value = self.__coerce_to_int(new_value)
+
     self.mosi_state = new_value
     rising = (old_value == 0 and new_value == 1)
     falling = (old_value == 1 and new_value == 0)
@@ -118,18 +133,16 @@ def get_mosi(self):
 def main(args):
 
   vcdfile = "./foo.vcd"
-
-
-  foo = VcdEater(vcdfile)
+  foo = AntlrVCD(file(vcdfile))
 
   spi = SPI(CPOL=0, CPHA=0,
-            SCLK="revisit_ad9510./ad9510_hw/old_booter/clockEngine/SCLK",
-            CSN="revisit_ad9510./ad9510_hw/old_booter/clockEngine/CSN",
-            MOSI="revisit_ad9510./ad9510_hw/old_booter/clockEngine/SDIO")
-  spi.register(foo.vcd)
+            SCLK="/ad9510_hw/old_booter/clockEngine/SCLK",
+            CSN="/ad9510_hw/old_booter/clockEngine/CSN",
+            MOSI="/ad9510_hw/old_booter/clockEngine/SDIO")
+  spi.register(foo)
 
 
-  foo.process()
+  foo.go()
   spi.end()
 
   print spi.get_mosi()

VCDSimulation.g

@@ -56,7 +56,7 @@ sim_time [context]
     ;
 
 value_change [context]
-    : ^(SCALAR_CHANGE id=IDENTIFIER v=.)
+    : ^(SCALAR_CHANGE id=IDENTIFIER v=SCALAR_VALUE)
         {
             context.scalar_change($id.text, $v.text)
         }

ValueChangeDump.g

@@ -53,6 +53,7 @@ tokens {
     TIME;
     SCALAR_CHANGE;
     VECTOR_CHANGE;
+    SCALAR_VALUE;
 }
 
 /* Parser rules */
@@ -180,7 +181,17 @@ scalar_value_change
 	;
 
 // Throw an error if DEC_NUM is mult-digit
-value 	:	DEC_NUM | 'X' | 'x' | 'Z' | 'z'
+value 	
+    : DEC_NUM 
+        -> ^(SCALAR_VALUE[$DEC_NUM.text])
+    | 'X' 
+        -> ^(SCALAR_VALUE['X'])
+    | 'x' 
+        -> ^(SCALAR_VALUE['x'])
+    | 'Z' 
+        -> ^(SCALAR_VALUE['Z'])
+    | 'z'
+        -> ^(SCALAR_VALUE['z'])      
 	;
 
 vector_value_change

ad9510spi.py

@@ -21,9 +21,11 @@
 """
 
 import sys
-from vcd_reader import VcdEater
+#from vcd_reader import VcdEater
+from cmu_vcd import AntlrVCD
 from SPI import SPI
 
+
 class ad9510spi  (object):
 
    def __init__(self):
@@ -133,19 +135,17 @@ def run(self, data):
 
 
 def main(argv):
-  vcdfile = "./foo.vcd"
-
-
-  foo = VcdEater(vcdfile)
+  vcdfile = "./foo.vcd"  
+  #foo = VcdEater(vcdfile)
+  foo = AntlrVCD(file(vcdfile))
 
   spi = SPI(CPOL=0, CPHA=1,
-            SCLK="revisit_ad9510./ad9510_hw/old_booter/clockEngine/SCLK",
-            CSN="revisit_ad9510./ad9510_hw/old_booter/clockEngine/CSN",
-            MOSI="revisit_ad9510./ad9510_hw/old_booter/clockEngine/SDIO")
-  spi.register(foo.vcd)
-
-
-  foo.process()
+            SCLK="/ad9510_hw/old_booter/clockEngine/SCLK",
+            CSN="/ad9510_hw/old_booter/clockEngine/CSN",
+            MOSI="/ad9510_hw/old_booter/clockEngine/SDIO")
+  spi.register(foo)
+
+  foo.go()
   spi.end()
 
   print '\n'.join(spi.get_mosi())

cmu_vcd.py

@@ -10,30 +10,45 @@
 
 class VCDContext:
 
-    def __init__(self, dict):
+    def __init__(self, dict, verbose_changes=False):
         self.defns = dict
         self.now = None
+        self.verbose_changes = verbose_changes
         self.values = {}
+        self.ref_to_idcode = {}
+        self.watchers = {}
         for id_code in self.defns.keys():
             self.values[id_code] = None
+            self.watchers[id_code] = []
+            ref = self.defns[id_code]['ref']
+            self.ref_to_idcode[ref] = id_code
+
 
     def note_time(self, time):
         self.now = time
 
-    def scalar_change(self, id_code, newvalue):
+    def __common_change(self, id_code, new_value):
         varinfo = self.defns[id_code]
         ref = varinfo['ref']
         old_value = self.values[id_code]
-        self.values[id_code]=newvalue
-        print "%7d Scalar: %s:  %s -> %s\t%s" % (self.now, id_code, old_value, newvalue,ref)
-
-    def vector_change(self, id_code, newvalue):
-        varinfo = self.defns[id_code]
-        ref = varinfo['ref']
+        if ((old_value is None) or (new_value != old_value)):
+            self.values[id_code]=new_value
+            for obs in self.watchers[id_code]:
+                obs(self.now,id_code,ref,old_value, new_value, (old_value is None))
+        return old_value
+
+    def scalar_change(self, id_code, newvalue):        
+        old_value = self.__common_change(id_code,newvalue)
+        if self.verbose_changes:
+            ref = self.defns[id_code]['ref']
+            print "%7d Scalar: %s:  %s -> %s\t%s" % (self.now, id_code, old_value, newvalue,ref)
+
+    def vector_change(self, id_code, newvalue):        
         extended_value = self.__extend_vec(id_code,newvalue)
-        old_value = self.values[id_code]
-        self.values[id_code]=extended_value
-        print "%7d Vector: %s: %s -> %s\t%s" % (self.now, id_code, old_value, extended_value, ref)
+        old_value = self.__common_change(id_code,extended_value)
+        if self.verbose_changes:
+            ref = self.defns[id_code]['ref']
+            print "%7d Vector: %s: %s -> %s\t%s" % (self.now, id_code, old_value, extended_value, ref)
 
         ##print"\t %s --> %s" % (newvalue, extended_value)
 
@@ -47,8 +62,11 @@ def __extend_vec(self, id_code, value_str):
                          else value_str[0])*extend_digits + value_str
         return value_str
 
+    def reg_by_name(self, ref, observer):
+        id_code = self.ref_to_idcode[ref]
+        self.watchers[id_code].append(observer)
 
-
+        
 def antlr_setup(file):
     char_stream = antlr3.ANTLRInputStream(file)
     lexer = ValueChangeDumpLexer(char_stream)        
@@ -69,8 +87,7 @@ def process_header(parser, tokenStream):
     result = interpret.vcd_header()
     return result
 
-def process_body(parser, tokenStream, dict):
-    context = VCDContext(dict)
+def process_body(parser, tokenStream, context):
     while True:
         r = parser.simulation_command()
         # this is the root of the AST
@@ -90,13 +107,32 @@ def process_body(parser, tokenStream, dict):
         result = sim.simulation_command(context)
         #print result
 
-
+class AntlrVCD:
+
+    "A very thin wrapper for the parsing functions in this file"
+
+    def __init__(self, file):
+        self.parser, self.tokens = antlr_setup(file)
+        self.dict = process_header(self.parser, self.tokens)
+        self.context = VCDContext(self.dict)
+
+    def reg_by_name(self, name, observer):
+        self.context.reg_by_name(name, observer)
+
+    def go(self):
+        process_body(self.parser, self.tokens, self.context)
+
+    def getContext(self):
+        return self.context
 
 def main(args):
-    parser, tokens = antlr_setup(sys.stdin)
-    dict = process_header(parser, tokens)
-    print dict
-    process_body(parser, tokens, dict)
+
+    foo = AntlrVCD(sys.stdin)
+    foo.go()
+    # parser, tokens = antlr_setup(sys.stdin)
+    # dict = process_header(parser, tokens)
+    # print dict
+    # process_body(parser, tokens, dict)
     return 0
 
 if __name__ == '__main__':