def __init__(self): super(Sensors, self).__init__() #create the sensore self.anemometer=Anemometer() self.hygrometer=Hygrometer() self.rain_gauge=RainGauge() self.thermometer=Thermometer()
def __init__(self):
self.temperature = 0
if not boxsettings.FAKE_DATA:
logging.debug("Not FAKE data")
self.thermometer = Thermometer()
else:
logging.debug("Not using sensors: fake data.")
class MaxMinThermometer(object):
"""
a maximum minimum thermometer which encapsulates (i.e. contains)
a thermometer and also stores min / max temperature data
"""
def __init__(self):
self.thermometer = Thermometer()
self.min = None
self.max = None
def get_measurement(self):
(temp, when) = self.thermometer.get_measurement()
self.update_max_min(temp)
return (temp, when)
def update_max_min(self, temp):
if self.min == None or self.min > temp:
self.min = temp
if self.max == None or self.max < temp:
self.max = temp
def reset_max_min(self):
self.min = None
self.max = None
def close(self):
self.thermometer.close()
def __init__(self, interval=INTERVAL, d_name=DEVICE_NAME):
os.system('modprobe w1-gpio')
os.system('modprobe w1-therm')
self.d_name = d_name
self.temp_sensor = os.path.join('/sys/bus/w1/devices', self.d_name,
'w1_slave')
Thermometer.__init__(self, interval)
def encoding(input, num_bits = 8):
inputs = []
th = Thermometer(input.data.min(), input.data.max(), num_bits)
for i in range(len(input.data)):
bit_array = bitarray(0)
row = input.data[i]
for elem in row:
bit_array.extend(th.code(elem))
inputs.append({"class" : input.target[i], "bitarray": bit_array})
return inputs
def config_from_file(self, a_path):
"""
Configure the Brewer instantiates elements and populates the Tank as described by the selected config file
:param a_path: path and name of the config file
:type a_path: String
"""
print "using path:"+a_path
with open(a_path) as f:
content = f.read()
f.close()
print "content"+content
y = BeautifulSoup(content,"xml")
self.__name = y.brewer['name']
self.__receipe=Receipe("Fill me !")
self.__receipe.config_from_file(y.brewer.receipe.contents[0])
thermo_tank=Thermometer(y.brewer.tank.equipments.thermometer['name'], y.brewer.tank.equipments.thermometer.path.contents[0])
if(y.brewer.tank['drivetype']=="BOOLEAN"):
self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, BOOLEAN)
elif(y.brewer.tank['drivetype']=="PID"):
self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, PID)
elif(y.brewer.tank['drivetype']=="PREDICTIVE"):
self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, PREDICTIVE)
elif(y.brewer.tank['drivetype']=="STEP_INERTIA"):
self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, STEP_INERTIA)
for a_heater in y.find_all('heater'):
self.__tank.add_heater(Heater(a_heater.get('name'),int(a_heater.get('power')),int(a_heater.get('GPIOpin'))))
for an_ingredient in y.find_all('ingredient'):
if(an_ingredient.get('type')=="Grain"):
self.__tank.add_ingredient(Ingredient(an_ingredient.get('name'),GRAIN,float(an_ingredient.get('quantity'))))
elif(an_ingredient.get('type')=="Water"):
self.__tank.add_ingredient(Ingredient(an_ingredient.get('name'),WATER,float(an_ingredient.get('quantity'))))
self.__outside_thermometer = Thermometer(y.brewer.outsidethermometer['name'],y.brewer.outsidethermometer.path.contents[0])
return self.__name
class GetSendTemp:
def __init__(self):
self.temperature = 0
if not boxsettings.FAKE_DATA:
logging.debug("Not FAKE data")
self.thermometer = Thermometer()
else:
logging.debug("Not using sensors: fake data.")
def fake_temperature(self):
deg_value = random.randint(3, 30)
deg_value += random.random()
return deg_value
def measure_temperature(self):
if boxsettings.FAKE_DATA:
self.temperature = self.fake_temperature()
logging.debug("Fake temperature: %s", self.temperature)
else:
try:
self.temperature = self.thermometer.read_temp()
logging.info("Temperature was read: %s", str(self.temperature))
except:
logging.warning("Error when reading temperature.")
def send_temperature(self):
logging.debug('GetSendTemp: send_temperature')
sender = Sender()
sender.send_deg(self.temperature)
def __init__(self):
cntr = counter(2)
meter = FluxMeter(70, 75)
thermos = {}
for i in range(2):
thermo = Thermometer(cntr, meter)
thermos[thermo.id] = thermo
self.thermos = thermos
class Sensors(object): """docstring for Sensors""" def __init__(self): super(Sensors, self).__init__() #create the sensore self.anemometer=Anemometer() self.hygrometer=Hygrometer() self.rain_gauge=RainGauge() self.thermometer=Thermometer() def getValue(self): temp = self.thermometer.getTemperature(); hum = self.hygrometer.getHumidity() wind_dir = self.anemometer.getWindDirection() wind_int = self.anemometer.getWindIntensity() rain = self.rain_gauge.getRain() return temp,hum,wind_dir,wind_int,rain
def build_page(layout, page):
layout.clear_widgets()
links.clear() # TODO: will prevent iframe functionality to work
for id, item in page.iteritems():
if item['type'] == 'button':
wgt = Button()
elif item['type'] == 'label':
wgt = Label()
elif item['type'] == 'var-label':
wgt = VariableLabel()
wgt.set_var(item['variable'])
elif item['type'] == 'led':
wgt = Led()
wgt.set_var(item['variable'])
elif item['type'] == 'thermometer':
wgt = Thermometer()
wgt.set_var(item['variable'])
elif item['type'] == 'manometer':
wgt = Manometer()
wgt.set_var(item['variable'])
elif item['type'] == 'edit-grid':
wgt = EditGrid()
wgt.set_dimenstion(item['rows'], item['cols'])
wgt.id = id
if 'text' in item:
wgt.text = item['text']
if 'font-size' in item:
wgt.font_size = item['font-size']
if 'pos' in item:
wgt.pos = eval(item['pos'])
if 'size' in item:
wgt.size = eval(item['size'])
if 'pos_hint' in item:
wgt.pos_hint = item['pos_hint']
if 'size_hint' in item:
wgt.size_hint = eval(item['size_hint'])
if 'link' in item:
links[wgt.id] = item['link']
wgt.bind(on_press=navigate)
if 'click' in item:
wgt.bind(on_press=eval(item['click']))
layout.add_widget(wgt)
from datetime import datetime
from thermometer import Thermometer
from program import app
from flask import render_template
thermo = Thermometer()
timenow = str(datetime.today())
@app.route('/')
@app.route('/index')
def index():
tp = f"{thermo.get_temp():.2f}"
tm = datetime.today().strftime("%H:%M:%S %m/%d/%Y")
return render_template('index.html',time=tm,temp=tp)
@app.route('/temp')
def get_temp():
return f"{thermo.get_temp():.2f}°F"
def createWidget(self, parent):
return Thermometer(parent)
def __init__(self, parent, cx, htrs):
self.cx = cx
self.htrs = htrs
title = "Connection %d" % (cx + 1)
wx.Frame.__init__(self, parent, wx.ID_ANY, title, (-1, -1), (-1, -1),
wx.DEFAULT_FRAME_STYLE & ~(wx.CLOSE_BOX))
self.Bind(wx.EVT_CLOSE, self.onClose)
sizer = wx.BoxSizer(wx.VERTICAL)
sizerLeft = wx.BoxSizer(wx.VERTICAL)
sizerRight = wx.BoxSizer(wx.VERTICAL)
grid = wx.GridBagSizer()
bfont = wx.Font(12, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_BOLD)
font = wx.Font(12, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_NORMAL)
row = 1
t = wx.StaticText(self, wx.ID_ANY, "Printer:", size=(160, -1))
t.SetFont(bfont)
grid.Add(t, (row, 0))
self.tPrtr = wx.StaticText(self, wx.ID_ANY, "", size=(200, -1))
self.tPrtr.SetFont(font)
grid.Add(self.tPrtr, (row, 1))
t = wx.StaticText(self, wx.ID_ANY, "Port:")
t.SetFont(bfont)
grid.Add(t, (row + 1, 0))
self.tPort = wx.StaticText(self, wx.ID_ANY, "")
self.tPort.SetFont(font)
grid.Add(self.tPort, (row + 1, 1))
t = wx.StaticText(self, wx.ID_ANY, "Status:")
t.SetFont(bfont)
grid.Add(t, (row + 2, 0))
self.tStat = wx.StaticText(self, wx.ID_ANY, "")
self.tStat.SetFont(font)
grid.Add(self.tStat, (row + 2, 1))
sizerLeft.Add(grid)
sizerLeft.AddSpacer((20, 20))
self.lFile = wx.StaticText(self, wx.ID_ANY, "")
self.lFile.SetFont(bfont)
sizerLeft.Add(self.lFile)
self.tFile = wx.StaticText(self, wx.ID_ANY, "")
self.tFile.SetFont(font)
sizerLeft.Add(self.tFile)
sizerLeft.AddSpacer((20, 20))
grid = wx.GridBagSizer()
row = 0
self.lStartTime = wx.StaticText(self, wx.ID_ANY, "", size=(160, -1))
self.lStartTime.SetFont(bfont)
grid.Add(self.lStartTime, (row, 0))
self.tStartTime = wx.StaticText(self, wx.ID_ANY, "", size=(200, -1))
self.tStartTime.SetFont(font)
grid.Add(self.tStartTime, (row, 1))
self.lExpDur = wx.StaticText(self, wx.ID_ANY, "")
self.lExpDur.SetFont(bfont)
grid.Add(self.lExpDur, (row + 1, 0))
self.tExpDur = wx.StaticText(self, wx.ID_ANY, "")
self.tExpDur.SetFont(font)
grid.Add(self.tExpDur, (row + 1, 1))
self.lOrigETA = wx.StaticText(self, wx.ID_ANY, "")
self.lOrigETA.SetFont(bfont)
grid.Add(self.lOrigETA, (row + 2, 0))
self.tOrigETA = wx.StaticText(self, wx.ID_ANY, "")
self.tOrigETA.SetFont(font)
grid.Add(self.tOrigETA, (row + 2, 1))
grid.AddSpacer((10, 10), (row + 3, 0))
row += 4
self.lElapsed = wx.StaticText(self, wx.ID_ANY, "")
self.lElapsed.SetFont(bfont)
grid.Add(self.lElapsed, (row, 0))
self.tElapsed = wx.StaticText(self, wx.ID_ANY, "")
self.tElapsed.SetFont(font)
grid.Add(self.tElapsed, (row, 1))
self.lRemaining = wx.StaticText(self, wx.ID_ANY, "")
self.lRemaining.SetFont(bfont)
grid.Add(self.lRemaining, (row + 1, 0))
self.tRemaining = wx.StaticText(self, wx.ID_ANY, "")
self.tRemaining.SetFont(font)
grid.Add(self.tRemaining, (row + 1, 1))
self.lNewETA = wx.StaticText(self, wx.ID_ANY, "")
self.lNewETA.SetFont(bfont)
grid.Add(self.lNewETA, (row + 2, 0))
self.tNewETA = wx.StaticText(self, wx.ID_ANY, "")
self.tNewETA.SetFont(font)
grid.Add(self.tNewETA, (row + 2, 1))
grid.AddSpacer((20, 20), (row + 3, 0))
row += 4
self.lHeight = wx.StaticText(self, wx.ID_ANY, "")
self.lHeight.SetFont(bfont)
grid.Add(self.lHeight, (row, 0))
self.tHeight = wx.StaticText(self, wx.ID_ANY, "")
self.tHeight.SetFont(font)
grid.Add(self.tHeight, (row, 1))
self.lLayer = wx.StaticText(self, wx.ID_ANY, "")
self.lLayer.SetFont(bfont)
grid.Add(self.lLayer, (row + 1, 0))
self.tLayer = wx.StaticText(self, wx.ID_ANY, "")
self.tLayer.SetFont(font)
grid.Add(self.tLayer, (row + 1, 1))
self.lGCode = wx.StaticText(self, wx.ID_ANY, "G Code")
self.lGCode.SetFont(bfont)
grid.Add(self.lGCode, (row + 2, 0))
self.tGCode = wx.StaticText(self, wx.ID_ANY, "")
self.tGCode.SetFont(font)
grid.Add(self.tGCode, (row + 2, 1))
sizerLeft.Add(grid)
sizerH = wx.BoxSizer(wx.HORIZONTAL)
sizerH.AddSpacer((20, 20))
sizerH.Add(sizerLeft)
sizerRight.AddSpacer((20, 20))
self.therm = {}
self.therm['Bed'] = Thermometer(self, "Print Bed")
sizerRight.Add(self.therm['Bed'])
sizerRight.AddSpacer((10, 10))
k = "temps::connection.%d::temps::temps::HE0" % (self.cx + 1)
if k in self.htrs:
self.therm['HE0'] = Thermometer(self, "Hot End 0")
sizerRight.Add(self.therm['HE0'])
sizerRight.AddSpacer((10, 10))
k = "temps::connection.%d::temps::temps::HE1" % (self.cx + 1)
if k in self.htrs:
self.therm['HE1'] = Thermometer(self, "Hot End 1")
sizerRight.Add(self.therm['HE1'])
sizerRight.AddSpacer((10, 10))
sizerRight.AddSpacer((10, 10))
sizerH.Add(sizerRight, 1, wx.EXPAND)
sizerH.AddSpacer((20, 20))
sizer.Add(sizerH)
self.SetSizer(sizer)
self.Layout()
self.Fit()
class Brewer:
"""
A brewer uses the thermometers and heaters in order to follow the receipe. Each brewer has a single tank who knows its own composition in order to perform kick-ass calculations'
"""
def __init__(self):
"""
Constructor
"""
self.__name = None
self.__outside_thermometer = None
self.__tank = None
self.__receipe = None
self.__brewing_started = False
def config_from_file(self, a_path):
"""
Configure the Brewer instantiates elements and populates the Tank as described by the selected config file
:param a_path: path and name of the config file
:type a_path: String
"""
print "using path:"+a_path
with open(a_path) as f:
content = f.read()
f.close()
print "content"+content
y = BeautifulSoup(content,"xml")
self.__name = y.brewer['name']
self.__receipe=Receipe("Fill me !")
self.__receipe.config_from_file(y.brewer.receipe.contents[0])
thermo_tank=Thermometer(y.brewer.tank.equipments.thermometer['name'], y.brewer.tank.equipments.thermometer.path.contents[0])
if(y.brewer.tank['drivetype']=="BOOLEAN"):
self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, BOOLEAN)
elif(y.brewer.tank['drivetype']=="PID"):
self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, PID)
elif(y.brewer.tank['drivetype']=="PREDICTIVE"):
self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, PREDICTIVE)
elif(y.brewer.tank['drivetype']=="STEP_INERTIA"):
self.__tank=Tank(y.brewer.tank['name'],int(y.brewer.tank['diameter']),thermo_tank, STEP_INERTIA)
for a_heater in y.find_all('heater'):
self.__tank.add_heater(Heater(a_heater.get('name'),int(a_heater.get('power')),int(a_heater.get('GPIOpin'))))
for an_ingredient in y.find_all('ingredient'):
if(an_ingredient.get('type')=="Grain"):
self.__tank.add_ingredient(Ingredient(an_ingredient.get('name'),GRAIN,float(an_ingredient.get('quantity'))))
elif(an_ingredient.get('type')=="Water"):
self.__tank.add_ingredient(Ingredient(an_ingredient.get('name'),WATER,float(an_ingredient.get('quantity'))))
self.__outside_thermometer = Thermometer(y.brewer.outsidethermometer['name'],y.brewer.outsidethermometer.path.contents[0])
return self.__name
def get_name(self):
"""
Returns the name of the Brewer
:return: Name of the Brewer
:rtype: Sting
"""
return self.__name
def print_self(self):
"""
Returns the Brewer as a human readable String ended with a new line
:return: A String detailling the caracteristics of the Brewer
:rtype: String
"""
to_print="Name : "+self.__name
to_print+="Outside thermometer : "+self.__outside_thermometer.print_self()
to_print+="Tank : "+self.__tank.print_self()
to_print+="Receipe : "+self.__receipe.print_self()+"\n"
return to_print
def init_brewing(self):
"""
Checks that everything is ready for brewing and starts the receipe
:return: A Boolean True = started OK, False for any anomaly
:rtype: Boolean
"""
if(self.__name == None or self.__tank == None or self.__receipe == None or self.__brewing_started == True):return False
self.__brewing_started = True
self.__receipe.start(self.__tank.get_current_temperature())
print "***************************************************"
print "Updated receipe "+self.__receipe.print_self()
return True
def log_temperatures(self,a_file):
"""
This function logs in the desired output file the temperature state of the system.
:param a_file: path and name of the file where all temperature will be reccorded
:type a_file: String
"""
f=open(a_file, "a")
try:
f.write(str(datetime.datetime.now().strftime('%H:%M:%S'))+"\t"+unicodedata.normalize('NFKD',self.__receipe.get_current_step().get_name()).encode('ascii','ignore')+"\t"+str(self.__receipe.get_current_temperature_instruction())+"\t"+str(self.__tank.get_current_temperature())+"\t"+str(self.__tank.get_heating_status())+"\n")
except:
print "Unexpected log write error"
f.close()
def brew(self,a_outputfile):
"""
This function is the main brewing function : ajusting the temperature according to the receipe. Function to be called regularily (every 5 seconds for instance).
:param a_outputfile: path and name of the file where all temperature will be reccorded
:type a_outputfile: String
"""
while 1==1 :
self.__receipe.update_step()
if(self.__receipe.get_current_step().get_type()==TRANSITION):
if(self.__tank.get_current_temperature()>=self.__receipe.get_next_temperature_instruction()): #Only works as long as transitions go from lower to higher temperatures...
self.__receipe.transition_complete()
if(self.__receipe.get_current_step()==None):
print "Receipe completed"
return True
#self.__tank.temperature_hysteresis_drive(self.__receipe.get_current_temperature_instruction())
#self.__tank.temperature_inertia_drive(self.__receipe.get_current_temperature_instruction(), self.__receipe.get_next_temperature_instruction())
#self.__tank.temperature_model_drive(self.__receipe.get_current_temperature_instruction(), self.__receipe.get_next_temperature_instruction(),self.__outside_thermometer.read_temperature())
self.__tank.temperature_step_inertia_drive(self.__receipe.get_current_temperature_instruction(), self.__receipe.get_next_temperature_instruction(),self.__receipe.get_current_step().get_inertia())
print "Current step : "+self.__receipe.get_current_step().print_self()
print "Temperature instuction : "+str(self.__receipe.get_current_temperature_instruction())
print "Next Temperature instuction : "+str(self.__receipe.get_next_temperature_instruction())
print "Current temperature : "+str(self.__tank.get_current_temperature())
self.log_temperatures(a_outputfile)
print 'Type "N" if you want to skip the current step',
rlist, _, _ = select([sys.stdin], [], [], UPDATE_PERIOD)
if rlist:
s = sys.stdin.readline()
if(s == "N\n"):
print "Skip order received"
self.__receipe.user_force_next_step()
else:
print "No input. Moving on..."
def __init__(self, interval=INTERVAL):
Thermometer.__init__(self, interval)
# encoding: utf-8
from thermometer import Thermometer
from resmeasure import ResMeasure
import socket
ip_port = ("192.168.0.150", 50052)
client = socket.socket()
client.connect(ip_port)
while True:
cont = client.recv(1024).decode() ##python 3.5 转型
# w= 0.01
c = float(cont) / 100
r = ResMeasure().get_res(c)
t = Thermometer().read(r)
# print('当前电阻是：','%.2f' % r,'Ω')
print('当前温度是：', '%.2f' % t, '℃')
client.close()
def __init__(self):
self.thermometer = Thermometer()
self.min = None
self.max = None
class Trainer(object):
def __init__(self):
###############
# load config #
###############
with open('trainer_config.yaml') as f:
CONFIG = yaml.load(f)
self.exp_type = CONFIG['experiment-type']
self.playback_bool = CONFIG['playback-enabled']
self.subj_id = CONFIG['subject-id']
self.subj_dir = 'datasets/' + self.subj_id
if self.exp_type == 'timed':
fu.write_all_headers_timed(self)
elif self.exp_type == 'block':
fu.write_all_headers_block(self)
#################
# set constants #
#################
self.FRAME_RATE = 30
self.SCREEN_WIDTH, self.SCREEN_HEIGHT = 1024, 768
self.BG_COLOR_REG = 70,70,70
self.BG_COLOR_REG_2 = 110,110,110
self.BG_COLOR_REG_3 = 40,40,40
self.SUCCESS_COLOR = 70,170,70
self.INDICATOR_COLOR = 40,60,40
self.INDICATOR_COLOR_2 = 30,100,30
self.GOOD_MSG_COLOR = 160,255,160
self.BAD_MSG_COLOR = 255,160,160
self.A_MSG_COLOR = 160,160,255
self.B_MSG_COLOR = 230,230,160
self.SENSOR_INPUT_OFFSET = np.array([0.5*self.SCREEN_WIDTH,
0.5*self.SCREEN_HEIGHT])
self.NEWTONS_2_PIXEL = 200
self.BLOCK_TIME = CONFIG['block-length']
self.RESET_HOLD_TIME = 0.5
self.REACH_SUCCESS_TIME = 2.
self.NOISE_VAR_GOOD = 0.025
if not self.playback_bool:
self.NOISE_VAR_BAD = 10*self.NOISE_VAR_GOOD
else:
self.NOISE_VAR_BAD = self.NOISE_VAR_GOOD
self.SAMPLE_PERIOD = 2.
self.SAMPLE_FRAMES = self.SAMPLE_PERIOD*self.FRAME_RATE
self.TRS_SHOW_UPDATE_RATE = 2
self.TR_LIST = (0.125, .25, 0.5, 1., 2., 4.)
self.TRS_SAMPLES_DICT = dict((tr, tr/self.SAMPLE_PERIOD)
for tr in self.TR_LIST)
self.TRS_SUCCESS_DICT = dict((tr, self.REACH_SUCCESS_TIME/tr)
for tr in self.TR_LIST)
self.BUFFER_DIST = 0.075*self.SCREEN_HEIGHT
self.START_DIST = self.BUFFER_DIST
self.GAME_ORIGIN = (0.5*self.SCREEN_WIDTH-0.5*self.SCREEN_HEIGHT,
self.SCREEN_HEIGHT)
self.START_COORDS = np.array([self.GAME_ORIGIN[0]+self.BUFFER_DIST,
self.GAME_ORIGIN[1]-self.BUFFER_DIST])
self.TARGET_DIST = (0.3*self.SCREEN_HEIGHT,
0.8*self.SCREEN_HEIGHT)
self.ERROR_CUTOFF = self.TARGET_DIST[0] - self.START_DIST
self.MIN_ERROR_METRIC = 0.1
self.SS_ERROR_METRIC = 0.9
self.MIN_SUCCESS_SCORE = 0.7
self.TARGET_RAD = (self.ERROR_CUTOFF*
(1-(self.MIN_SUCCESS_SCORE-self.MIN_ERROR_METRIC)
/(self.SS_ERROR_METRIC-self.MIN_ERROR_METRIC)))
if SENSOR_ACTIVE:
self.daq = Pydaq('Dev1/ai0:1', self.FRAME_RATE)
self.VISIBLE_TRIALS = CONFIG['visible-trials']
self.INVISIBLE_TRIALS = CONFIG['invisible-trials']
self.NUM_TRIALS = self.VISIBLE_TRIALS
self.TRIAL_TYPES = 8
####################################################
# start pygame and initialize default game objects #
####################################################
pygame.init()
pygame.mouse.set_visible(not pygame.mouse.set_visible)
self.clock = pygame.time.Clock()
if CONFIG['fullscreen']:
self.screen = pygame.display.set_mode(
(self.SCREEN_WIDTH, self.SCREEN_HEIGHT),
pygame.FULLSCREEN)
else:
self.screen = pygame.display.set_mode(
(self.SCREEN_WIDTH, self.SCREEN_HEIGHT))
##################################
# initialize custom game objects #
##################################
self.cursor = Cursor(self.screen)
self.target = Target(self.screen,
self.FRAME_RATE,
self.TARGET_RAD,
self.ERROR_CUTOFF,
self.MIN_ERROR_METRIC,
self.SS_ERROR_METRIC,
self.MIN_SUCCESS_SCORE,
self.START_COORDS,
self.TARGET_DIST)
self.therm = Thermometer(self.screen,
self.MIN_ERROR_METRIC,
self.MIN_SUCCESS_SCORE,
self.SS_ERROR_METRIC)
self.INDIC_RAD_MAX = self.START_DIST-self.cursor.RAD-2
self.target.target_lims = self.TARGET_DIST
self.timers = {}
self.init_timers()
self.set_tr(2.)
self.trial_count = 0
self.trial_type_count = 1
self.next_dof = 1
self.set_dof(self.next_dof)
self.next_ir = 'impulse'
self.next_visible = True
self.set_trial()
######################
# set game variables #
######################
self.screen_mid = np.array([0.5*self.screen.get_width(),
0.5*self.screen.get_height()])
self.bg_color = self.BG_COLOR_REG
self.bg_color_alt = self.BG_COLOR_REG_2
self.bg_color_alt_2 = self.BG_COLOR_REG_3
self.indicator_color = self.INDICATOR_COLOR
self.indicator_rad = 0*self.START_DIST
self.success_color = self.SUCCESS_COLOR
self.input_mode = 'mouse'
self.input_pos = np.array([0.0,0.0])
self.training_mode = True
#######################
# set block variables #
#######################
self.NUM_BLOCK_TRIALS = CONFIG['num-block-trials']
self.next_target = 'new'
self.first_feedback = CONFIG['first-trial-feedback']
self.first_noise = CONFIG['first-trial-noise']
self.next_feedback = self.first_feedback
self.next_noise = self.first_noise
self.set_noise()
self.BLOCK_TRS = self.BLOCK_TIME/self.tr
self.block_nfb_buffer = np.zeros(self.BLOCK_TRS)
self.block_tr_count = 0
self.total_block_count = 0
self.trial_block_count = 0
##########################
# set playback variables #
##########################
self.TIME_SHIFT = 6
self.PLAYBACK_TRS = self.BLOCK_TRS + self.TIME_SHIFT/self.tr
self.EXTRA_TRS = 2
self.playback_buffer_length = (self.BLOCK_TIME
+ self.EXTRA_TRS)*self.FRAME_RATE
self.move_counter = 0
self.reset_playback_buffers()
def reset_playback_buffers(self):
self.playback_counter = 0
self.playback_time_buffer = np.zeros(self.playback_buffer_length)
self.playback_pos_buffer = np.zeros((2,self.playback_buffer_length))
self.playback_nfb_buffer = np.zeros(self.playback_buffer_length)
self.playback_nfb_points = np.zeros(self.PLAYBACK_TRS)
def get_pos(self):
if self.input_mode=='mouse' or not(SENSOR_ACTIVE):
return pygame.mouse.get_pos()
else:
f_out = self.daq.get_force()
return (self.SENSOR_INPUT_OFFSET[0]+self.NEWTONS_2_PIXEL*f_out[0],
self.SENSOR_INPUT_OFFSET[1]+self.NEWTONS_2_PIXEL*f_out[1])
def set_trial(self):
self.set_dof(self.next_dof)
self.target.set_fb_mode(self.next_ir)
self.set_training_mode(self.next_visible)
def set_noise(self):
if self.next_noise == 'good':
self.noise_var = self.NOISE_VAR_GOOD
elif self.next_noise == 'bad':
self.noise_var = self.NOISE_VAR_BAD
def set_training_mode(self, bool_arg):
self.training_mode = bool_arg
def set_tr(self, tr):
if tr == 0.125:
self.tr = 0.125
self.timers['tr'] = self.timers['tr_8hz']
elif tr == 0.25:
self.tr = 0.25
self.timers['tr'] = self.timers['tr_4hz']
elif tr == 0.5:
self.tr = 0.5
self.timers['tr'] = self.timers['tr_2hz']
elif tr == 1:
self.tr = 1.
self.timers['tr'] = self.timers['tr_1hz']
elif tr == 2:
self.tr = 2.
self.timers['tr'] = self.timers['tr_p5hz']
elif tr == 4:
self.tr = 4.
self.timers['tr'] = self.timers['tr_p25hz']
def init_timers(self):
self.timers['signal'] = Timer(self.SAMPLE_PERIOD)
self.timers['tr_8hz'] = Timer(self.TR_LIST[0])
self.timers['tr_4hz'] = Timer(self.TR_LIST[1])
self.timers['tr_2hz'] = Timer(self.TR_LIST[2])
self.timers['tr_1hz'] = Timer(self.TR_LIST[3])
self.timers['tr_p5hz'] = Timer(self.TR_LIST[4])
self.timers['tr_p25hz'] = Timer(self.TR_LIST[5])
self.timers['tr'] = self.timers['tr_2hz']
self.timers['reach'] = Timer(0)
self.timers['reach_hold'] = Timer(self.REACH_SUCCESS_TIME)
self.timers['block'] = Timer(self.BLOCK_TIME)
self.timers['reset_hold'] = Timer(self.RESET_HOLD_TIME)
def reset_all_timers(self):
for k,t in self.timers.iteritems():
t.reset()
def check_input(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.quit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.quit()
elif event.key == pygame.K_0:
self.daq.set_volts_zero()
elif event.key == pygame.K_f:
if self.dof == 1:
self.set_dof(2)
elif self.dof == 2:
self.set_dof(1)
elif event.key == pygame.K_b:
self.target.set_new_target()
elif event.key == pygame.K_v:
self.training_mode = not(self.training_mode)
elif event.key == pygame.K_c:
self.target.set_fb_mode('hrf')
elif event.key == pygame.K_x:
self.target.set_fb_mode('impulse')
elif event.key == pygame.K_m:
if self.input_mode == 'mouse':
self.input_mode = 'sensor'
elif self.input_mode == 'sensor':
self.input_mode = 'mouse'
def run_timed(self):
###########################################
# main loop for time-to-target experiment #
###########################################
while True:
time_passed = self.clock.tick_busy_loop(self.FRAME_RATE)
self.check_input()
self.input_pos = self.get_pos()
self.cursor.update(self.input_pos)
self.target.update(self.cursor.pos)
if not(self.timers['reset_hold'].time_limit_hit):
gr.check_in_start(self, time_passed)
self.target.draw_bool = True
elif not(self.cursor.has_left):
gr.check_if_left(self)
self.target.draw_bool = False
elif self.training_mode:
self.target.draw_bool = True
else:
self.target.draw_bool = False
if self.cursor.has_left:
gr.frame_based_updates_timed(self)
self.timers['signal'].update(time_passed)
self.timers['tr'].update(time_passed)
if self.timers['signal'].time_limit_hit:
gr.signal_based_updates(self)
if self.timers['tr'].time_limit_hit:
gr.tr_based_updates(self)
self.draw_background()
self.therm.draw(self.cursor.has_left,
self.target.error_metric)
self.target.draw()
if (self.trial_count == 0
and not self.cursor.has_left):
self.draw_instructions_timed()
self.cursor.draw()
pygame.display.flip()
def run_block(self):
###########################################
# main loop for block feedback experiment #
###########################################
self.target.draw_bool = False
if self.playback_bool:
self.set_dof(2)
else:
self.set_dof(1)
self.target.set_fb_mode('hrf')
while True:
time_passed = self.clock.tick_busy_loop(self.FRAME_RATE)
self.check_input()
self.input_pos = self.get_pos()
self.cursor.update(self.input_pos)
self.target.update(self.cursor.pos)
if not(self.timers['reset_hold'].time_limit_hit):
gr.check_in_start(self, time_passed)
if self.next_target == 'new':
self.target.draw_bool = True
elif not(self.cursor.has_left):
gr.check_if_left(self)
self.target.draw_bool = False
# debugging
# self.target.draw_bool = True
if self.cursor.has_left:
gr.frame_based_updates_block(self)
self.timers['signal'].update(time_passed)
self.timers['tr'].update(time_passed)
self.timers['block'].update(time_passed)
if self.timers['signal'].time_limit_hit:
gr.signal_based_updates(self)
if self.timers['tr'].time_limit_hit:
gr.tr_based_updates(self)
if self.timers['block'].time_limit_hit:
gr.block_based_updates(self)
self.draw_background()
therm_draw_bool = ((self.cursor.has_left and
self.next_feedback == 'continuous')
or (self.total_block_count > 0
and not self.cursor.has_left))
score = self.target.error_metric
self.therm.draw(therm_draw_bool,
score)
self.target.draw()
if not self.cursor.has_left:
self.draw_instructions_block()
else:
self.therm.set_score_color('norm')
self.cursor.draw()
pygame.display.flip()
def run_playback(self):
while self.move_counter > 0:
time_passed = self.clock.tick_busy_loop(self.FRAME_RATE)
self.check_input()
self.cursor.update(self.playback_pos_buffer[:,
self.playback_counter])
self.indicator_rad = int(self.INDIC_RAD_MAX*(
self.playback_time_buffer[self.playback_counter]
/float(self.timers['block'].MAX_TIME)))
self.draw_background()
self.therm.draw(True,
self.playback_nfb_buffer[self.playback_counter])
# debugging
# self.target.draw()
self.cursor.draw()
pygame.display.flip()
self.move_counter -= 1
self.playback_counter += 1
def set_dof(self, dof):
self.dof = dof
self.cursor.set_dof(dof)
self.target.set_dof(dof)
def draw_background(self):
self.screen.fill(self.bg_color_alt_2)
gr.cap_indicator_rad(self)
self.draw_play_area()
if self.indicator_rad > 0:
self.draw_indicator()
def draw_instructions_block(self):
if self.next_target == 'new':
top_msg = 'New target'
top_color = self.GOOD_MSG_COLOR
else:
top_msg = 'Same target'
top_color = self.BAD_MSG_COLOR
if self.next_feedback == 'continuous':
mid_msg = 'Continuous feedback'
mid_color = self.A_MSG_COLOR
else:
mid_msg = 'Intermittent feedback'
mid_color = self.B_MSG_COLOR
if self.next_noise == 'good':
btm_msg = 'Good signal'
btm_color = self.A_MSG_COLOR
else:
btm_msg = 'Bad signal'
btm_color = self.B_MSG_COLOR
gg.draw_msg(self.screen, top_msg,
color=top_color,
center=(self.screen_mid[0],
self.screen_mid[1]-75))
gg.draw_msg(self.screen, mid_msg,
color=mid_color,
center=(self.screen_mid[0],
self.screen_mid[1]))
if not self.playback_bool:
gg.draw_msg(self.screen, btm_msg,
color=btm_color,
center=(self.screen_mid[0],
self.screen_mid[1]+75))
def draw_instructions_timed(self):
if self.next_visible:
top_msg = 'Target visible'
top_color = self.GOOD_MSG_COLOR
else:
top_msg = 'Target invisible'
top_color = self.BAD_MSG_COLOR
if self.next_ir == 'impulse':
btm_msg = 'Instant feedback'
btm_color = self.GOOD_MSG_COLOR
else:
btm_msg = 'Delayed feedback'
btm_color = self.BAD_MSG_COLOR
gg.draw_msg(self.screen, top_msg,
color=top_color,
center=(self.screen_mid[0],
self.screen_mid[1]-50))
gg.draw_msg(self.screen, btm_msg,
color=btm_color,
center=(self.screen_mid[0],
self.screen_mid[1]+50))
def draw_play_area(self):
if self.dof == 1:
gg.draw_center_rect(self.screen,
self.SCREEN_HEIGHT, self.SCREEN_HEIGHT,
self.bg_color,
self.screen_mid[0], self.screen_mid[1])
gg.draw_center_rect(self.screen,
self.TARGET_DIST[1]-self.TARGET_DIST[0],
self.SCREEN_HEIGHT,
self.bg_color_alt,
(self.TARGET_DIST[0]
+0.5*(self.TARGET_DIST[1]
-self.TARGET_DIST[0])
+ self.START_COORDS[0]),
self.screen_mid[1])
gg.draw_center_rect(self.screen,
2*(self.START_DIST-self.cursor.RAD),
self.SCREEN_HEIGHT,
self.bg_color_alt_2,
self.START_COORDS[0], self.screen_mid[1])
elif self.dof == 2:
gg.draw_center_rect(self.screen,
self.SCREEN_HEIGHT, self.SCREEN_HEIGHT,
self.bg_color,
self.screen_mid[0], self.screen_mid[1])
gg.draw_filled_aacircle(self.screen,
self.TARGET_DIST[1],
self.bg_color_alt,
self.START_COORDS[0], self.START_COORDS[1])
gg.draw_filled_aacircle(self.screen,
self.TARGET_DIST[0],
self.bg_color,
self.START_COORDS[0], self.START_COORDS[1])
gg.draw_center_rect(self.screen,
self.SCREEN_HEIGHT, 2*self.BUFFER_DIST,
self.bg_color,
self.screen_mid[0], self.GAME_ORIGIN[1])
gg.draw_center_rect(self.screen,
2*self.BUFFER_DIST, self.SCREEN_HEIGHT,
self.bg_color,
self.GAME_ORIGIN[0], self.screen_mid[1])
gg.draw_filled_aacircle(self.screen,
self.START_DIST-self.cursor.RAD,
self.bg_color_alt_2,
self.START_COORDS[0], self.START_COORDS[1])
def draw_indicator(self):
if self.dof == 1:
gg.draw_center_rect(self.screen,
2*self.indicator_rad, self.SCREEN_HEIGHT,
self.indicator_color,
self.START_COORDS[0], self.screen_mid[1])
elif self.dof == 2:
gg.draw_filled_aacircle(self.screen,
self.indicator_rad,
self.indicator_color,
self.START_COORDS[0], self.START_COORDS[1])
def quit(self):
sys.exit()
log("File imports sucessful!")
VERBOSE = True
HOST = "0.0.0.0"
DEVICE_PORT = 24601
ADC_PIN = 0
generate_auth_key_if_not_exists()
"""
Unfortunately micropython on the ESP8266 does not support threading at this point
and so only 1 request can be processed at once, however this should be fine as
request collisions should not occur very often.
"""
thermometer = Thermometer(ADC_PIN)
"""
log() logs the string to a text file ("log.txt") which we can have a look at
incase anything goes wrong or we need to see what requests have been occuring
on the device.
"""
log("Thermometer object instantiated!")
# Connection Manager
sk = socket.socket()
sk.bind((HOST, DEVICE_PORT))
sk.listen(1)
while True:
def __init__(self):
###############
# load config #
###############
with open('trainer_config.yaml') as f:
CONFIG = yaml.load(f)
self.exp_type = CONFIG['experiment-type']
self.playback_bool = CONFIG['playback-enabled']
self.subj_id = CONFIG['subject-id']
self.subj_dir = 'datasets/' + self.subj_id
if self.exp_type == 'timed':
fu.write_all_headers_timed(self)
elif self.exp_type == 'block':
fu.write_all_headers_block(self)
#################
# set constants #
#################
self.FRAME_RATE = 30
self.SCREEN_WIDTH, self.SCREEN_HEIGHT = 1024, 768
self.BG_COLOR_REG = 70,70,70
self.BG_COLOR_REG_2 = 110,110,110
self.BG_COLOR_REG_3 = 40,40,40
self.SUCCESS_COLOR = 70,170,70
self.INDICATOR_COLOR = 40,60,40
self.INDICATOR_COLOR_2 = 30,100,30
self.GOOD_MSG_COLOR = 160,255,160
self.BAD_MSG_COLOR = 255,160,160
self.A_MSG_COLOR = 160,160,255
self.B_MSG_COLOR = 230,230,160
self.SENSOR_INPUT_OFFSET = np.array([0.5*self.SCREEN_WIDTH,
0.5*self.SCREEN_HEIGHT])
self.NEWTONS_2_PIXEL = 200
self.BLOCK_TIME = CONFIG['block-length']
self.RESET_HOLD_TIME = 0.5
self.REACH_SUCCESS_TIME = 2.
self.NOISE_VAR_GOOD = 0.025
if not self.playback_bool:
self.NOISE_VAR_BAD = 10*self.NOISE_VAR_GOOD
else:
self.NOISE_VAR_BAD = self.NOISE_VAR_GOOD
self.SAMPLE_PERIOD = 2.
self.SAMPLE_FRAMES = self.SAMPLE_PERIOD*self.FRAME_RATE
self.TRS_SHOW_UPDATE_RATE = 2
self.TR_LIST = (0.125, .25, 0.5, 1., 2., 4.)
self.TRS_SAMPLES_DICT = dict((tr, tr/self.SAMPLE_PERIOD)
for tr in self.TR_LIST)
self.TRS_SUCCESS_DICT = dict((tr, self.REACH_SUCCESS_TIME/tr)
for tr in self.TR_LIST)
self.BUFFER_DIST = 0.075*self.SCREEN_HEIGHT
self.START_DIST = self.BUFFER_DIST
self.GAME_ORIGIN = (0.5*self.SCREEN_WIDTH-0.5*self.SCREEN_HEIGHT,
self.SCREEN_HEIGHT)
self.START_COORDS = np.array([self.GAME_ORIGIN[0]+self.BUFFER_DIST,
self.GAME_ORIGIN[1]-self.BUFFER_DIST])
self.TARGET_DIST = (0.3*self.SCREEN_HEIGHT,
0.8*self.SCREEN_HEIGHT)
self.ERROR_CUTOFF = self.TARGET_DIST[0] - self.START_DIST
self.MIN_ERROR_METRIC = 0.1
self.SS_ERROR_METRIC = 0.9
self.MIN_SUCCESS_SCORE = 0.7
self.TARGET_RAD = (self.ERROR_CUTOFF*
(1-(self.MIN_SUCCESS_SCORE-self.MIN_ERROR_METRIC)
/(self.SS_ERROR_METRIC-self.MIN_ERROR_METRIC)))
if SENSOR_ACTIVE:
self.daq = Pydaq('Dev1/ai0:1', self.FRAME_RATE)
self.VISIBLE_TRIALS = CONFIG['visible-trials']
self.INVISIBLE_TRIALS = CONFIG['invisible-trials']
self.NUM_TRIALS = self.VISIBLE_TRIALS
self.TRIAL_TYPES = 8
####################################################
# start pygame and initialize default game objects #
####################################################
pygame.init()
pygame.mouse.set_visible(not pygame.mouse.set_visible)
self.clock = pygame.time.Clock()
if CONFIG['fullscreen']:
self.screen = pygame.display.set_mode(
(self.SCREEN_WIDTH, self.SCREEN_HEIGHT),
pygame.FULLSCREEN)
else:
self.screen = pygame.display.set_mode(
(self.SCREEN_WIDTH, self.SCREEN_HEIGHT))
##################################
# initialize custom game objects #
##################################
self.cursor = Cursor(self.screen)
self.target = Target(self.screen,
self.FRAME_RATE,
self.TARGET_RAD,
self.ERROR_CUTOFF,
self.MIN_ERROR_METRIC,
self.SS_ERROR_METRIC,
self.MIN_SUCCESS_SCORE,
self.START_COORDS,
self.TARGET_DIST)
self.therm = Thermometer(self.screen,
self.MIN_ERROR_METRIC,
self.MIN_SUCCESS_SCORE,
self.SS_ERROR_METRIC)
self.INDIC_RAD_MAX = self.START_DIST-self.cursor.RAD-2
self.target.target_lims = self.TARGET_DIST
self.timers = {}
self.init_timers()
self.set_tr(2.)
self.trial_count = 0
self.trial_type_count = 1
self.next_dof = 1
self.set_dof(self.next_dof)
self.next_ir = 'impulse'
self.next_visible = True
self.set_trial()
######################
# set game variables #
######################
self.screen_mid = np.array([0.5*self.screen.get_width(),
0.5*self.screen.get_height()])
self.bg_color = self.BG_COLOR_REG
self.bg_color_alt = self.BG_COLOR_REG_2
self.bg_color_alt_2 = self.BG_COLOR_REG_3
self.indicator_color = self.INDICATOR_COLOR
self.indicator_rad = 0*self.START_DIST
self.success_color = self.SUCCESS_COLOR
self.input_mode = 'mouse'
self.input_pos = np.array([0.0,0.0])
self.training_mode = True
#######################
# set block variables #
#######################
self.NUM_BLOCK_TRIALS = CONFIG['num-block-trials']
self.next_target = 'new'
self.first_feedback = CONFIG['first-trial-feedback']
self.first_noise = CONFIG['first-trial-noise']
self.next_feedback = self.first_feedback
self.next_noise = self.first_noise
self.set_noise()
self.BLOCK_TRS = self.BLOCK_TIME/self.tr
self.block_nfb_buffer = np.zeros(self.BLOCK_TRS)
self.block_tr_count = 0
self.total_block_count = 0
self.trial_block_count = 0
##########################
# set playback variables #
##########################
self.TIME_SHIFT = 6
self.PLAYBACK_TRS = self.BLOCK_TRS + self.TIME_SHIFT/self.tr
self.EXTRA_TRS = 2
self.playback_buffer_length = (self.BLOCK_TIME
+ self.EXTRA_TRS)*self.FRAME_RATE
self.move_counter = 0
self.reset_playback_buffers()
# Celsius to Fahrenheit button
self.addButton(text = ">>>>",
row = 2, column = 0,
command = self.computeFahr)
# Fahrenheit to Celsius button
self.addButton(text = "<<<<",
row = 2, column = 1,
command = self.computeCelsius)
# The controller methods
def computeFahr(self):
"""Inputs the Celsius degrees
and outputs the Fahrenheit degrees."""
degrees = self.celsiusField.getNumber()
self.model.setCelsius(degrees)
self.fahrField.setNumber(self.model.getFahrenheit())
def computeCelsius(self):
"""Inputs the Fahrenheit degrees
and outputs the Celsius degrees."""
degrees = self.fahrField.getNumber()
self.model.setFahrenheit(degrees)
self.celsiusField.setNumber(self.model.getCelsius())
# Instantiate the model, pass it to the view, and pop up the window.
if __name__ == "__main__":
model = Thermometer()
view = ThermometerView(model)
view.mainloop()
from thermometer import Thermometer
thermometer = Thermometer()
for i in range(5):
temp, when = thermometer.get_measurement()
print("{} temperature = {} degrees".format(when.isoformat(), temp))
thermometer.close()
def build_page(layout, page):
layout.clear_widgets()
links.clear() # TODO: will prevent iframe functionality to work
for id, item in page.iteritems(): # create instances (ids)
if item['type'] == 'button':
wgt = Button()
if Preferences.theme != 'default':
wgt.background_normal = os.path.join(util.dir_theme,
Preferences.theme,
'btn_normal.png')
wgt.background_down = os.path.join(util.dir_theme,
Preferences.theme,
'btn_down.png')
wgt.color = Preferences.foreground
wgt.border = [0, 0, 0, 0]
elif item['type'] == 'label':
wgt = Label()
if Preferences.theme != 'default':
wgt.color = Preferences.foreground
elif item['type'] == 'image':
img_path = os.path.join(util.dir_img, item['source'])
wgt = Image(source=img_path)
elif item['type'] == 'textinput':
wgt = TextInput()
elif item['type'] == 'var-label':
wgt = VariableLabel()
elif item['type'] == 'led':
wgt = Led()
elif item['type'] == 'thermometer':
wgt = Thermometer()
elif item['type'] == 'manometer':
wgt = Manometer()
elif item['type'] == 'edit-grid':
wgt = EditGrid()
wgt.set_dimenstion(item['rows'], item['cols'])
elif item['type'] == 'simul-grid':
wgt = SimulGrid()
wgt.set_dimenstion(item['rows'], item['cols'])
wgt.build_network()
Simulator.set_grid(wgt)
elif item['type'] == 'graph':
wgt = Graph()
elif item['type'] == 'DatePicker':
wgt = DatePicker()
elif item['type'] == 'GraphLabel':
wgt = GraphLabel()
else:
print 'Unknown component ' + item['type']
return
wgt.id = id
layout.add_widget(wgt)
for id, item in page.iteritems(): # now can use references (id)
wgt = get_widget(id)
if 'text' in item:
wgt.text = item['text']
if 'font_size' in item:
wgt.font_size = item['font_size']
if 'pos' in item:
wgt.pos = eval(item['pos'])
if 'size' in item:
wgt.size = eval(item['size'])
if 'pos_hint' in item:
wgt.pos_hint = item['pos_hint']
if 'size_hint' in item:
wgt.size_hint = eval(item['size_hint'])
if 'link' in item:
links[wgt.id] = item['link']
wgt.bind(on_press=navigate)
if 'click' in item:
wgt.bind(on_press=eval(item['click']))
if 'halign' in item:
wgt.halign = item['halign']
if 'multiline' in item:
wgt.multiline = item['multiline']
if 'validate' in item:
wgt.bind(on_text_validate=eval(item['validate']))
if 'variable' in item:
wgt.set_var(item['variable'])
if 'listener' in item:
listeners = item['listener'].split(',')
for listener in listeners:
wgt.append_listener(get_widget(listener.strip()))
if 'markup' in item:
wgt.markup = item['markup']
