################################################################################
#
# Copyright 2012-2013, Sinclair R.F., Inc.
#
################################################################################

from ssbccPeripheral import SSBCCperipheral
from ssbccUtil import SSBCCException;

class PWM_8bit(SSBCCperipheral):
  """
  Pulse Width Modulator (PWM) with 8-bit control.\n
  This peripheral creates one or more PWMs.  The PWM is designed so that it is
  allways off when the control is 0 and it is always on when the control is
  0xFF.\n
  Usage:
    PERIPHERAL PWM_8bit   outport=O_name \\
                          outsignal=o_name \\
                          ratemethod={clk/rate|count} \\
                          [invert|noinvert] \\
                          [instances=n] \\
                          [norunt]\n
  Where:
    outport=O_name
      specifies the symbol used by the outport instruction to write a byte to
      the peripheral
      Note:  The name must start with "O_".
    outsignal=o_name
      specifies the name of the output signal
      Note:  The name must start with "o_".
    ratemethod={clk/rate|count}
      specifies the frequency at which the PWM counter is incremented
      Example:  ratemethod=count means to increment the PWM counter once every
                "count" clock cycles.
    invert|noinvert
      optional configuration command to invert or to not invert the PWM output
      Default:  don't invert the output (i.e., a command of 0 means the output is
                always low)
      Note:  "invert" should be used when pulling the external signal to ground
             means the device is "on"
    instances=n
      specifies the number of PWMs for the peripheral
      Default:  The default is one PWM control and output.
    norunt
      optionally add logic to ensure "runt" pulses are not generated by
      incorporating new PWM commands at the start of the counting cycle
      Default:  "runt" pulses are allowed.\n
  The following OUTPORT is provided by this peripheral when instances=1:
    O_name
      output the next 8-bit value to transmit or to queue for transmission\n
  The following OUTPORT is provided by this peripheral when instances=n is larger
  than 1:
    O_name_0, O_name_1, ..., O_name_{n-1}
      output the next 8-bit value to transmit on the specified PWM
      Note:  O_name_i = ${O_name_0+i) where 0<=i<n.
      Note:  The PWM for o_name[i] is controlled by the outport O_name_i
      Example:  If "instances=3" is specified, then the following outports are
                provided:  O_name_0, O_name_1, and O_name_2.  The assembly
                sequence "5 .outport(O_name_1)" will change the PWM control for
                the second of these three PWMs to 5.\n
  Note:  The PWM counter is an 8-bit count that ranges from 1 to 255.  Each PWM
         output is '1' when this count is less than or equal to the commanded
         count.  The signal for a commanded count of 0 will never be on while
         the signal for a commanded count of 255 will always be on.\n
  Example:  Control the intensity of an LED through a PWM.  The LED must flicker
            at a frequency greater than about 30 Hz in order for the flickering
            to not be visible by human eyes.  The LED is turned on when the
            signal to the LED is at ground.  The processor clock frequency is
            provided by the parameter G_CLK_FREQ_HZ.\n
    Within the processor architecture file include the configuration command:\n
    PERIPHERAL PWM_8bit   outport=O_PWM_LED                     \\
                          outsignal=o_led                       \\
                          ratemethod=G_CLK_FREQ_HZ/(30*255)     \\
                          invert\n
    Use the following assembly to set the LED to about 1/4 intensity:\n
    0x40 .outport(O_PWM_LED)\n
  Example:  Similarly to obove, but for the three controls of a tri-color LED:\n
    Within the processor architecture file include the configuration command:\n
    PERIPHERAL PWM_8bit   outport=O_PWM_LED                     \\
                          outsignal=o_led                       \\
                          ratemethod=G_CLK_FREQ_HZ/(30*255)     \\
                          invert                                \\
                          instances=3\n
    Use the following assembly to set the LED intensities to 0x10 0x20 and 0x55:\n
    0x10 .outport(O_PWM_LED_0)
    0x20 .outport(O_PWM_LED_1)
    0x55 .outport(O_PWM_LED_2)\n
    or use the following function to send the three values on the stack where
    the top of the stack is 0x55 0x20 0x10 (this isn't less code, but it
    illustrates how to increment the outport index):\n
    ; ( u_pwm_led_2 u_pwm_led_1 u_pwm_led_0 - )
    .function set_pwm_led
      O_PWM_LED_0 ${3-1} :loop r> swap over outport drop 1+ r> .jumpc(loop,1-) drop
    .return(drop)
  """

  def __init__(self,peripheralFile,config,param_list,loc):
    # Use the externally provided file name for the peripheral
    self.peripheralFile = peripheralFile;
    # Get the parameters.
    for param_tuple in param_list:
      param = param_tuple[0];
      param_arg = param_tuple[1];
      if param == 'outport':
        self.AddAttr(config,param,param_arg,r'O_\w+$',loc);
      elif param == 'outsignal':
        self.AddAttr(config,param,param_arg,r'o_\w+$',loc);
      elif param == 'ratemethod':
        self.ProcessRateMethod(config,param_arg,loc);
      elif param == 'invert':
        self.AddAttr(config,param,param_arg,None,loc);
      elif param == 'noinvert':
        self.AddAttr(config,param,param_arg,None,loc);
      elif param == 'instances':
        self.AddAttr(config,param,param_arg,r'[1-9]\d*$',loc,int);
      elif param == 'norunt':
        self.AddAttr(config,param,param_arg,None,loc);
      else:
        raise SSBCCException('Unrecognized parameter at %s: %s' % (loc,param,));
    # Ensure the required parameters are provided.
    if not hasattr(self,'instances'):
      self.instances = 1;
    # Set optional parameters.
    if not hasattr(self,'invert') and not hasattr(self,'noinvert'):
      self.noinvert = True;
    if not hasattr(self,'norunt'):
      self.norunt = False;
    # Ensure parameters do not conflict.
    if hasattr(self,'invert') and hasattr(self,'noinvert'):
      raise SSBCCException('Only one of "invert" or "noinvert" can be specified at %s' % loc);
    # Use only one of mutually exclusive configuration settings.
    if hasattr(self,'noinvert'):
      self.invert = False;
    # Add the I/O port, internal signals, and the INPORT and OUTPORT symbols for this peripheral.
    config.AddIO(self.outsignal,self.instances,'output',loc);
    self.ix_outport_0 = config.NOutports();
    if self.instances == 1:
      tmpOutport = self.outport;
      config.AddOutport((tmpOutport,False,),loc);
    else:
      for ixOutPort in range(self.instances):
        tmpOutport = '%s_%d' % (self.outport,ixOutPort,);
        config.AddOutport((tmpOutport,False,),loc);
    # Add the 'clog2' function to the processor (if required).
    config.functions['clog2'] = True;

  def ProcessRateMethod(self,config,param_arg,loc):
    if hasattr(self,'ratemethod'):
      raise SSBCCException('ratemethod repeated at %s' % loc);
    if param_arg.find('/') < 0:
      if self.IsIntExpr(param_arg):
        self.ratemethod = str(self.ParseIntExpr(param_arg));
      elif self.IsParameter(config,param_arg):
        self.ratemethod = param_arg;
      else:
        raise SSBCCException('ratemethod with no "/" must be an integer or a previously declared parameter at %s' % loc);
    else:
      baudarg = re.findall('([^/]+)',param_arg);
      if len(baudarg) == 2:
        if not self.IsIntExpr(baudarg[0]) and not self.IsParameter(config,baudarg[0]):
          raise SSBCCException('Numerator in ratemethod must be an integer or a previously declared parameter at %s' % loc);
        if not self.IsIntExpr(baudarg[1]) and not self.IsParameter(config,baudarg[1]):
          raise SSBCCException('Denominator in ratemethod must be an integer or a previously declared parameter at %s' % loc);
        for ix in range(2):
          if self.IsIntExpr(baudarg[ix]):
            baudarg[ix] = str(self.ParseIntExpr(baudarg[ix]));
        self.ratemethod = '('+baudarg[0]+'+'+baudarg[1]+'/2)/'+baudarg[1];
    if not hasattr(self,'ratemethod'):
      raise SSBCCException('Bad ratemethod value at %s:  "%s"' % (loc,param_arg,));

  def GenVerilog(self,fp,config):
    body = self.LoadCore(self.peripheralFile,'.v');
    output_on = "1'b1";
    output_off = "1'b0";
    if self.invert:
      output_on = "1'b0";
      output_off = "1'b1";
    norunt = "1'b0";
    if self.norunt:
      norunt = "1'b1";
    for subs in (
                  (r'\bL__',            'L__@NAME@__',),
                  (r'\bgen__',          'gen__@NAME@__',),
                  (r'\bs__',            's__@NAME@__',),
                  (r'\bix\b',           'ix__@NAME@',),
                  (r'@COUNT@',          self.ratemethod,),
                  (r'@INSTANCES@',      str(self.instances),),
                  (r'@IX_OUTPORT_0@',   str(self.ix_outport_0),),
                  (r'@OFF@',            output_off,),
                  (r'@ON@',             output_on,),
                  (r'@NAME@',           self.outsignal,),
                  (r'@NORUNT@',         norunt,),
                ):
      body = re.sub(subs[0],subs[1],body);
    body = self.GenVerilogFinal(config,body);
    fp.write(body);