generate.py

#!/usr/bin/env python
#

import sys, argparse, logging, os

get_input = raw_input

new_config = {
    'i2c' : { 'active' : True }
}

board_config_path = "boards"
linker_scripts = {
    'samd09' : 'scripts/samd09d14a_flash.ld'
}
pin_activity_led = "PA27"
max_addr_pins = 5

class Tc:
    def __init__(self, index, wo):
        self.index = index
        self.wo = wo

class Sercom:
    def __init__(self, index, pad):
        self.index = index
        self.pad = pad

class Samd09Pin:
    def __init__(self, name, adc, sercom, sercomalt, tc):
        self.name = name
        self.adc = adc
        self.sercom = sercom
        self.sercomalt = sercomalt
        self.tc = tc
        self.mux = None

    def can_i2c(self, alt=False):
        if alt:
            sercom = self.sercomalt
        else:
            sercom = self.sercom

        if sercom is not None:
            if sercom.pad == 0:
                return "SDA"
            if sercom.pad == 1:
                return "SCL"
        return False

    def number(self):
        return int(self.name[2:])

used_sercoms = []
used_tc = []

pinouts = {
    'samd09' : [
        Samd09Pin("PA02", 0, None, None, None),
        Samd09Pin("PA03", 1, None, None, None),
        Samd09Pin("PA04", 2, Sercom(0, 2), Sercom(0, 0), Tc(1, 0)),
        Samd09Pin("PA05", 3, Sercom(0, 3), Sercom(0, 1), Tc(1, 1)),
        Samd09Pin("PA06", 4, Sercom(0, 0), Sercom(0, 2), Tc(2, 0)),
        Samd09Pin("PA07", 5, Sercom(0, 1), Sercom(0, 3), Tc(2, 0)),
        Samd09Pin("PA08", None, Sercom(1, 2), Sercom(0, 2), None),
        Samd09Pin("PA09", None, Sercom(1, 3), Sercom(0, 3), None),
        Samd09Pin("PA10", 8, Sercom(0, 2), None, Tc(2, 0)),
        Samd09Pin("PA11", 9, Sercom(0, 3), None, Tc(2, 1)),
        Samd09Pin("PA14", 6, Sercom(0, 0), None, Tc(1, 0)),
        Samd09Pin("PA15", 7, Sercom(0, 1), None, Tc(1, 1)),
        Samd09Pin("PA16", None, Sercom(1, 2), None, Tc(1, 0)),
        Samd09Pin("PA17", None, Sercom(1, 3), None, Tc(1, 1)),
        Samd09Pin("PA22", None, Sercom(1, 0), None, Tc(1, 0)),
        Samd09Pin("PA23", None, Sercom(1, 1), None, Tc(1, 1)),
        Samd09Pin("PA27", None, None, None, None),
        Samd09Pin("PA28", None, None, None, None),
        Samd09Pin("PA30", None, Sercom(1, 0), Sercom(1, 2), Tc(2, 0)),
        Samd09Pin("PA31", None, Sercom(1, 2), Sercom(1, 3), Tc(2, 1)),
        Samd09Pin("PA24", None, Sercom(1, 2), None, None),
        Samd09Pin("PA25", None, Sercom(1, 3), None, None),
    ],
    'samd21' : []
}

used_pins = {
    'samd09' : [
        pinouts['samd09'][18], pinouts['samd09'][19], pinouts['samd09'][17] #SWCLK, SDWIO, RESET
    ]
}

def pin_is_used(name):
    name = name.upper()
    for pin in used_pins[new_config['chipset']]:
        if pin.name == name:
            return True
    return False

def is_a_pin(name):
    name = name.upper()
    for pin in pinouts[new_config['chipset']]:
        if pin.name == name:
            return True
    return False

def get_pin_index(name):
    name = name.upper()
    for ix,pin in enumerate(pinouts[new_config['chipset']]):
        if pin.name == name:
            return ix
    return -1

def get_available_sda():
    pins = []
    for pin in pinouts[new_config['chipset']]:
        if pin not in used_pins[new_config['chipset']]:
            if pin.can_i2c() == "SDA" and pin.sercom is not None and pin.sercom.index not in used_sercoms:
                pins.append( (pin, pin.sercom, 2) )
            if pin.can_i2c(True) == "SDA" and pin.sercomalt is not None and pin.sercomalt.index not in used_sercoms:
                pins.append( (pin, pin.sercom, 3) )
    return pins

def get_available_scl():
    pins = []
    for pin in pinouts[new_config['chipset']]:
        if pin not in used_pins[new_config['chipset']]:
            if pin.can_i2c() == "SCL" and pin.sercom is not None and pin.sercom.index not in used_sercoms:
                pins.append( (pin, pin.sercom, 2) )
            if pin.can_i2c(True) == "SCL" and pin.sercomalt is not None and pin.sercomalt.index not in used_sercoms:
                pins.append( (pin, pin.sercom, 3) )
    return pins

def get_available_adc():
    pins = []
    for pin in pinouts[new_config['chipset']]:
        if pin not in used_pins[new_config['chipset']]:
            if pin.adc is not None:
                pins.append(pin)
    return pins

def get_available_pwm():
    pins = []
    for pin in pinouts[new_config['chipset']]:
        if pin not in used_pins[new_config['chipset']]:
            if pin.tc is not None:
                used = False
                for tc in used_tc:
                    if tc.index == pin.tc.index and tc.wo == pin.tc.wo: #we want independent channels
                        used = True
                        break
                if not used:
                    pins.append(pin)
    return pins

def get_available_gpio():
    pins = []
    for pin in pinouts[new_config['chipset']]:
        if pin not in used_pins[new_config['chipset']]:
            pins.append(pin)
    return pins

def generate_files():
    path = board_config_path + "/" + new_config['name']
    os.makedirs(path)
    f = open(path + "/board.mk", 'w')
    f.write("CHIP_FAMILY = %s\n" % new_config['chipset'].upper())
    f.write("CHIP_VARIANT = SAMD09D14A\n") #TODO:
    f.write("BOARD_NAME = %s\n" % new_config['name'].upper())
    f.write("LINKER_SCRIPT = %s\n" % linker_scripts[new_config['chipset']])
    f.close()

    f = open(path + "/board_config.h", 'w')

    f.writelines(["#ifndef SEESAW_DEVICE_CONFIG_H\n",
                "#define SEESAW_DEVICE_CONFIG_H\n"])

    f.write("\n#define PRODUCT_CODE %i\n" % new_config['pid'])

    if new_config['i2c']['no_led']:
        f.write("#define CONFIG_NO_ACTIVITY_LED\n")

    f.write("#define CONFIG_NO_EEPROM\n")

    f.writelines(["\n","//* ============== POOL SIZES =================== *//\n",
    "#define	EVT_SIZE_SMALL 16\n",
    "#define EVT_SIZE_MEDIUM 32\n",
    "#define	EVT_SIZE_LARGE 64\n",
    "#define	EVT_COUNT_SMALL 16\n",
    "#define	EVT_COUNT_MEDIUM 8\n",
    "#define	EVT_COUNT_LARGE 1\n",
    "\n",
    "//* ============== ADC =================== *//\n"])

    f.write("#define CONFIG_ADC %i\n" % (0 if not new_config['adc'] else 1))
    if new_config['chipset'] == 'samd09':
      max_adc = 4
    elif new_config['chipset'] == 'samd21':
      max_adc = 8
    for ix in range(max_adc):
        f.write("#define CONFIG_ADC_INPUT_%i " % ix)
        if ix > len(new_config['adc'])-1:
            f.write("0\n")
        else:
            f.write("1\n#define CONFIG_ADC_INPUT_%i_PIN %i\n\n" % (ix, new_config['adc'][ix].number()))

    f.writelines(["//* ============== DAC =================== *//\n",
    "#define CONFIG_DAC 0\n\n",
    "//* ============== TIMER =================== *//\n"])

    f.write("#define CONFIG_TIMER %i\n" % (0 if not new_config['pwm'] else 1))
    if new_config['chipset'] == 'samd09':
      max_pwm = 4
    elif new_config['chipset'] == 'samd21':
      max_pwm = 12
    for ix in range(max_pwm):
        f.write("#define CONFIG_TIMER_PWM_OUT%i " % ix)
        if ix > len(new_config['pwm'])-1:
            f.write("0\n")
        else:
            f.write("1\n#define CONFIG_TIMER_PWM_OUT%i_PIN %i\n" % (ix, new_config['pwm'][ix].number()))
            f.write("#define CONFIG_TIMER_PWM_OUT%i_TC TC%i\n" % (ix, new_config['pwm'][ix].tc.index))
            f.write("#define CONFIG_TIMER_PWM_OUT%i_WO %i\n" % (ix, new_config['pwm'][ix].tc.wo))

    f.write("\n//* ============== INTERRUPT =================== *//\n")

    f.write("#define CONFIG_INTERRUPT %i\n" % (0 if new_config['interrupt'] is None else 1))
    f.write("#define CONFIG_INTERRUPT_PIN %i\n" % (0 if new_config['interrupt'] is None else new_config['interrupt'].number()))

    f.write("\n//* ============== I2C SLAVE =================== *//\n")

    f.write("#define CONFIG_I2C_SLAVE %i\n" % (0 if new_config['i2c']['active'] is False else 1))
    if new_config['i2c']['active']:
        f.write("#define CONFIG_I2C_SLAVE_SERCOM SERCOM%i\n" % new_config['i2c']['sercom'])
        f.write("#define CONFIG_I2C_SLAVE_HANDLER SERCOM%i_Handler\n" % new_config['i2c']['sercom'])
        f.write("#define CONFIG_I2C_SLAVE_IRQn SERCOM%i_IRQn\n" % new_config['i2c']['sercom'])
        
        f.write("#define CONFIG_I2C_SLAVE_PIN_SDA %i\n" % new_config['i2c']['sda'].number())
        f.write("#define CONFIG_I2C_SLAVE_PIN_SCL %i\n" % new_config['i2c']['scl'].number())

        f.write("#define CONFIG_I2C_SLAVE_MUX %i\n" % new_config['i2c']['sda'].mux)

        f.write("#define CONFIG_I2C_SLAVE_FLOW_CONTROL %i\n" % (0 if new_config['i2c']['flow'] is None else 1))
        f.write("#define CONFIG_I2C_SLAVE_FLOW_CONTROL_PIN %i\n" % (0 if new_config['i2c']['flow'] is None else new_config['i2c']['flow'].number()))
        
        f.write("#define CONFIG_I2C_SLAVE_ADDR 0x%s\n" % format(new_config['i2c']['address'], '02X'))

        if len(new_config['i2c']['addr_select']) == 0:
            f.write("#define CONFIG_NO_ADDR\n")
        else:
            for ix, p in enumerate(new_config['i2c']['addr_select']):
                if ix > 1:
                    f.write("#define CONFIG_ADDR_%i 1\n" % ix)
                f.write("#define PIN_ADDR_%i " % ix)
                f.write("%i\n" % p.number())

    f.writelines(["\n//* ============== SERCOM =================== *//\n",
    "#define CONFIG_SERCOM0 0\n",
    "#define CONFIG_SERCOM1 0\n",
    "#define CONFIG_SERCOM1 0\n",
    "#define CONFIG_SERCOM2 0\n\n",
    "//These are only available on samd21\n"
    "#define CONFIG_SERCOM3 0\n",
    "#define CONFIG_SERCOM4 0\n",
    "#define CONFIG_SERCOM5 0\n\n",
    "//* ============== DAP =================== *//\n",
    "#define CONFIG_DAP 0\n\n"
    "//* =========== NEOPIXEL ================ *//\n"])

    f.write("#define CONFIG_NEOPIXEL %i\n" % (0 if new_config['neopixel'] is None else 1))
    f.write(" #define CONFIG_NEOPIXEL_BUF_MAX %i\n" % (0 if new_config['neopixel'] is None else new_config['neopixel']))

    f.write("#endif\n")

    f.close()

def generate_preview():
    print("====== CONFIGURATION SUMMARY =====\n")
    print("NAME: %s" % new_config['name'])
    print("PID: %i" % new_config['pid'])
    print("CHIPSET: %s" % new_config['chipset'])
    if new_config['i2c']['active']:
        print("\nI2C:")
        print("\tADDRESS: 0x%s" % format(new_config['i2c']['address'], '02X'))
        print("\tSERCOM: SERCOM%i" % new_config['i2c']['sercom'])
        print("\tSDA: %s" % new_config['i2c']['sda'].name)
        print("\tSCL: %s" % new_config['i2c']['scl'].name)
        print("\tFLOW CONTROL: %s" % ("None" if new_config['i2c']['flow'] is None else new_config['i2c']['flow'].name))
        print("\tACTIVITY LED: %s" % (not new_config['i2c']['no_led']))
        if len(new_config['i2c']['addr_select']):
            print("\nADDR SELECT PINS: %i" % len(new_config['i2c']['addr_select']))
            for ix, p in enumerate(new_config['i2c']['addr_select']):
                print("\t%s" % p.name)
        else:
            print("\tADDR SELECT PINS: None\n")

    if new_config['adc']:
        print("\nADC CHANNELS: %i" % len(new_config['adc']))
        for ix, adc in enumerate(new_config['adc']):
            print("\t%s" % adc.name)

    if new_config['pwm']:
        print("\nPWM CHANNELS: %i" % len(new_config['pwm']))
        for ix, pwm in enumerate(new_config['pwm']):
            print("\t%s" % pwm.name)

    print("\nIRQ: %s" % ("None" if new_config['interrupt'] is None else new_config['interrupt'].name))
    print("NEOPIXEL BUFFER: %s" % new_config['neopixel'])
    print("\nAVAILABLE GPIOS:")
    for gpio in get_available_gpio():
        print("\t%s" % gpio.name)
    print("\n")

# Gather our code in a main() function
def main(args, loglevel):
  logging.basicConfig(format="%(levelname)s: %(message)s", level=loglevel)
  
  #logging.info("You passed an argument.")

  #NAME
  user_input = get_input("enter a name for your configuration: ")
  logging.debug("received name: %s" % user_input)

  if os.path.isdir(board_config_path + "/" + user_input):
      logging.error("directory "+board_config_path+"/%s already exists" % user_input)
      return
  else:
      new_config['name'] = user_input
      logging.debug("directory "+board_config_path+"/%s does not yet exist" % user_input)

  #CHIPSET
  user_input = get_input("select a chipset:\n [0] samd09 \n [1] samd21 \n: ")
  if user_input == "0":
      new_config['chipset'] = "samd09"
  elif user_input == "1":
      new_config['chipset'] = "samd21"
      #TODO: fix
      logging.error("SAMD21 support coming soon")
      return
  else:
      logging.error("unrecognized option")
      return

  logging.debug("chipset %s selected" % new_config['chipset'])

  #BOOTLOADER
  if new_config['chipset'] == "samd21":
      user_input = get_input("will you use a bootloader? [y/n]: ")
      if user_input == "y":
          new_config['bootloader'] = True
      elif user_input == "n":
          new_config['bootloader'] = False
      else:
          logging.error("unrecognized option")
          return

      logging.debug("selected uses bootloader: %s" % new_config['bootloader'])

  #PID
  user_input = get_input("what's the product id? : ")
  if not user_input.isdigit():
      logging.error("the product ID must be a positive integer")
      return
  new_config['pid'] = int(user_input)
  logging.debug("selected pid: %i" % new_config['pid'])

  #I2C
  user_input = get_input("will you use the i2c slave interface? [y/n]: ")
  if user_input == "y":
    new_config['i2c'] = {'active' : True}
  elif user_input == "n":
    new_config['i2c'] = {'active' : False}
  else:
    logging.error("unrecognized option")
    return

  if new_config['i2c']['active']:
    #I2C SERCOM
    sdapins = get_available_sda()
    istring = "which pin for SDA?\n"
    for ix,cfg in enumerate(sdapins):
        istring = istring + " [" + str(ix) + "] " + cfg[0].name + " (sercom" + str(cfg[1].index) + ")\n"

    istring = istring + ": "
    user_input = get_input(istring)
    
    if user_input.isdigit() and int(user_input) < len(sdapins):
        cfg = sdapins[int(user_input)]
        new_config['i2c']['sercom'] = cfg[1].index
        new_config['i2c']['sda'] = cfg[0]
        new_config['i2c']['mux'] = cfg[2]
        cfg[0].mux = cfg[2]
        used_pins[new_config['chipset']].append(cfg[0])
        logging.debug("selected SDA pin: %s" % new_config['i2c'])
        logging.debug("selected I2C Sercom: %s" % new_config['i2c']['sercom'])
    else:
        logging.error("unrecognized option")
        return

    sclpins = get_available_scl()
    accepatable_sclpins = []
    istring = "which pin for SCL?\n"
    for cfg in sclpins:
        if cfg[1].index == new_config['i2c']['sercom'] and cfg[2] == new_config['i2c']['mux']:
            accepatable_sclpins.append(cfg)
    sclpins = accepatable_sclpins
    for ix,cfg in enumerate(sclpins):
        istring = istring + " [" + str(ix) + "] " + cfg[0].name + " (sercom" + str(cfg[1].index) + ")\n"

    istring = istring + ": "
    user_input = get_input(istring)
    
    if user_input.isdigit() and int(user_input) < len(sclpins):
        cfg = sclpins[int(user_input)]
        new_config['i2c']['sercom'] = cfg[1].index
        new_config['i2c']['scl'] = cfg[0]
        cfg[0].mux = cfg[2]
        used_pins[new_config['chipset']].append(cfg[0])
        logging.debug("selected SCL pin: %s" % new_config['i2c']['scl'].name)
    else:
        logging.error("unrecognized option")
        return

    #mark sercom is now used
    used_sercoms.append(new_config['i2c']['sercom'])

    #ADDRESS
    user_input = get_input("which I2C address? [default 0x49]: ")
    if user_input == "":
        new_config['i2c']['address'] = 0x49
    else:
        new_config['i2c']['address'] = int(user_input, 0)

    logging.debug("selected i2c address: 0x%s"  % format(new_config['i2c']['address'], '02X'))
    if new_config['i2c']['address'] > 0x7F:
        logging.error("the I2C address cannot be greater than 7 bits in length.")
        return

    #ADDRESS SELECT
    new_config['i2c']['addr_select'] = []
    while(len(new_config['i2c']['addr_select']) < max_addr_pins):
        user_input = get_input("add a pin for address select? (ex. enter name as 'PA10' or leave blank for no more address select) :")
        if user_input == "":
            break
        else:
            if get_pin_index(user_input) > -1:
                if pin_is_used(user_input):
                    logging.error("pin is used!")
                    return
                else:
                    selected_pin = pinouts[new_config['chipset']][get_pin_index(user_input)]
                    new_config['i2c']['addr_select'].append(selected_pin)
                    used_pins[new_config['chipset']].append(selected_pin)
                    logging.debug("selected addr pin: %s" % selected_pin.name)
            else:
                logging.error("unrecognized option")
                return

    #ACTIVITY LED
    user_input = get_input("will you use the activity LED? [y/n]: ")
    if user_input == "y":
      new_config['i2c']['no_led'] = False
      used_pins[new_config['chipset']].append(pinouts[new_config['chipset']][get_pin_index(pin_activity_led)])
    elif user_input == "n":
      new_config['i2c']['no_led'] = True
    else:
      logging.error("unrecognized option")
      return

    #FLOW
    user_input = get_input("which pin for flow control? (ex. enter name as 'PA10' or leave blank for no flow control) :")
    if user_input == "":
        new_config['i2c']['flow'] = None
    else:
        if get_pin_index(user_input) > -1:
            if pin_is_used(user_input):
                logging.error("pin is used!")
                return
            else:
                selected_pin = pinouts[new_config['chipset']][get_pin_index(user_input)]
                new_config['i2c']['flow'] = selected_pin
                used_pins[new_config['chipset']].append(selected_pin)
                logging.debug("selected flow pin: %s" % new_config['i2c']['flow'].name)
        else:
            logging.error("unrecognized option")
            return
        
  #ADC
  new_config['adc'] = []
  if new_config['chipset'] == 'samd09':
      max_adc = 4
  elif new_config['chipset'] == 'samd21':
      max_adc = 8

  ix = 0
  while(ix < max_adc):
    available_adcs = get_available_adc()
    istring = "select an ADC pin or leave blank for no more ADC\n"
    for jx, pin in enumerate(available_adcs):
        istring = istring + " [" + str(jx) + "] " + pin.name + "\n"
    istring = istring + ": "
    user_input = get_input(istring)
    if user_input == "":
        break
    if user_input.isdigit() and int(user_input) < len(available_adcs):
        new_config['adc'].append(available_adcs[int(user_input)])
        used_pins[new_config['chipset']].append(available_adcs[int(user_input)])
    else:
        logging.error("unrecognized option")
        return
    ix = ix + 1

  #PWM
  new_config['pwm'] = []
  if new_config['chipset'] == 'samd09':
      max_pwm = 4
  elif new_config['chipset'] == 'samd21':
      max_pwm = 12

  ix = 0
  while(ix < max_pwm):
    available_pwm = get_available_pwm()
    istring = "select a PWM pin or leave blank for no more PWM\n"
    for jx, pin in enumerate(available_pwm):
        istring = istring + " [" + str(jx) + "] " + pin.name + "\n"
    istring = istring + ": "
    user_input = get_input(istring)
    if user_input == "":
        break
    if user_input.isdigit() and int(user_input) < len(available_pwm):
        new_config['pwm'].append(available_pwm[int(user_input)])
        used_pins[new_config['chipset']].append(available_pwm[int(user_input)])
        used_tc.append(available_pwm[int(user_input)].tc)
    else:
        logging.error("unrecognized option")
        return
    ix = ix + 1

  #INTERRUPT
  available_int = get_available_gpio()
  istring = "select an IRQ pin or leave blank for none\n"
  for jx, pin in enumerate(available_int):
    istring = istring + " [" + str(jx) + "] " + pin.name + "\n"
  istring = istring + ": "
  user_input = get_input(istring)
  if user_input == "":
    new_config['interrupt'] = None
  elif user_input.isdigit() and int(user_input) < len(available_int):
    new_config['interrupt'] = available_int[int(user_input)]
    used_pins[new_config['chipset']].append(available_int[int(user_input)])
  else:
    logging.error("unrecognized option")
    return

  #NEOPIXEL
  user_input = get_input("enter a NeoPixel buffer size in bytes or leave blank for none : ")
  if user_input == "":
      new_config['neopixel'] = None
  elif not user_input.isdigit():
      logging.error("bufsize must be a positive integer")
      return
  else:
    new_config['neopixel'] = int(user_input)

  generate_preview()

  user_input = get_input("press enter to generate or Ctrl+C to cancel")

  generate_files()

  print("configuration generated. Please run 'make BOARD=%s'\n" % new_config['name'])
  
 
# Standard boilerplate to call the main() function to begin
# the program.
if __name__ == '__main__':
  parser = argparse.ArgumentParser( 
                                    description = "Generates a new seesaw configuration",
                                    epilog = "As an alternative to the commandline, params can be placed in a file, one per line, and specified on the commandline like '%(prog)s @params.conf'.",
                                    fromfile_prefix_chars = '@' )
  # TODO Specify your real parameters here.
  parser.add_argument(
                      "-v",
                      "--verbose",
                      help="increase output verbosity",
                      action="store_true")
  args = parser.parse_args()
  
  # Setup logging
  if args.verbose:
    loglevel = logging.DEBUG
  else:
    loglevel = logging.INFO
  
  main(args, loglevel)