def add_component(self, component_hints):
'''add a tuple of the form (component, state, parent_pipe, child_pipe,
hints) and append it to list components
state is an integer, 0 for dead, 1 for alive
'''
global last_component_number
# Components get their id based on the order they were added to the list...
c = component(self.mystate, component_hints, len(self.components))
lock = Lock()
self.components.append({"component":c, "lock":lock})
def __init__(self): super(ersatzschaltbild, self).__init__() self.dx=160 self.dy=160 self.objects=[] self.origonal_objects=[] self.editable=True self.selected="diode" self.file_name=os.path.join(get_sim_path(),"diagram.inp") #self.setMouseTracking(True) self.init() self.hover=component()
def add_object(self,x0,y0,x1,y1,file_name):
c=component()
c.name=file_name
c.x0=x0
c.y0=y0
c.x1=x1
c.y1=y1
c.lines=self.load_component(c)
#print(">>>>",c.get_direction())
self.objects.append(c)
return len(self.objects)-1
def hello():
components = []
url = "http://127.0.0.1:9998/components/1"
response = requests.get(url)
jsonDict = json.loads(response.text)
for key in jsonDict:
comp = jsonDict[key]
id = comp[0]
name = comp[1]
desc = comp[2]
print("%s %s %s") %(id,name,desc)
c = component(id,name,desc)
components.append(c)
return render_template('Hello.html',components=components)
def decode_circuit_lines(self, lines):
build = []
self.data = []
for line in lines:
s, label = decode_line(line)
l = len(s)
if l > 0:
if s[0].startswith("#") == False:
c = component()
c.z0 = float(s[0])
c.x0 = float(s[1])
c.y0 = float(s[2])
c.z1 = float(s[3])
c.x1 = float(s[4])
c.y1 = float(s[5])
c.name = s[6]
self.data.append(c)
return True
def __init__(self, component_list):
self.component_list = []
self.largest_bridge = 0
for idx, com in enumerate(component_list):
self.component_list.append(component(com[0], com[1]))
#-----------------------------------------------------------------------------
"""
74HC04
"""
#-----------------------------------------------------------------------------
import component
#-----------------------------------------------------------------------------
dev = component.component('74HC04', 'U', 'Hex Inverter')
dev.add_tags(('Inverter', ))
dev.set_url('http://www.ti.com/lit/ds/symlink/sn74ahcu04-ep.pdf')
dev.add_pin('1A', 'in').set_unit(1)
dev.add_pin('1Y', 'out').set_unit(1)
dev.add_pin('2A', 'in').set_unit(2)
dev.add_pin('2Y', 'out').set_unit(2)
dev.add_pin('3A', 'in').set_unit(3)
dev.add_pin('3Y', 'out').set_unit(3)
dev.add_pin('GND', 'power_in')
dev.add_pin('VCC', 'power_in')
dev.add_pin('6A', 'in').set_unit(6)
dev.add_pin('6Y', 'out').set_unit(6)
dev.add_pin('5A', 'in').set_unit(5)
dev.add_pin('5Y', 'out').set_unit(5)
dev.add_pin('4A', 'in').set_unit(4)
dev.add_pin('4Y', 'out').set_unit(4)
def create_components_list():
engine_body_object = component.component()
engine_body_object._init_("engine_body", engine_body_x, 0, 0, engine_body_img)
component_list.append(engine_body_object)
crankgear_object = component.component()
crankgear_object._init_("crankgear", engine_body_x + 230, 364, 0, gear20_img)
component_list.append(crankgear_object)
camgear_object = component.component()
camgear_object._init_("camgear", engine_body_x + 230 + gear20_width - 15, 364 - gear40_offset, 0, gear40_img)
component_list.append(camgear_object)
camgear_object = component.component()
camgear_object._init_("camgear", engine_body_x + 230 - gear40_width + 15, 364 - gear40_offset, 0, gear40_img)
component_list.append(camgear_object)
cam_object = component.component()
cam_object._init_("inlet_cam", engine_body_x + 230 - gear40_width + cam_centre_y , 364 - gear40_offset + cam_centre_y, 0, cam_img)
component_list.append(cam_object)
cam_object = component.component()
cam_object._init_("exhaust_cam", engine_body_x + 230 + gear20_width + cam_centre_x - 15 , 364 - gear40_offset + cam_centre_y, 0, cam_img)
component_list.append(cam_object)
pushrod_object = component.component()
pushrod_object._init_("exhaust_pushrod", engine_body_x + 230 + gear20_width + cam_centre_x + cam_width/2 - 20, 364 - gear40_offset + cam_centre_y
- pushrod_img.get_size()[1], 0,
pushrod_img)
component_list.append(pushrod_object)
pushrod_object = component.component()
pushrod_object._init_("inlet_pushrod", engine_body_x + 230 - gear40_width + cam_centre_y + cam_width/2 - 5,
364 - gear40_offset + cam_centre_y - pushrod_img.get_size()[1], 0, pushrod_img)
component_list.append(pushrod_object)
crankshaft_object = component.component()
crankshaft_object._init_("crankshaft", engine_body_x + 195, 330, 0, crankshaft_img)
component_list.append(crankshaft_object)
conrod_object = component.component()
conrod_object._init_("connecting_rod", engine_body_x + 244, 16, 0, conrod_img)
component_list.append(conrod_object)
piston_object = component.component()
piston_object._init_("piston", engine_body_x + 238, 190, 0, piston_img)
component_list.append(piston_object)
inlet_rocker_object = component.component()
inlet_rocker_object._init_("inlet_rocker", engine_body_x + 102, 50, 0, inlet_rockerarm_img)
component_list.append(inlet_rocker_object)
exhaust_rocker_object = component.component()
exhaust_rocker_object._init_("exhaust_rocker", engine_body_x + 337, 50, 0, exhaust_rockerarm_img)
component_list.append(exhaust_rocker_object)
inlet_valve_object = component.component()
inlet_valve_object._init_("inlet_valve", engine_body_x + 244, 50, 0, valve_img)
component_list.append(inlet_valve_object)
exhaust_valve_object = component.component()
exhaust_valve_object._init_("exhaust_valve", engine_body_x + 330, 50, 0, valve_img)
component_list.append(exhaust_valve_object)
ValveDefaultActualFlow = 800 / 3600.0 #//From average HX flow in unit CW circuit.
ValveDefaultDP = 1.2 * Ps
ValveDefaultOpening = 0.5 #//Default valve opening.
ValveEqualPercR = 40.0 #//Dimensionless constant for valve equalpercentage.
ValveDefaultCv = ValveDefaultActualFlow / \
(math.pow(ValveEqualPercR, ValveDefaultOpening - 1) * math.sqrt(ValveDefaultDP)) # //m^3/s/(Pa^0.5)
ValveHydraulicTau = 10.0 #//seconds. Time constant of valve hydraulics.
ValveLength = 0.5 #//m
ValveWidth = 0.4 #//m
#fluidpackage constants -------------------------------------------------------------------------------------------------
fluidpackage = list() #list of component object
fluidpackage.append(component.component(molecule.molecule("Naphtha", "GTL Naphtha", 0.157, 0.00164, 661.4959, 273 + 495, 1.2411 * 10**7, \
-1 - np.log10(110000 /1.2411 * (10**7)) , 150.5, 0.6, 0, 0), 0))
fluidpackage.append(component.component(molecule.molecule("Air", "Air", 0.02897, 1.983 * math.pow(10, -5), 1.225, 132.41, \
3.72 * math.pow(10, 6), \
0.0335,
0.8*31.15 + 0.2*28.11, 0.8*(-0.01357) + 0.2*(-3.7) * math.pow(10, -6), 0.8*2.68*math.pow(10,-5) + 0.2*1.746 * math.pow(10, -5),
0.8 * (-1.168) * math.pow(10, -8) + 0.2 * (-1.065) * math.pow(10, -8)), 0))
#//Density: 1.977 kg/m3 (gas at 1 atm and 0 °C)
fluidpackage.append( component.component( molecule.molecule("CO2", "Carbon Dioxide", 0.018, 0.07 * 0.001, 1.977, 304.25, 7.39 * math.pow(10, 6), 0.228,
19.8, 0.07344, -5.602E-05, 1.715E-08), 0))
#//Density: 1.977 kg/m3 (gas at 1 atm and 0 °C)
fluidpackage.append( component.component( molecule.molecule("CO", "Carbon Monoxide", 0.02801, 0.0001662 * 0.001, 1.145), 0))
#//Density: 1.145 kg/m3 at 25 °C, 1 atm
fluidpackage.append( component.component( molecule.molecule("H2", "Hydrogen", 0.0020158, 8.76 * math.pow(10, -6), 0.08988), 0))
#//Density: 0.08988 g/L = 0.08988 kg/m3 (0 °C, 101.325 kPa)
fluidpackage.append( component.component( molecule.molecule("He", "Helium", HeMolarMass, 0, 0.1786, 5.1953, 5.1953E6, -0.390,
20.8, 0, 0, 0), 0))
#run ComponentPositions
from component import component
from ComponentPositions import ComponentPositions as CP
import numpy as np
from sympy import *
import quaternion
SCBody = CoordSysCartesian('SCBody')
SCBody.origin
comp1 = component(SCBody, 'box1') #=SCBody)#compname='box1',
comp1.r_component_Body += 1. * SCBody.i + 1. * SCBody.j + 1. * SCBody.k
#comp1.r_component_Body += [1.,1.,1.]#np.asarray([1.,1.,1.])
comp2 = component(SCBody, 'box2')
comp2.r_component_Body += comp1.r_component_Body
print comp1.vertices
print comp2.vertices
comp1.r_component_Body += 1. * SCBody.i + 1. * SCBody.j + 1. * SCBody.k
print comp1.vertices
print comp2.vertices
# cp = CP()
# print cp.comps['box1']['part_position']
# cp.r_SCbody_I += np.asarray([1,1,1])
# print cp.comps['box1']['part_position']
#-----------------------------------------------------------------------------
"""
Broadcom JTAG Connector - as seen on the BCM949408EAP
"""
#-----------------------------------------------------------------------------
import component
#-----------------------------------------------------------------------------
dev = component.component('BCMJTAG', 'U', 'Broadcom 16 pin JTAG Connector (BCM949408EAP)')
dev.add_tags(('JTAG',))
dev.set_url('https://www.broadcom.com/products/wireless/wireless-lan-infrastructure/bcm49408')
# jtag
dev.add_pin('TDI', 'out')
dev.add_pin('TDO', 'in')
dev.add_pin('TMS', 'out')
dev.add_pin('TCK', 'out')
dev.add_pin('TRST_L', 'out')
# spi ??
dev.add_pin('DBG_CLK', 'out').set_group(1)
dev.add_pin('DBG_EN_N', 'out').set_group(1)
dev.add_pin('DBG_SOUT', 'in').set_group(1)
dev.add_pin('DBG_SIN', 'out').set_group(1)
# serial port
dev.add_pin('UART0_RX', 'out').set_group(2)
dev.add_pin('UART0_TX', 'in').set_group(2)
# system
#-----------------------------------------------------------------------------
import kicad
import footprint
import component
#-----------------------------------------------------------------------------
name = 'ILI9341'
descr = 'LCD Module 2.8 inch 240x320 SPI TFT with touch sensor and SD card'
tags = ('LCD', )
url = 'https://www.amazon.com/gp/product/B017FZTIO6/ref=od_aui_detailpages00?ie=UTF8&psc=1'
#-----------------------------------------------------------------------------
dev = component.component(name, 'M', descr)
dev.add_tags = (tags)
dev.set_url(url)
# power
dev.add_pin('VCC', 'power_in')
dev.add_pin('GND', 'power_in')
# lcd
dev.add_pin('LCD_CS', 'in')
dev.add_pin('LCD_RESET', 'in')
dev.add_pin('LCD_DC', 'in')
dev.add_pin('LCD_SDI', 'in')
dev.add_pin('LCD_SCK', 'in')
dev.add_pin('LCD_LED', 'in')
dev.add_pin('LCD_SDO', 'out')
# touch screen
def add_component(self, comp_type, position, direction):
#In the future, specify connections, layer, collision detection
#Place in components without connections, gradually add them in
self.components.append([ct.component(comp_type, position, direction), {}])
def __init__(self, info_dict, fwk, index):
"""
construct and manage the workflow of a simulation and its constituent components
"""
# stuff from the framework
self.RM = fwk.RM
self.fwk = fwk
# bookkeeping
self.total_usage = 0
self.total_work_time = 0
self.total_lost_time = 0
self.total_overhead = 0
self.total_restart_time = 0
self.total_resubmit_time = 0
self.total_launch_delay = 0
self.total_rework_time = 0
self.total_ckpt_time = 0
self.total_waiting_time = 0
self.num_waiting = 0
self.num_restarts = 0
self.num_rework = 0
self.num_work = 0
self.num_ckpts = 0
self.num_faults = 0
self.num_retries = 0
self.resubmissions = 0
self.last_submission_time = 0
# my components and properties
self.state = 'startup' # other states: 'shutdown', 'checkpoint', 'restart', 'work'
self.my_comps = dict()
self.all_comps = dict()
self.my_overheads = dict()
self.phases = dict()
self.is_done = False
self.resubmission_threshold = 5
try:
self.name = info_dict['name'] + '_' + str(index)
except:
raise
try:
self.mode = info_dict['mode']
except:
self.mode = 'normal' # this means time stepped
if self.mode == 'normal':
self.fwk.failure_mode = 'normal'
try:
self.nsteps = int(info_dict['nsteps'])
self.comp_list = info_dict['components']
except:
self.nsteps = 0
self.comp_list = []
try:
self.phase_list = info_dict['phases']
except:
self.phase_list = []
if self.nsteps > 0 and self.comp_list:
self.old_style = True
elif self.phase_list:
self.old_style = False
else:
print "bad config file"
raise
try:
self.ft_strategy = info_dict['ft_strategy']
except:
self.ft_strategy = None
try:
self.retry_limit = int(info_dict['retry_limit'])
except:
self.retry_limit = -1
self.curr_step = 1
self.curr_phase_index = -1
self.curr_phase = ''
self.total_steps = 0
elif self.mode == 'total_time':
#self.fwk.failures_on = True
self.fwk.failure_mode = 'sandia'
try:
self.total_work = int(info_dict['total_work'])
self.comp_list = info_dict['components']
except:
raise
self.rework_todo = 0
self.completed_work = 0
self.old_style = True
# get overheads
try:
startup = info_dict['startup']
self.my_overheads.update({
'startup':
overhead(None, self.fwk, self, None, 'startup', startup)
})
except:
self.my_overheads.update({
'startup':
overhead(None, self.fwk, self, None, 'startup', None)
})
try:
resubmit = info_dict['resubmit']
self.my_overheads.update({
'resubmit':
overhead(None, self.fwk, self, None, 'resubmit', resubmit)
})
except:
self.my_overheads.update({
'resubmit':
overhead(None, self.fwk, self, None, 'resubmit', None)
})
try:
shutdown = info_dict['shutdown']
self.my_overheads.update({
'shutdown':
overhead(None, self.fwk, self, None, 'shutdown', shutdown)
})
except:
self.my_overheads.update({
'shutdown':
overhead(None, self.fwk, self, None, 'shutdown', None)
})
try:
restart = info_dict['restart']
self.my_overheads.update({
'restart':
overhead(None, self.fwk, self, None, 'restart', restart)
})
except:
self.my_overheads.update({
'restart':
overhead(None, self.fwk, self, None, 'restart', None)
})
try:
launch_delay = info_dict['launch_delay']
self.my_overheads.update({
'launch_delay':
overhead(None, self.fwk, self, None, 'launch_delay',
launch_delay)
})
except:
self.my_overheads.update({
'launch_delay':
overhead(None, self.fwk, self, None, 'launch_delay', None)
})
# is checkpointing being modeled?
try:
ckpt_section = info_dict['checkpoint']
ckpt_on_val = ckpt_section['ckpt_on']
if ckpt_on_val == 'True':
self.ckpt_on = True
else:
self.ckpt_on = False
except:
self.ckpt_on = False
# get checkpointing parameters
if self.ckpt_on:
try:
self.ckpt_mode = ckpt_section['ckpt_mode']
if self.ckpt_mode == 'sandia':
self.last_ckpt = 0
try:
self.next_ckpt = int(ckpt_section['tau'])
self.ckpt_interval = self.next_ckpt
except:
# **** NEED TO CHANGE TO CALCULATE INITIAL VAL!!!!
self.next_ckpt = 10
elif self.ckpt_mode == 'wall_regular' or self.ckpt_mode == 'phys_regular':
self.ckpt_interval = int(ckpt_section['ckpt_interval'])
self.next_ckpt = self.ckpt_interval
elif self.ckpt_mode == 'wall_explicit' or self.ckpt_mode == 'phys_explicit':
self.ckpt_values = [
int(x) for x in ckpt_section['ckpt_values']
]
self.next_ckpt = self.ckpt_values.pop(0)
self.my_overheads.update({
'checkpoint':
overhead(None, self.fwk, self, None, 'checkpoint',
ckpt_section)
})
except:
print "problems setting up checkpoint parameters"
raise
self.ckpt_comps = list()
self.ckpt_step = 0
self.ckpt_phase_index = 0
self.ckpt_phase = ''
# add components
try:
if self.mode == 'total_time':
self.phase_list.append('none')
self.phases.update({
'none':
phase({}, self.fwk, self, 'none', old_style=True)
})
self.phases['none'].comp_list = self.comp_list
if not isinstance(self.comp_list, list):
self.comp_list = [self.comp_list]
for s in self.comp_list:
self.all_comps.update({
'none_' + s:
component(info_dict[s], self.fwk, self, 'none')
})
elif self.old_style:
self.phase_list.append('none')
self.phases.update({
'none':
phase({}, self.fwk, self, 'none', old_style=True)
})
self.phases['none'].nsteps = self.nsteps
self.phases['none'].comp_list = self.comp_list
if not isinstance(self.comp_list, list):
self.comp_list = [self.comp_list]
for s in self.comp_list:
self.all_comps.update({
'none_' + s:
component(info_dict[s], self.fwk, self, 'none')
})
else:
if not isinstance(self.phase_list, list):
self.phase_list.append(self.phase_list)
for p in self.phase_list:
self.phases.update(
{p: phase(info_dict[p], self.fwk, self.name, p)})
if not isinstance(self.phases[p].comp_list, list):
self.phases[p].comp_list = [self.phases[p].comp_list]
for s in self.phases[p].comp_list:
self.all_comps.update({
p + '_' + s:
component(info_dict[p][s], self.fwk, self, p)
})
except:
raise
if self.fwk.debug:
for k, v in self.phases.items():
print "phase:", k, "nsteps:", v.nsteps, "comps:", v.comp_list
for c in self.all_comps.values():
print c.name, c.nproc, c.runtime, c.stddev
self.get_next_phase()
# populate handles to total_time components
if self.mode == 'total_time':
for c in self.my_comps.values():
if c.type == 'sandia_work':
self.work_comp = c
self.work_comp.state = "ready"
elif c.type == 'sandia_rework':
self.rework_comp = c
elif c.type == 'sandia_restart':
self.restart_comp = c
elif c.type == 'sandia_ckpt':
self.ckpt_comp = c
#self.get_ready_comps()
if self.fwk.debug:
print self.my_comps.keys()
def mouseReleaseEvent(self, event):
if self.editable==False:
return
if inp().isfile(self.file_name)==False:
result=yes_no_dlg(self,_("Are you sure you want to edit the circuit directly? The circuit will no longer automaticly be updated as you change the layer structure, and the electrical parameters editor will be disabled. Use can use the reset function in the circuit diagram editor to resore this functionality"))
if result == False:
return
if event.button() == Qt.LeftButton:
x0,y0,x1,y1,direction=self.find_click_points(event)
c=component()
c.x0=x0
c.y0=y0
c.x1=x1
c.y1=y1
index=self.find_component_index(c)
if self.selected=="clean":
if index!=-1:
self.objects.pop(index)
else:
if index==-1:
c.name=self.selected
c.lines=self.load_component(c)
#if direction=="up":
# self.rotate(c.lines)
self.objects.append(c)
else:
if self.objects[index].name=="resistor":
self.a=inp_dialog()
ret=self.a.run(["#resistance",str(self.objects[index].R),"#end"])
if ret==QDialog.Accepted:
self.objects[index].R=float(self.a.tab.f.get_token("#resistance"))
elif self.objects[index].name=="capacitor":
self.a=inp_dialog()
ret=self.a.run(["#capacitance",str(self.objects[index].C),"#end"])
if ret==QDialog.Accepted:
self.objects[index].C=float(self.a.tab.f.get_token("#capacitance"))
elif self.objects[index].name=="inductor":
self.a=inp_dialog()
ret=self.a.run(["#inductance",str(self.objects[index].L),"#end"])
if ret==QDialog.Accepted:
self.objects[index].L=float(self.a.tab.f.get_token("#inductance"))
elif self.objects[index].name=="diode":
self.a=inp_dialog()
ret=self.a.run(["#J0",str(self.objects[index].J0),"#nid",str(self.objects[index].nid),"#end"])
if ret==QDialog.Accepted:
self.objects[index].nid=float(self.a.tab.f.get_token("#nid"))
self.objects[index].J0=float(self.a.tab.f.get_token("#J0"))
#if new_sim_name!=None:
self.repaint()
self.save()
elif event.button() == Qt.RightButton:
#do what you want here
print("Right Button Clicked")
#-----------------------------------------------------------------------------
"""
TLC 5940
"""
#-----------------------------------------------------------------------------
import component
#-----------------------------------------------------------------------------
dev = component.component('TLC5940', 'U', '16-Channel LED Driver')
dev.add_tags(('LED', 'PWM'))
dev.set_url('http://www.ti.com/product/TLC5940')
dev.add_pin('VCC', 'power_in')
dev.add_pin('GND', 'power_in')
dev.add_pin('BLANK', 'in')
dev.add_pin('XLAT', 'in')
dev.add_pin('SCLK', 'in')
dev.add_pin('SIN', 'in')
dev.add_pin('VPRG', 'in')
dev.add_pin('IREF', 'in')
dev.add_pin('DCPRG', 'in')
dev.add_pin('GSCLK', 'in')
dev.add_pin('OUT0', 'out')
dev.add_pin('OUT1', 'out')
dev.add_pin('OUT2', 'out')
dev.add_pin('OUT3', 'out')
dev.add_pin('OUT4', 'out')
