def __init__(self, verify=config.opt_verify,
reverse=False,
require_types=True):
Codegen.__init__(self)
self.fn = None
self.verify = verify
self.reverse = reverse
self.require_types = require_types
def compile(chunk, chunk_name):
parser = Parser()
lexer = Lexer(chunk, chunk_name)
ast = parser.parse_block(lexer)
# print(ast)
proto = Codegen.gen_proto(ast)
# proto.print_code()
LuaCompiler.set_source(proto, chunk_name)
return proto
def generate_code(path):
msg = ""
line_no = 0
lexer = Lexer().get_lexer()
pg = Parser()
pg.parse()
parser = pg.get_parser()
with open(path) as fp:
line_no = line_no + 1
for line in fp:
try:
if ((len(line.replace('\n', "")) > 0) and ('#' not in line)):
token = lexer.lex(line.replace('\n', ""))
parser.parse(token)
line_no = line_no + 1
except:
msg = "Syntax error in line No " + str(line_no)
return msg
fp.close()
Code = Codegen()
write_file(Code.doit(), path)
return "Successfully generated"
stride = 0
kernel_range = [2, 3]
channel_range = [0, 1]
f_list.extend([
Func(fbase, k, k, ch, stride, stride, corefunc, "krnpad")
for k in kernel_range for ch in channel_range
])
#at last add the generic function that can be used in the else branch in the wrapper.
default_func = Func(fbase, 0, 0, 0, 0, 0, "conv2d_chw", generic=True)
f_list.append(default_func)
#------------------------------------------------------------
# Generate the output file
#------------------------------------------------------------
c = Codegen()
c.set_wrapper_variables({
'stride_w': "cfg->stride_width",
'stride_h': "cfg->stride_height"
})
c.set_wrapper_variables({
'kernel_w': "weights->shape[KRNL_W_DIM_CHW]",
'kernel_h': "weights->shape[KRNL_H_DIM_CHW]"
})
c.set_wrapper_variables({'channels': "in->shape[FMAP_C_DIM_CHW]"})
c.set_wrapper_variables({'padding_top': "cfg->padding_top"})
c.set_wrapper_variables({'padding_bot': "cfg->padding_bottom"})
c.set_wrapper_variables({'padding_left': "cfg->padding_left"})
c.set_wrapper_variables({'padding_right': "cfg->padding_right"})
c.set_wrapper_hierarchy(
['stride_w', 'stride_h', 'kernel_w', 'kernel_h', 'channels', 'padding'])
kernel_range = [0, 2, 3]
ch = 0
f_list.extend([Func(fbase, 1, k, ch, stride, stride, corefunc, "krnpad") for k in kernel_range])
f_list.extend([Func(fbase, k, 1, ch, stride, stride, corefunc, "krnpad") for k in kernel_range])
f_list.extend([Func(fbase, 1, k, ch, stride, stride, corefunc, "nopad") for k in kernel_range])
f_list.extend([Func(fbase, k, 1, ch, stride, stride, corefunc, "nopad") for k in kernel_range])
#at last add the generic function that can be used in the else branch in the wrapper.
corefunc = "avepool_chw_krnpad"
default_func = Func(fbase, 0, 0, 0, 0, 0, corefunc, generic=True)
f_list.append(default_func)
#------------------------------------------------------------
# Generate the output file
#------------------------------------------------------------
c = Codegen()
c.set_wrapper_variables({'stride_w' : "cfg->stride_width", 'stride_h' : "cfg->stride_height"})
c.set_wrapper_variables({'kernel_w' : "cfg->kernel_width", 'kernel_h' : "cfg->kernel_height"})
c.set_wrapper_variables({'padding_top' : "cfg->padding_top"})
c.set_wrapper_variables({'padding_bot' : "cfg->padding_bottom"})
c.set_wrapper_variables({'padding_left' : "cfg->padding_left"})
c.set_wrapper_variables({'padding_right' : "cfg->padding_right"})
c.set_wrapper_hierarchy(['stride_w', 'stride_h', 'kernel_w', 'kernel_h', 'padding'])
c.set_wrapper_if_tree(False)
if "fx16" in sys.argv or no_args:
f = open(output_file_fx16, "wb")
f.write(c.print_file(f_list, default_func, func_body_template_file, file_template, include_list, define_list))
f.close()
#------------------------------------------------------------
fname = sys.argv[1]
out_fname = sys.argv[2]
dot_fname = sys.argv[3]
pp_opt = sys.argv[4:]
l,ltab = pyggy.getlexer("promela.pyl")
p,ptab = pyggy.getparser("promela.pyg")
l.setinput(pp_file(fname))
p.setlexer(l)
l.SPACES_PER_TAB = 4
try:
tree = p.parse()
except pyggy.errors.ParseError, e:
print >>sys.stderr, "%s:%d:%d: %s (token type: %s) unexpected here" % (fname, l.lineno, l.charno, e.str, e.tok)
print_errpos(fname, l.lineno, l.charno, l.SPACES_PER_TAB)
sys.exit(1)
else:
try:
ptab.codegen = Codegen()
code = pyggy.proctree(tree, ptab)
except pyggy.errors.SemanticError, e:
# Character position in semantic diagnostic doesn't look nice
print >>sys.stderr, "%s:%d: %s" % (fname, e.lineno(l), e.err)
print_errpos(fname, e.lineno(l), e.charno(l), l.SPACES_PER_TAB)
sys.exit(2)
else:
code.write_file(out_fname)
code.write_dot(dot_fname)
def runCompiler(input_file, file_name, stage, opt_stage, debug_stage):
# scan, parse, ast, semantic, irt, codegen
if (stage == "scan" or stage == "parse" or stage == "ast"
or stage == "semantic" or stage == "irt" or stage == "codegen"):
debug = False
if (("scan" in debug_stage)):
debug = True
sc = Scanner.Scanner()
rf = ReadFile.ReadFile()
wf = WriteFile.WriteFile()
# set de input file
rf.set_file(f"decafs/{input_file}.decaf")
# call scanner class and scan for tokens in input file
token_list, error_list = sc.scan(rf.file_to_string(), debug)
string_list = []
for token in token_list:
string_list.append(token.pretty_print())
# write file in output/
wf.write_file(file_name, string_list)
# write file in output/
error1 = len(error_list)
wf.write_file_append("error_list", error_list)
if (stage == "parse" or stage == "ast" or stage == "semantic"
or stage == "irt" or stage == "codegen"):
debug = False
if (("parse" in debug_stage)):
debug = True
pr = Parser.Parser()
main_program, error_list = pr.parse(token_list, debug)
# write file in output/
wf.write_file_append("error_list", error_list)
error2 = len(error_list)
if (stage == "ast" or stage == "semantic" or stage == "irt"
or stage == "codegen"):
debug = False
if (("ast" in debug_stage)):
debug = True
ast = Ast.Ast()
ast.ast(main_program, debug)
if (stage == "semantic" or stage == "irt" or stage == "codegen"):
debug = False
if (("semantic" in debug_stage)):
debug = True
sm = Semantic.Semantic()
error_list = sm.semantic(main_program, debug)
# write file in output/
wf.write_file_append("error_list", error_list)
error3 = len(error_list)
if (stage == "irt" or stage == "codegen"):
if (error1 == 0 and error2 == 0 and error3 == 0):
debug = False
if (("irt" in debug_stage)):
debug = True
irt = Irt.Irt()
irt_list = irt.irt(main_program, debug)
else:
print("There are errors in the error_log")
if (stage == "codegen"):
if (error1 == 0 and error2 == 0 and error3 == 0):
codegen = Codegen.Codegen()
code_list, code_list_2 = codegen.codegen(main_program, debug)
wf.write_file_no_extension("program.asm", code_list)
wf.write_file_no_extension("program.py", code_list_2)
else:
print("There are errors in the error_log")
# TODO write file asm or py from code_list
# print("CODEGEN not ready")
if (stage != "scan" and stage != "parse" and stage != "ast"
and stage != "semantic" and stage != "irt" and stage != "codegen"):
print("stage value not defined")
print(input_file, file_name, stage, opt_stage, debug_stage)
warning = 'All outdated element abstract classes will be replaced. Enter `yes` to continue. '
def dir_to_ns(directory):
return directory.replace('/', '.').replace('\\', '.')
opts, args = getopt.getopt(sys.argv[1:], 'f', ['force'])
for opt, arg in opts:
if opt in ('-f', '--force'):
force = True
warning = 'Warning! All element abstract classes will be replaced, regardless of timestamp. Enter `yes` to continue. '
if raw_input(warning) == 'yes':
template = Template()
template.load(TEMPLATES_DIR)
codegen = Codegen(template)
for root, dirs, files in os.walk(ELEMENTS_DIR):
namespace = dir_to_ns(root.replace(ELEMENTS_DIR, ''))[1:]
for filename in files:
compounds = filename.split('.')
if compounds[-1] == 'json':
path = os.path.join(root, filename)
f = open(path)
element = simplejson.loads(f.read())
f.close()
element['namespace'] = namespace
def __init__(self, logger):
Logger.log.debug('{} initializing....'.format(__name__))
self.logger = logger
self.config = Config(logger=self.logger)
self.support = Support(config=self.config, logger=self.logger)
self.gpio = Gpio(config=self.config, logger=self.logger)
self.pollperm = Pollperm(logger=self.logger)
self.decoder = Decoder(config=self.config,
logger=self.logger,
gpio=self.gpio)
self.spi = SPI(config=self.config,
logger=self.logger,
decoder=self.decoder,
pollperm=self.pollperm)
self.codegen = Codegen(config=self.config,
logger=self.logger,
gpio=self.gpio,
spi=self.spi)
self.securitylevel = SecurityLevel(logger=self.logger)
self.gui = Mainwindow(self,
codegen=self.codegen,
config=self.config,
logger=self.logger,
support=self.support,
securitylevel=self.securitylevel)
self.switches = Switches(config=self.config,
logger=self.logger,
spi=self.spi,
gui=self.gui)
self.currentsense = CurrentSense(logger=self.logger,
spi=self.spi,
decoder=self.decoder,
gui=self.gui,
config=self.config)
self.pollvalues = Pollvalues(pollperm=self.pollperm,
logger=logger,
config=self.config,
currentsense=self.currentsense,
switches=self.switches,
sense_callback=self.poll_sense_callback,
switch_callback=self.poll_switch_callback)
self.securitywindow = SecurityWindow(logger=self.logger,
securitylevel=self.securitylevel)
self.window = self.gui.window
self.log = self.logger.log
self.knob_values = 0
self.rotary_0_pins = None
self.rotary_1_pins = None
self.rotary_2_pins = None
self.rotary_3_pins = None
self.rotary_0_pin_0_debounce = None
self.rotary_0_pin_1_debounce = None
self.rotary_1_pin_0_debounce = None
self.rotary_1_pin_1_debounce = None
self.rotary_2_pin_0_debounce = None
self.rotary_2_pin_1_debounce = None
self.rotary_3_pin_0_debounce = None
self.rotary_3_pin_1_debounce = None
self.gain0_val = 0
self.gain1_val = 0
self.gain_0_name = None
self.gain_1_name = None
self.gain_0_spi_channel = None
self.gain_1_spi_channel = None
self.gain_0_thresholds = None
self.gain_1_thresholds = None
self.GAIN_0_CS = None
self.GAIN_1_CS = None
self.speed0_val = 0
self.speed1_val = 0
self.speed_0_name = None
self.speed_1_name = None
self.speed_0_shape = None
self.speed_1_shape = None
self.speed_0_spi_channel = None
self.speed_1_spi_channel = None
self.speed_0_thresholds = None
self.speed_1_thresholds = None
self.screen_brightness_max = None
self.screen_brightness_min = None
self.display_brightness = None
self.spi_log_pause = False
self.SPEED_0_CS = None # 6 # SPEED SIMULATION TACH 1
self.SPEED_1_CS = None # 7 # SPEED SIMULATION TACH 2
self.load_from_config()
self.adc_scale = None
self.sense_amp_max_amps = None
self.sense_ad_vin = None # LM4128CQ1MF3.3/NOPB voltage reference
self.sense_ad_max_bits = 0 # AD7940 ADC
self.sense_scaling_factor_mv_amp = None # 110 milivolts per amp
self.sense_ad_max_scaled_value = None
self.speed0 = Speedgen(
pollperm=self.pollperm,
logger=self.logger,
config=self.config,
decoder=self.decoder,
spi=self.spi,
gpio=self.gpio,
name=self.speed_0_name,
shape=self.speed_0_shape,
spi_channel=self.speed_0_spi_channel,
chip_select=self.SPEED_0_CS,
pin_0=self.rotary_0_pins[0],
pin_1=self.rotary_0_pins[1],
pin_0_debounce=self.rotary_0_pin_0_debounce,
pin_1_debounce=self.rotary_0_pin_1_debounce,
thresholds=self.speed_0_thresholds,
callback=self.speed_callback,
commander_speed_move_callback=self.speed_move_callback)
self.speed1 = Speedgen(
pollperm=self.pollperm,
logger=self.logger,
config=self.config,
decoder=self.decoder,
spi=self.spi,
gpio=self.gpio,
name=self.speed_1_name,
shape=self.speed_1_shape,
spi_channel=self.speed_1_spi_channel,
chip_select=self.SPEED_1_CS,
pin_0=self.rotary_1_pins[0],
pin_1=self.rotary_1_pins[1],
pin_0_debounce=self.rotary_1_pin_0_debounce,
pin_1_debounce=self.rotary_1_pin_1_debounce,
thresholds=self.speed_1_thresholds,
callback=self.speed_callback,
commander_speed_move_callback=self.speed_move_callback)
self.gain0 = Gains(
pollperm=self.pollperm,
config=self.config,
logger=self.logger,
decoder=self.decoder,
spi=self.spi,
gpio=self.gpio,
name=self.gain_0_name,
spi_channel=self.gain_0_spi_channel,
chip_select=self.GAIN_0_CS,
pin_0=self.rotary_2_pins[0],
pin_1=self.rotary_2_pins[1],
pin_0_debounce=self.rotary_2_pin_0_debounce,
pin_1_debounce=self.rotary_2_pin_1_debounce,
thresholds=self.gain_0_thresholds,
callback=self.gains_callback,
commander_gain_move_callback=self.gain_move_callback)
self.gain1 = Gains(
pollperm=self.pollperm,
config=self.config,
logger=self.logger,
decoder=self.decoder,
spi=self.spi,
gpio=self.gpio,
name=self.gain_1_name,
spi_channel=self.gain_1_spi_channel,
chip_select=self.GAIN_1_CS,
pin_0=self.rotary_3_pins[0],
pin_1=self.rotary_3_pins[1],
pin_0_debounce=self.rotary_3_pin_0_debounce,
pin_1_debounce=self.rotary_3_pin_1_debounce,
thresholds=self.gain_1_thresholds,
callback=self.gains_callback,
commander_gain_move_callback=self.gain_move_callback)
self.startup_processes()
class Commander(object):
Logger.log.debug("Instantiating {} class...".format(__qualname__))
set_level = 0
def __init__(self, logger):
Logger.log.debug('{} initializing....'.format(__name__))
self.logger = logger
self.config = Config(logger=self.logger)
self.support = Support(config=self.config, logger=self.logger)
self.gpio = Gpio(config=self.config, logger=self.logger)
self.pollperm = Pollperm(logger=self.logger)
self.decoder = Decoder(config=self.config,
logger=self.logger,
gpio=self.gpio)
self.spi = SPI(config=self.config,
logger=self.logger,
decoder=self.decoder,
pollperm=self.pollperm)
self.codegen = Codegen(config=self.config,
logger=self.logger,
gpio=self.gpio,
spi=self.spi)
self.securitylevel = SecurityLevel(logger=self.logger)
self.gui = Mainwindow(self,
codegen=self.codegen,
config=self.config,
logger=self.logger,
support=self.support,
securitylevel=self.securitylevel)
self.switches = Switches(config=self.config,
logger=self.logger,
spi=self.spi,
gui=self.gui)
self.currentsense = CurrentSense(logger=self.logger,
spi=self.spi,
decoder=self.decoder,
gui=self.gui,
config=self.config)
self.pollvalues = Pollvalues(pollperm=self.pollperm,
logger=logger,
config=self.config,
currentsense=self.currentsense,
switches=self.switches,
sense_callback=self.poll_sense_callback,
switch_callback=self.poll_switch_callback)
self.securitywindow = SecurityWindow(logger=self.logger,
securitylevel=self.securitylevel)
self.window = self.gui.window
self.log = self.logger.log
self.knob_values = 0
self.rotary_0_pins = None
self.rotary_1_pins = None
self.rotary_2_pins = None
self.rotary_3_pins = None
self.rotary_0_pin_0_debounce = None
self.rotary_0_pin_1_debounce = None
self.rotary_1_pin_0_debounce = None
self.rotary_1_pin_1_debounce = None
self.rotary_2_pin_0_debounce = None
self.rotary_2_pin_1_debounce = None
self.rotary_3_pin_0_debounce = None
self.rotary_3_pin_1_debounce = None
self.gain0_val = 0
self.gain1_val = 0
self.gain_0_name = None
self.gain_1_name = None
self.gain_0_spi_channel = None
self.gain_1_spi_channel = None
self.gain_0_thresholds = None
self.gain_1_thresholds = None
self.GAIN_0_CS = None
self.GAIN_1_CS = None
self.speed0_val = 0
self.speed1_val = 0
self.speed_0_name = None
self.speed_1_name = None
self.speed_0_shape = None
self.speed_1_shape = None
self.speed_0_spi_channel = None
self.speed_1_spi_channel = None
self.speed_0_thresholds = None
self.speed_1_thresholds = None
self.screen_brightness_max = None
self.screen_brightness_min = None
self.display_brightness = None
self.spi_log_pause = False
self.SPEED_0_CS = None # 6 # SPEED SIMULATION TACH 1
self.SPEED_1_CS = None # 7 # SPEED SIMULATION TACH 2
self.load_from_config()
self.adc_scale = None
self.sense_amp_max_amps = None
self.sense_ad_vin = None # LM4128CQ1MF3.3/NOPB voltage reference
self.sense_ad_max_bits = 0 # AD7940 ADC
self.sense_scaling_factor_mv_amp = None # 110 milivolts per amp
self.sense_ad_max_scaled_value = None
self.speed0 = Speedgen(
pollperm=self.pollperm,
logger=self.logger,
config=self.config,
decoder=self.decoder,
spi=self.spi,
gpio=self.gpio,
name=self.speed_0_name,
shape=self.speed_0_shape,
spi_channel=self.speed_0_spi_channel,
chip_select=self.SPEED_0_CS,
pin_0=self.rotary_0_pins[0],
pin_1=self.rotary_0_pins[1],
pin_0_debounce=self.rotary_0_pin_0_debounce,
pin_1_debounce=self.rotary_0_pin_1_debounce,
thresholds=self.speed_0_thresholds,
callback=self.speed_callback,
commander_speed_move_callback=self.speed_move_callback)
self.speed1 = Speedgen(
pollperm=self.pollperm,
logger=self.logger,
config=self.config,
decoder=self.decoder,
spi=self.spi,
gpio=self.gpio,
name=self.speed_1_name,
shape=self.speed_1_shape,
spi_channel=self.speed_1_spi_channel,
chip_select=self.SPEED_1_CS,
pin_0=self.rotary_1_pins[0],
pin_1=self.rotary_1_pins[1],
pin_0_debounce=self.rotary_1_pin_0_debounce,
pin_1_debounce=self.rotary_1_pin_1_debounce,
thresholds=self.speed_1_thresholds,
callback=self.speed_callback,
commander_speed_move_callback=self.speed_move_callback)
self.gain0 = Gains(
pollperm=self.pollperm,
config=self.config,
logger=self.logger,
decoder=self.decoder,
spi=self.spi,
gpio=self.gpio,
name=self.gain_0_name,
spi_channel=self.gain_0_spi_channel,
chip_select=self.GAIN_0_CS,
pin_0=self.rotary_2_pins[0],
pin_1=self.rotary_2_pins[1],
pin_0_debounce=self.rotary_2_pin_0_debounce,
pin_1_debounce=self.rotary_2_pin_1_debounce,
thresholds=self.gain_0_thresholds,
callback=self.gains_callback,
commander_gain_move_callback=self.gain_move_callback)
self.gain1 = Gains(
pollperm=self.pollperm,
config=self.config,
logger=self.logger,
decoder=self.decoder,
spi=self.spi,
gpio=self.gpio,
name=self.gain_1_name,
spi_channel=self.gain_1_spi_channel,
chip_select=self.GAIN_1_CS,
pin_0=self.rotary_3_pins[0],
pin_1=self.rotary_3_pins[1],
pin_0_debounce=self.rotary_3_pin_0_debounce,
pin_1_debounce=self.rotary_3_pin_1_debounce,
thresholds=self.gain_1_thresholds,
callback=self.gains_callback,
commander_gain_move_callback=self.gain_move_callback)
self.startup_processes()
# ****************************************************************************************************************
def startup_processes(self):
self.load_from_config()
self.exit_signalling()
self.log_level_first_start()
self.speed_get_values()
self.gains_get_values()
self.shape_get_values()
self.poll_timer_setup()
self.display_timer_setup()
self.brightness_check()
# QApplication.restoreOverrideCursor()
# ****************************************************************************************************************
def gains_lock(self, value):
self.log.info("Gains Locked button received {}".format(value))
if value:
Gains.gains_locked = True
else:
Gains.gains_locked = False
# ****************************************************************************************************************
def logging_callback(self, level):
self.log.info("Logging callback")
# ****************************************************************************************************************
def parse_args(self, arguments):
"""
parses arguments sent from running the command line
:param arguments:
"""
for currentArgument, currentValue in arguments:
if currentArgument in ("-v", "--verbose"):
print("enabling verbose mode")
elif currentArgument in ("-h", "--help"):
print("displaying help")
elif currentArgument in ("-o", "--output"):
print(("enabling special output mode (%s)") % (currentValue))
# *******************************************************************************
def gpio_manual_read_pin(self):
pinstate = 0
gpio_pin = self.window.SPIN_gpio_manual_read_select.value()
if gpio_pin <= 40:
pinstate = self.gpio.gpio.read(gpio_pin)
elif gpio_pin > 40:
gpio_pin = gpio_pin - 41
pinstate = self.switch_values & gpio_pin
if pinstate == 0:
self.window.LBL_gpio_manual_read_value.setText("LOW")
elif pinstate == 1:
self.window.LBL_gpio_manual_read_value.setText("HIGH")
# ****************************************************************************************************************
def PB_spi_log_pause(self, value):
self.spi_log_pause = value
# *******************************************************************************
def gpio_manual_toggled(self, value):
"""grabs the gpio from the spin box control and sets it high or low based on
button press. if pin is > 40 then these are the auxillary gpio located
on the spi expander. currently the firs 4 pins are set as inputs and the
last 4 are set as outputs.
:param value:
"""
gpio_pin = self.window.SPIN_gpio_manual_select.value()
if gpio_pin <= 40:
try:
if value:
self.gpio.gpio.write(gpio_pin, True)
self.log.info("Setting GPIO {} to ON ".format(gpio_pin))
self.window.PB_gpio_manual_toggle.setText("ON")
elif not value:
self.gpio.gpio.write(gpio_pin, False)
self.log.info("Setting GPIO {} to OFF".format(gpio_pin))
self.window.PB_gpio_manual_toggle.setText("OFF")
except Exception:
self.log.info("GPIO ERROR")
self.window.PB_gpio_manual_toggle.setText("ERR")
elif gpio_pin >= 41:
try:
gpio_pin = gpio_pin - 41
if value:
self.switches.spi_write_values(pinvalue=1**gpio_pin)
self.log.info(
"Setting EXTENDED GPIO {} to ON".format(gpio_pin))
ret = self.window.PB_gpio_manual_toggle.setText("ON")
elif not value:
self.switches.spi_write_values(pinvalue=0**gpio_pin)
self.log.info(
"Setting EXTENDED GPIO {} to OFF".format(gpio_pin))
ret = self.window.PB_gpio_manual_toggle.setText("OFF")
except Exception:
self.log.info("GPIO ERROR")
self.window.PB_gpio_manual_toggle.setText("ERR")
# ***************************************************************************************
def manual_chip_select_toggled(self, value):
cs = self.window.SPIN_chip_select.value()
self.decoder.chip_select(cs)
self.log.info("Setting manual CS PIN:{} to {}".format(
cs, ("ON", "OFF")[value]))
self.window.PB_chip_select_manual_toggle.setText(("ON", "OFF")[value])
if cs > 7:
self.gpio.gpio.write(18, value)
else:
self.gpio.gpio.write(16, value)
# ******************************************************************************
def exit_signalling(self):
signal.signal(signal.SIGINT, self.exit_application)
signal.signal(signal.SIGTERM, self.exit_application)
self.log.debug("Setting up exit signaling...")
# ****************************************************************************************************************
def poll_timer_setup(self):
self.poll_timer = QTimer()
self.poll_timer.setObjectName("POLL_TIMER")
self.poll_timer.timeout.connect(self.pollvalues.poll_read_values)
self.poll_timer.start(self.config.poll_timer_interval)
# ****************************************************************************************************************
def display_timer_setup(self):
self.display = QTimer()
self.display.setObjectName("DISPLAY_TIMER")
self.display.timeout.connect(self.display_timer_run)
self.display.start(self.config.display_timer_interval)
# ****************************************************************************************************************
def poll_sense_callback(
self,
raw_analog_digital_value): # adc_average, display_amps, counts):
analog_digital_volts, scaled_value = self.adc_process_values(
raw_analog_digital_value)
display_amps = (scaled_value * analog_digital_volts)
display_amps = display_amps / 1000
adc_millivolts = analog_digital_volts * 1000
self.window.LBL_display_adc.setText("{:4.1f}".format(adc_millivolts))
self.window.LBL_display_amps.setText("{:2.3f}".format(display_amps))
self.window.LBL_loop_current.setText("{:2.3f}".format(display_amps))
self.window.LBL_display_adc_counts.setText(
"{:5.0f}".format(raw_analog_digital_value))
self.log.debug('GUI received sense values...')
self.log.debug("RAW A/D:{} Volts:{} Scaled:{} AMPS:{}".format(
raw_analog_digital_value, analog_digital_volts, scaled_value,
display_amps))
# **********************************************************************************************
def adc_process_values(self, raw_analog_digital_value):
analog_digital_volts = self.sense_ad_vin * (
raw_analog_digital_value / self.sense_ad_max_scaled_value)
scaled_value = (analog_digital_volts /
self.sense_scaling_factor_mv_amp)
self.log.debug(
"Analog_Digital converter switches_value: {} Scaled Value({})".
format(analog_digital_volts, scaled_value))
return analog_digital_volts, scaled_value
# ****************************************************************************************************************
def display_timer_run(self):
self.display_update()
self.gpio_manual_read_pin()
# ************************************************************************************
# call back from switch_polling
def poll_switch_callback(self, switches_value):
self.log.debug(
"onSwitchChangeValues :{:08b}".format(switches_value))
self.log.debug("knob values :{:08b}".format(
self.knob_values))
self.switch_values = switches_value
switches_value = (switches_value | self.knob_values)
self.log.debug(
"onSwitchChangeValues ORED:{:08b}".format(switches_value))
if switches_value & 0b00000001:
self.window.switch3_green.setVisible(True)
self.window.switch3_red.setVisible(False)
self.window.QDIAL_primary_gain.setStyleSheet(
'background-color: rgb(255, 0, 0)')
else:
self.window.switch3_green.setVisible(False)
self.window.switch3_red.setVisible(True)
self.window.QDIAL_primary_gain.setStyleSheet(
'background-color: rgb(191, 191, 191)')
if switches_value & 0b00000010:
self.window.switch4_green.setVisible(True)
self.window.switch4_red.setVisible(False)
self.window.QDIAL_secondary_gain.setStyleSheet(
'background-color: rgb(255, 0, 0)')
else:
self.window.switch4_green.setVisible(False)
self.window.switch4_red.setVisible(True)
self.window.QDIAL_secondary_gain.setStyleSheet(
'background-color: rgb(191, 191, 191)')
if switches_value & 0b00000100:
self.window.switch5_green.setVisible(True)
self.window.switch5_red.setVisible(False)
self.window.QDIAL_speed_0.setStyleSheet(
'background-color: rgb(255, 0, 0)')
else:
self.window.switch5_green.setVisible(False)
self.window.switch5_red.setVisible(True)
self.window.QDIAL_speed_0.setStyleSheet(
'background-color: rgb(191, 191, 191)')
if switches_value & 0b00001000:
self.window.switch6_green.setVisible(True)
self.window.switch6_red.setVisible(False)
self.window.QDIAL_speed_1.setStyleSheet(
'background-color: rgb(255, 0, 0)')
else:
self.window.switch6_green.setVisible(False)
self.window.switch6_red.setVisible(True)
self.window.QDIAL_speed_1.setStyleSheet(
'background-color: rgb(191, 191, 191)')
# if self.switches.primary_gain_pb_status == "ON":
# self.window.LBL_primary_gain_pb_status.setText("ON")
# self.digital_pots.gains_locked = False
# self.window.LBL_frequency_selected.setText("SEC")
# if self.switches.primary_gain_pb_status == "OFF":
# self.window.LBL_primary_gain_pb_status.setText("OFF")
# self.digital_pots.gains_locked = False
# if self.switches.primary_gain_pb_status == "CODERATE":
# self.window.LBL_primary_gain_pb_status.setText("CODERATE")
# self.digital_pots.gains_locked = False
# if self.switches.primary_gain_pb_status == "LOCKED":
# self.window.LBL_primary_gain_pb_status.setText("LOCKED")
# self.digital_pots.gains_locked = True
# self.primary_gain_pb_status = "NONE"
#
# if self.switches.secondary_gain_pb_status == "ON":
# self.window.LBL_secondary_gain_pb_status.setText("ON")
# if self.switches.secondary_gain_pb_status == "OFF":
# self.window.LBL_secondary_gain_pb_status.setText("OFF")
# if self.switches.secondary_gain_pb_status == "CODERATE":
# self.window.LBL_secondary_gain_pb_status.setText("CODERATE")
# if self.switches.secondary_gain_pb_status == "LOCKED":
# self.window.LBL_secondary_gain_pb_status.setText("LOCKED")
# self.secondary_gain_pb_status = "NONE"
#
# # self.lcd_switches.display(switch_value)
# self.thread_info()
# ****************************************************************************************************************
def speed_buttonstate_change(self, name, value):
if name == "SPEED0":
self.speed0.update_shape(shape=value)
elif name == "SPEED1":
self.speed1.update_shape(shape=value)
# ****************************************************************************************************************
def speed_callback(self, name, frequency):
"""
receives callback from the speed class to update screen
:rtype: object
"""
self.log.debug(
"Callback received from {} with switches_value of {}".format(
name, frequency))
if name == "SPEED0":
self.window.LBL_pri_tach_freq.setText("{:5.0f}".format(frequency))
if name == "SPEED1":
self.window.LBL_sec_tach_freq.setText("{:5.0f}".format(frequency))
self.log.debug("updated GUI ")
self.change_tab("SPEED")
# ****************************************************************************************************************
def change_tab(self, tab):
tabvalue = self.securitylevel.get_index_from_name(tab)
self.window.tabWidget.setCurrentIndex(tabvalue)
# ****************************************************************************************************************
def shape_get_values(self):
shape0 = self.speed0.shape
shape1 = self.speed1.shape
self.shape_update_gui("SPEED0", shape0)
self.shape_update_gui("SPEED1", shape1)
# ****************************************************************************************************************
def shape_update_gui(self, name, value):
if name == "SPEED0":
if value == self.config.FREQ_SHAPE_SINE:
self.window.BUTTON_speed0_sine.setChecked(True)
if value == self.config.FREQ_SHAPE_SQUARE:
self.window.BUTTON_speed0_square.setChecked(True)
if value == self.config.FREQ_SHAPE_TRIANGLE:
self.window.BUTTON_speed0_triangle.setChecked(True)
if name == "SPEED1":
if value == self.config.FREQ_SHAPE_SINE:
self.window.BUTTON_speed1_sine.setChecked(True)
if value == self.config.FREQ_SHAPE_SQUARE:
self.window.BUTTON_speed1_square.setChecked(True)
if value == self.config.FREQ_SHAPE_TRIANGLE:
self.window.BUTTON_speed1_triangle.setChecked(True)
# ****************************************************************************************************************
def gains_get_values(self):
gain0 = self.gain0.wiper_total_percentage
gain1 = self.gain1.wiper_total_percentage
self.gains_gui_update("GAIN0", gain0)
self.gains_gui_update("GAIN1", gain1)
# ****************************************************************************************************************
def speed_get_values(self):
speed0 = self.speed0.speed_frequency
speed1 = self.speed1.speed_frequency
self.speed_gui_update("SPEED0", speed0)
self.speed_gui_update("SPEED1", speed1)
# ****************************************************************************************************************
def gains_callback(self, name, gain):
"""
receives callback from the speed class to update screen
:rtype: object
"""
self.log.debug(
"Callback received from {} with switches_value of {}".format(
name, gain))
self.gains_gui_update(name, gain)
self.change_tab("CODERATE")
# ****************************************************************************************************************
def security_pressed(self):
self.log.debug("Security presssed")
self.securitywindow.window.show()
# ****************************************************************************************************************
def msgbtn(self, value):
self.log.debug("In MSG Button:{}".format(value))
# ****************************************************************************************************************
def SLIDER_duty_cycle_changed(self, value):
self.codegen.coded_carrier_generate(duty_cycle=value)
self.gui.window.LBL_duty_cycle.setText(str(value))
# ****************************************************************************************************************
def gains_gui_update(self, name, gain):
if name == "GAIN0":
if Gains.gains_locked == True:
self.gain1.set_value(self.gain0.value)
self.window.LBL_primary_gain_percent.setText(
"{0:.3%}".format(gain))
if name == "GAIN1":
# if Gains.gains_locked == True:
self.window.LBL_secondary_gain_percent.setText(
"{0:.3%}".format(gain))
# ****************************************************************************************************************
def speed_gui_update(self, name, frequency):
if name == "SPEED0":
self.window.LBL_pri_tach_freq.setText("{:5.0f}".format(frequency))
if name == "SPEED1":
self.window.LBL_sec_tach_freq.setText("{:5.0f}".format(frequency))
self.log.debug("updated GUI ")
# ****************************************************************************************************************
def speed_move_callback(self, name, direction, speed_increment):
"""
when the physical speed dial is moved this callback is activated. it causes the screen simulated
dial to move
:param name:
:param direction:
:param speed_increment:
"""
self.log.debug("Callback from:{} Direction:{} Speed:{}".format(
name, direction, speed_increment))
if name == "SPEED0":
if direction == 1:
self.speed0_val = self.speed0_val + 1
if direction == -1:
self.speed0_val = self.speed0_val - 1
self.window.QDIAL_speed_0.setValue(self.speed0_val)
if name == "SPEED1":
if direction == 1:
self.speed1_val = self.speed1_val + 1
if direction == -1:
self.speed1_val = self.speed1_val - 1
self.window.QDIAL_speed_1.setValue(self.speed1_val)
# ****************************************************************************************************************
def gain_move_callback(self, name, direction, speed_increment):
"""
when the physical speed dial is moved this callback is activated. it causes the screen simulated
dial to move
:param name:
:param direction:
:param speed_increment:
"""
self.log.debug("Callback from:{} Direction:{} Speed:{}".format(
name, direction, speed_increment))
if name == "GAIN0":
if direction == 1:
self.gain0_val = self.gain0_val + 1
if direction == -1:
self.gain0_val = self.gain0_val - 1
self.window.QDIAL_primary_gain.setValue(self.gain0_val)
if name == "GAIN1":
if direction == 1:
self.gain1_val = self.gain1_val + 1
if direction == -1:
self.gain1_val = self.gain1_val - 1
self.window.QDIAL_secondary_gain.setValue(self.gain1_val)
# ****************************************************************************************************************
def speed_simulate(self, name, sim_pins):
"""
when the on screen dial is rotated, this routine is called to simulate the physical pot turning
:param name:
:param sim_pins:
"""
self.log.debug("Simulating:{} PINS:{}".format(name, sim_pins))
if name == "SPEED0":
self.speed0.simulate(sim_pins)
if name == "SPEED1":
self.speed1.simulate(sim_pins)
# ****************************************************************************************************************
def gain_simulate(self, name, sim_pins):
"""
when the on screen dial is rotated, this routine is called to simulate the physical pot turning
:param name:
:param sim_pins:
"""
self.log.debug("Simulating:{} PINS:{}".format(name, sim_pins))
if name == "GAIN0":
self.gain0.simulate(sim_pins)
if name == "GAIN1":
self.gain1.simulate(sim_pins)
# ****************************************************************************************************************
def log_level_PB_changed(self, value):
self.log.debug("Log level PB pushed")
Commander.set_level = Commander.set_level + 10
self.log_level_set(Commander.set_level)
txt_level = self.log_level_to_text(Commander.set_level)
self.log_level_update_gui(txt_level)
if Commander.set_level == 50:
Commander.set_level = 0
# ****************************************************************************************************************
def log_level_set(self, setLevel):
self.log.debug("Set log level:{}".format(setLevel))
txt_level = self.log_level_to_text(setLevel)
self.log.setLevel(txt_level)
self.log.debug("Setting LOG LEVEL:{}".format(txt_level))
# ****************************************************************************************************************
def log_level_update_gui(self, value):
self.log.debug("SLog level update gui:{}".format(value))
self.window.PB_log_level.setText(value)
# ****************************************************************************************************************
def log_level_get(self):
level = self.log.getEffectiveLevel()
Commander.set_level = level
self.log.debug("Get log level:{}".format(level))
return level
# ****************************************************************************************************************
def log_level_first_start(self):
self.log.debug("Log level first start:{}")
level = self.log_level_get()
txt_level = self.log_level_to_text(level)
self.log_level_update_gui(txt_level)
# ****************************************************************************************************************
def log_level_to_text(self, value):
txtlevel = None
if value == 0:
txtlevel = "NOTSET"
elif value == 10:
txtlevel = "DEBUG"
elif value == 20:
txtlevel = "INFO"
elif value == 30:
txtlevel = "WARNING"
elif value == 40:
txtlevel = "ERROR"
elif value == 50:
value = -10
txtlevel = "CRITICAL"
self.log.debug("Convert Log level:{} to text:{}".format(
value, txtlevel))
return txtlevel
# *******************************************************************************************
def brightness_check(self):
# check and set brightness of LCD
brightness_value = self.support.brightness_query()
if brightness_value is not None:
self.support.brightness_set(brightness_value)
self.window.SPIN_brightness.setValue(int(brightness_value))
# *******************************************************************************************
# CATCH BRIGHTNESS BUTTON CHANGE
def brightness_changed(self, value):
if value >= self.screen_brightness_max:
value = self.screen_brightness_max
if value <= self.screen_brightness_min:
value = self.screen_brightness_min
self.log.debug('GUI brightness changed to ' + str(value))
self.support.brightness_set(value)
# *******************************************************************************************
def display_update(self):
cpu_percentage_numeric = psutil.cpu_percent()
cpu_percentage_string = 'CPU:{}'.format(psutil.getloadavg())
cpu_temperature_numeric = psutil.sensors_temperatures(fahrenheit=True)
cpu_temperature_degree = cpu_temperature_numeric.get(
"cpu-thermal")[0][1]
boot_time = datetime.datetime.fromtimestamp(
psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S")
memory = psutil.virtual_memory()
log = False
if log:
self.log.debug('LOCAL TIMER RUNNING...')
self.log.debug("CPU %: {}".format(cpu_percentage_numeric))
self.log.debug("CPU LOAD AVG : {}".format(cpu_percentage_string))
self.log.debug(
"CPU Temperature : {} def F".format(cpu_temperature_numeric))
self.log.debug("BootTime : {}".format(boot_time))
self.log.debug("Memory : {}".format(memory))
self.log.debug("THREADS RUNNING {0:d}".format(
threading.active_count()))
self.window.LBL_threads_value.setText(str(threading.active_count()))
str1 = ""
t_list = threading.enumerate()
for ele in t_list:
str1 += str(ele) + "\r\n"
self.window.LBL_t_list.setText(str(str1))
self.window.LBL_cpu_percent_value.setText(
"{:3.2f}".format(cpu_percentage_numeric))
self.window.LBL_cpu_temperature_value.setText(
"{:3.2f}".format(cpu_temperature_degree))
self.window.LBL_boot_time_value.setText(boot_time)
if not self.spi_log_pause:
self.window.TE_spi_log.insertPlainText(str(self.spi.data))
# *******************************************************************************************
def load_from_config(self):
self.rotary_0_pins = self.config.rotary_0_pins
self.rotary_1_pins = self.config.rotary_1_pins
self.rotary_2_pins = self.config.rotary_2_pins
self.rotary_3_pins = self.config.rotary_3_pins
self.rotary_0_pin_0_debounce = self.config.rotary_0_pin_0_debounce
self.rotary_0_pin_1_debounce = self.config.rotary_0_pin_1_debounce
self.rotary_1_pin_0_debounce = self.config.rotary_1_pin_0_debounce
self.rotary_1_pin_1_debounce = self.config.rotary_1_pin_1_debounce
self.rotary_2_pin_0_debounce = self.config.rotary_2_pin_0_debounce
self.rotary_2_pin_1_debounce = self.config.rotary_2_pin_1_debounce
self.rotary_3_pin_0_debounce = self.config.rotary_3_pin_0_debounce
self.rotary_3_pin_1_debounce = self.config.rotary_3_pin_1_debounce
self.gain_0_name = self.config.gain_0_name
self.gain_1_name = self.config.gain_1_name
self.gain_0_spi_channel = self.config.gain_0_spi_channel
self.gain_1_spi_channel = self.config.gain_0_spi_channel
self.gain_0_thresholds = self.config.gain_0_thresholds
self.gain_1_thresholds = self.config.gain_1_thresholds
self.GAIN_0_CS = self.config.GAIN_0_CS
self.GAIN_1_CS = self.config.GAIN_1_CS
self.speed_0_name = self.config.speed_0_name
self.speed_1_name = self.config.speed_1_name
self.speed_0_shape = self.config.speed_0_shape
self.speed_1_shape = self.config.speed_1_shape
self.speed_0_spi_channel = self.config.speed_0_spi_channel
self.speed_1_spi_channel = self.config.speed_0_spi_channel
self.SPEED_0_CS = self.config.SPEED_0_CS # 6 # SPEED SIMULATION TACH 1
self.SPEED_1_CS = self.config.SPEED_1_CS # 7 # SPEED SIMULATION TACH 2
self.speed_0_thresholds = self.config.SPEED_0_thresholds
self.speed_1_thresholds = self.config.SPEED_1_thresholds
self.display_timer_interval = self.config.display_timer_interval
self.poll_timer_interval = self.config.poll_timer_interval
self.screen_brightness_max = self.config.screen_brightness_max
self.screen_brightness_min = self.config.screen_brightness_min
self.display_brightness = self.config.display_brightness
self.display_amps_template = self.config.display_amps_template
self.loop_current_template = self.config.loop_current_template
self.adc_counts_template = self.config.adc_counts_template
self.adc_template = self.config.adc_template
self.adc_scale = self.config.adc_scale
self.sense_amp_max_amps = self.config.sense_amp_max_amps
self.sense_ad_vin = self.config.sense_ad_vin
self.sense_ad_max_bits = self.config.sense_ad_max_bits
self.sense_scaling_factor_mv_amp = self.config.sense_scaling_factor_mv_amp
self.sense_ad_max_scaled_value = 2**self.sense_ad_max_bits
# *******************************************************************************************
def exit_application(self, signum, frame):
self.log.debug("Received signal from signum: {} with frame:{}".format(
signum, frame))
self.shutdown()
# *******************************************************************************************
def shutdown(self):
self.log.info(
"***********************************************************************************************************"
)
self.log.info(
"***********************************************************************************************************"
)
self.log.info(
"***********************************************************************************************************"
)
self.log.info(
"***********************************************************************************************************"
)
self.log.info(
"***********************************************************************************************************"
)
self.log.info("Starting shutdown")
# self.gains.setval_and_store(0)
try:
self.poll_timer.stop()
self.gain0.set_value(0)
self.gain1.set_value(0)
self.speed0.set_value(0)
self.speed1.set_value(0)
self.codegen.off()
time.sleep(1)
self.log.critical("Goodbye...")
except Exception:
self.log.critical("Error shutting down TCP server")
try:
self.server.server_close()
except Exception:
self.log.critical("Error shutting down TCP server")
# self.log.info('Turning off screen saver forced on')
# subprocess.call('xset dpms force off', shell=True)
# self.log.shutdown()
sys.exit(0)