def reset(self):
print ("ENTERED RESET MODEL\n")
# Spawn crossings
dim = self.parameters.get('grid_size')
self.crossings = [] # Crossings in grid orientation
row = 0
# Notice!! Location is [x, y], but in the grid, one first has to access row, then column (so [y][x])
while row < dim[1]:
cr_row = []
col = 0
while col < dim[0]:
cr_row.append(Crossing([col, row]))
col += 1
self.crossings.append(cr_row)
row += 1
# Spawn drivers
self.drivers = []
n = self.parameters.get('n_drivers')
#print ("DRIVERS SPAWNED\n")
while n > 0:
driver = Driver('driver' + str(n))
self.drivers.append(driver)
#TODO remove print
#print ("DRIVER ADDED TO LIST\n")
# Put at a grid edge
new_loc = driver.respawn(dim[0], dim[1])
self.crossings[new_loc[1]][new_loc[0]].put_spawn(driver, dim[0]-1, dim[1]-1)
n -= 1
def __init__(self, path=None):
f = open(utils.NAME_FILE, 'r')
car_name = f.read().strip()
f.close()
self.name = car_name
self.frames = deque(maxlen=5) # frame = {'car_name': (x,y,theta,vx,vy,t), ...}
self._state = CarState.IDLE
self._kill = False
self._last_frame_number = 0
self._collision_worker = threading.Thread(target=self._detect_collisions)
self._message_worker = threading.Thread(target=self._process_messages)
self._main_worker = threading.Thread(target=self._process_collisions)
self._collisions = dict() # {'car_name': collision_object ...}
car_ips = dict()
ips = utils.get_car_ips()
for name, ip in ips.iteritems():
if name != self.name:
car_ips[name] = ip
self._vicon_client = ViconClient(self.frames)
self._talker = CarTalker(car_ips)
self._driver = None
if path:
self._driver = Driver(path=path)
else:
self._driver = Driver()
def __init__(self, identifier, **kargs):
Driver.__init__(self, identifier, **kargs)
# self.identifier = identifier
# self.host = host
# self.device = device
# self.port = port # XML-RPC port
if 'host' not in kargs.keys():
raise ValueError("host is requested")
if 'devices' not in kargs.keys():
raise ValueError("devices is requested")
if 'port' not in kargs.keys():
raise ValueError("port is requested")
self.xmlrpc = xmlrpclib.ServerProxy("http://%s:%d/" %
(self.host, self.port))
# Available gratings
# TODO: add resolution, blaze angle, etc...
self.gratings_properties = { 0: {'name': 'G0',
'range': [200.0, 600.0]},
1: {'name': 'G1',
'range': [600.0, 1100.0]},
2: {'name': 'G2',
'range': [1100.0, 2600.0]}
}
self.gratings = self.gratings_properties.keys()
def doPort(self, e=None):
""" open a serial port """
if self.port == None:
self.findPorts()
self.ports += ['Gazebo']
dlg = wx.SingleChoiceDialog(self,'Port (Ex. COM4 or /dev/ttyUSB0)','Select Communications Port',self.ports)
#dlg = PortDialog(self,'Select Communications Port',self.ports)
if dlg.ShowModal() == wx.ID_OK:
if self.port != None:
self.port.ser.close()
print "Opening port: " + self.ports[dlg.GetSelection()]
try:
port_name = self.ports[dlg.GetSelection()]
if port_name == 'Gazebo':
self.port = GazeboDriver()
else:
# TODO: add ability to select type of driver
self.port = Driver(self.ports[dlg.GetSelection()], 38400, True) # w/ interpolation
self.panel.port = self.port
self.panel.portUpdated()
self.sb.SetStatusText(self.ports[dlg.GetSelection()] + "@38400",1)
except RuntimeError as e:
print 'Error opening port:', e
self.port = None
self.sb.SetBackgroundColour('RED')
self.sb.SetStatusText("Could Not Open Port",0)
self.sb.SetStatusText('not connected',1)
self.timer.Start(20)
dlg.Destroy()
def register(self, bench):
self.open()
connected = self.is_connected()
if not(connected):
raise IOError("Keithley Multimeter not connected.")
Driver.register(self, bench)
def register(self, bench):
# self.open()
connected = self.is_connected()
if not(connected):
raise IOError("Dummy device is not connected.")
Driver.register(self, bench)
def drive_after_test(self):
self.check_call([
"codecov", "-X", "gcov", "--required",
"--file", "./tests/coverage.xml"
])
Driver.drive_after_test(self)
def register(self, bench):
self.open()
connected = self.is_connected()
if not(connected):
raise IOError(
"TTL board not connected (or ttl software not running).")
Driver.register(self, bench)
def register(self, bench):
self.open()
time.sleep(2)
connected = self.is_connected()
if not(connected):
raise IOError("Oriel lamp not connected.")
Driver.register(self, bench)
def register(self, bench):
self.open()
time.sleep(2)
connected = self.is_connected()
if not(connected):
raise IOError("Lakeshore controller not connected.")
Driver.register(self, bench)
def register(self, bench):
self.open()
time.sleep(2)
connected = self.is_connected()
if not(connected):
raise IOError("Monochromator Triax not connected.")
Driver.register(self, bench)
def register(self, bench):
self.open()
time.sleep(2)
connected = self.is_connected()
if not(connected):
raise IOError("Laser Thorlabs not connected.")
Driver.register(self, bench)
def __init__(self, parent, clargs):
Tkinter.Tk.__init__(self,parent)
Driver.__init__(self,clargs)
self.geometry('%dx%d' % (512, 512))
self.update()
self.lsign = 1
self.act()
def __init__(self, identifier, **kargs):
Driver.__init__(self, identifier, **kargs)
# self.identifier = identifier
# self.host = host
# self.device = device
# self.port = port # XML-RPC port
# if 'host' not in kargs.keys():
# raise ValueError("host is requested")
# if 'devices' not in kargs.keys():
# raise ValueError("devices is requested")
# if 'port' not in kargs.keys():
# raise ValueError("port is requested")
if 'reb_id' not in kargs:
raise ValueError("reb_id is requested")
if 'host' not in kargs:
self.host = None
if 'stripe' not in kargs:
self.stripe = 0
if 'xmlfile' not in kargs:
raise ValueError("XML sequencer file is requested")
if self.hardware == 'REB1':
self.reb = reb1.REB1(reb_id=self.reb_id, ctrl_host=self.host, stripe_id=[self.stripe])
self.useCABAC = True
elif self.hardware == 'WREB1':
self.reb = wreb.WREB(rriaddress=self.reb_id, ctrl_host=self.host, stripe_id=[self.stripe])
self.useCABAC = True
self.reb.useCABACbias = True
elif self.hardware in ['REB3', 'REB4']:
self.reb = reb3.REB3(self.bcfile)
self.useCABAC = False
else:
raise ValueError('Unknown type of hardware: %s' % self.hardware)
# then check FPGA version after connecting
checkversion = self.reb.fpga.get_version()
if self.version != checkversion:
raise ValueError('Wrong version of the FPGA firmware: reading %x instead of %x'
% (checkversion, self.version))
self.reb.xmlfile = self.xmlfile
self.read_sequencer_file(self.xmlfile)
self.reb.exptime = self.reb.get_exposure_time()
# CCD and test-related values (for meta)
self.testID = { 'TESTTYPE': 'TEST', 'IMGTYPE': 'TEST', 'SEQNUM': 0}
self.sensorID = { 'CCD_MANU': 'NONE', 'CCD_TYPE': 'NONE', 'CCD_SERN': '000-00', 'LSST_NUM': 'NONE'}
logging.basicConfig(filename='REB-'+ time.strftime('%Y%m%d', time.gmtime()) + '.log',
level=logging.DEBUG, format='%(asctime)s: %(message)s')
def register(self, bench):
self.open()
connected = self.is_connected()
if not connected:
raise IOError("DS9 display could not be reached")
self.default_config()
Driver.register(self, bench)
def __init__(self, probe_ids, probe_names, probe_data_type, **kwargs):
"""Initializes the Json URL driver.
Keyword arguments:
probe_ids -- list containing the probes IDs
(a wattmeter monitor sometimes several probes)
kwargs -- keyword (url) defining the Json URL driver parameters
"""
Driver.__init__(self, probe_ids, probe_names, probe_data_type, kwargs)
def register(self, bench):
self.open()
connected = self.is_connected()
if not connected:
raise IOError(
"REB #%d not connected.\n You should run this on the computer connected to the crate." % self.reb_id)
Driver.register(self, bench)
self.boardID = self.reb.fpga.get_boardID()
def __init__(self, probe_ids, data_type, **kwargs):
"""Initializes the Wattsup driver.
Keyword arguments:
probe_ids -- list containing the probes IDs
(a wattmeter monitor sometimes several probes)
kwargs -- keyword (device) defining the device to read (/dev/ttyUSB0)
"""
Driver.__init__(self, probe_ids, data_type, kwargs)
def __init__(self, clargs, stream=sys.stdout):
Driver.__init__(self, clargs)
self.stream = stream
self.monitor = self.options.pop('monitor')
self.show = self.options.pop('show')
for option in self.options:
print("Setting %s to %s" % (option, self.options[option]) )
setattr(self.hemelb, option, self.options[option])
def __init__(self, clargs, stream=sys.stdout):
Driver.__init__(self,clargs)
self.stream = stream
self.time = time()
self.lsign = 1
self.last_step = 0
self.orbit = self.options.pop('orbit')
self.framerate = self.options.get('MaxFramerate',None)
if self.framerate:
self.hemelb.MaxFramerate = self.framerate
def drive_style(self):
if self.is_darwin:
self.check_call(
"\n".join((
"eval \"$( pyenv init - )\"",
"python -m flake8 -v"
)),
shell=True
)
else:
Driver.drive_style(self)
def drive_build(self):
if self.is_darwin:
self.check_call(
"\n".join((
"eval \"$( pyenv init - )\"",
"python setup.py build"
)),
shell=True
)
else:
Driver.drive_build(self)
def __init__(self, probe_ids, **kwargs):
"""Initializes the Eaton driver.
Keyword arguments:
probe_ids -- list containing the probes IDs
(a wattmeter monitor sometimes several probes)
kwargs -- keyword (ip, user) defining the Eaton SNMP parameters
"""
Driver.__init__(self, probe_ids, kwargs)
self.cmd_gen = cmdgen.CommandGenerator()
def __init__(self, probe_ids, probe_data_type, **kwargs):
"""Initializes the IPMI driver.
Keyword arguments:
probe_ids -- list containing the probes IDs
(a wattmeter monitor sometimes several probes)
kwargs -- keywords (interface, host, username,
password) defining the IPMI parameters
"""
Driver.__init__(self, probe_ids, probe_data_type, kwargs)
def main():
database = Database()
alarmLog = AlarmLog()
summarizer = Summarizer(database, alarmLog)
clock = Clock(summarizer)
alarmWriter = AlarmWriter(summarizer)
driver1 = Driver(1, summarizer)
clock.start()
alarmWriter.start()
driver1.start()
sleep(1000)
class rGPIO(object):
def __init__(self, logger):
self.logger = logger
logger.info("Starting GPIODaemon...")
self.driver = Driver()
logger.info("Initialized driver")
def handle_cmd(self, cmd):
# New handle command class that's simpler
cmd = cmd.strip()
self.logger.info("cmd: '%s'" % cmd)
return self._handle_cmd(cmd)
def _handle_cmd(self, internal_cmd):
# Internal cmd is the actual command (triggered by the user command).
# Any return value will be sent to the socket connection.
self.logger.info("execute> %s" % internal_cmd)
cmd_parts = internal_cmd.split(" ")
cmd = cmd_parts[0]
if cmd == "forward":
self.logger.info("in command forward")
self.driver.forward()
return "going forward"
elif cmd == "turn_left":
self.logger.info("in command turn_left")
self.driver.turn_left()
return "turn left"
elif cmd == "turn_right":
self.logger.info("in command turn_right")
self.driver.turn_right()
return "turning_right"
elif cmd == "stop":
self.logger.info("in command stop")
self.driver.stop()
return "stop"
elif cmd == "backward":
self.logger.info("in command backward")
self.driver.backward()
return "backwards"
else:
self.logger.warn("command '%s' not recognized", cmd)
def drive_install(self):
self.check_call(["sudo", "apt-get", "update"])
self.check_call(["sudo", "apt-get", "install", "gfortran"])
self.check_call([
"wget", "--no-check-certificate", "--progress=dot",
"https://cmake.org/files/v3.5/cmake-3.5.0-Linux-x86_64.tar.gz"
])
self.check_call(["tar", "xzf", "cmake-3.5.0-Linux-x86_64.tar.gz"])
self.check_call([
"sudo", "rsync", "-avz", "cmake-3.5.0-Linux-x86_64/", "/usr/local"
])
Driver.drive_install(self)
def __init__(self, probe_ids, **kwargs):
"""Initializes the dummy driver.
Keyword arguments:
probe_ids -- list containing the probes IDs
(a wattmeter monitor sometimes several probes)
kwargs -- keywords (min_value and max_value)
defining the random value interval
"""
Driver.__init__(self, probe_ids, kwargs)
self.min_value = int(kwargs.get('min', 75))
self.max_value = int(kwargs.get('max', 100))
def __init__(self, probe_ids, probes_names, probe_data_type, **kwargs):
"""Initializes the SNMP driver.
Keyword arguments:
probe_ids -- list containing the probes IDs
(a metricmeter monitor sometimes several probes)
kwargs -- keyword (protocol, user or community, ip, oid) defining the
SNMP parameters
Eaton OID is 1.3.6.1.4.1.534.6.6.7.6.5.1.3
Raritan OID is 1.3.6.1.4.1.13742.4.1.2.2.1.7
"""
Driver.__init__(self, probe_ids, probes_names, probe_data_type, kwargs)
self.cmd_gen = cmdgen.CommandGenerator()
def test_followLineG( self ):
robot = MagicMock()
robot.localisation.pose.return_value = (0, 0.3, 0)
driver = Driver(robot, maxSpeed = 0.5)
offsetDistance = 0.03
gen = driver.followPolyLineG(pts = [(0, 0), (1.0, 0)],
offsetDistance=offsetDistance)
speed, angularSpeed = gen.next()
self.assertAlmostEqual(angularSpeed, -4 * math.radians(20))
self.assertAlmostEqual(speed, 0.444444444444)
# now for closer distance reduce the turning angle
robot.localisation.pose.return_value = (0, 1.5 * offsetDistance, 0)
speed, angularSpeed = gen.next()
self.assertAlmostEqual(angularSpeed, -4 * math.radians(10))
self.assertAlmostEqual(speed, 0.4722222222222222)
def get_mssql(SchoolName):
return Driver.get_mssql(SchoolName, 'exec spPeriodListGet')
def get_mssql(SchoolName):
return Driver.get_mssql(SchoolName, 'exec spParentsGet')
class DecisionMaker():
# Makes the decisions
def __init__(self, world):
self.all_balloons = []
self.world = world
self.driver = Driver()
self.current_state = States.WithoutBalloon
self.pid = PID()
self.with_balloon_counter = 0
self.spin_counter = 0
self.last_side = 1
def run_towards_balloon(self, balloon):
(position_x, position_y) = balloon.get_position()
position_x = -position_x
angular_speed = self.pid.iterate(position_x)
if angular_speed > 9.09:
angular_speed = 9.09
height = balloon.height
linear_speed = 0.9 - height
if linear_speed > 0.8:
linear_speed = 0.8
elif linear_speed < 0.20:
linear_speed = 0.20
self.driver.move(angular_speed, linear_speed)
def spin(self):
if self.last_side == 1:
angular_speed = 1.7
else:
angular_speed = -1.6
self.driver.move(angular_speed, 0)
def curve(self):
if self.last_side == 1:
angular_speed = -1
else:
angular_speed = 1
self.driver.move(angular_speed, 0.15)
def make_decision(self):
self.all_balloons = self.world.all_balloons
balloon = max(self.all_balloons.values(), key=attrgetter("area"))
if self.current_state == States.WithoutBalloon:
if balloon.visible is True:
self.pid.reset()
self.run_towards_balloon(balloon)
self.with_balloon_counter = 1
self.current_state = States.WithBalloon
print("First time")
else:
self.spin()
self.current_state = States.WithoutBalloon
print("Without balloon")
elif self.current_state == States.WithBalloon:
if balloon.visivel is True:
self.run_towards_balloon(balloon)
if self.with_balloon_counter >= 10:
if balloon.position_x > 0:
self.last_side = -1
else:
self.last_side = 1
self.with_balloon_counter += 1
self.current_state = States.WithBalloon
print("With balloon")
else:
if self.with_balloon_counter < 10:
self.with_balloon_counter = 10
self.curve()
self.spin_counter = 1
self.current_state = States.Spin
print("Spin")
else:
self.spin()
self.current_state = States.WithoutBalloon
print("Without balloon")
elif self.current_state == States.Spin:
if balloon.visible is True:
self.pid.reset()
self.run_towards_balloon(balloon)
self.current_state = States.WithBalloon
print("With balloon*")
else:
if self.spin_counter < 20:
self.curve()
self.spin_counter += 1
self.current_state = States.Spin
print("Spin")
if self.spin_counter >= 20:
self.spin()
self.current_state = States.WithoutBalloon
print("Without balloon")
def finish(self):
self.driver.finish()
import websocket
import re
import os
from driver import Driver
from subprocess import Popen
try:
import thread
except ImportError:
import _thread as thread
import time
driver = Driver()
def on_error(ws, error):
driver.stop()
print(error)
def on_close(ws):
driver.stop()
print("### closed ###")
def handle_kbsignal(ws, kbsignal):
print('kbsignal: ' + str(kbsignal))
search = re.search('\"key\":(\d+),\"pulse\":\"(\w+)\"', kbsignal)
if search is not None:
key = search.group(1)
pulse = search.group(2)
def get_mssql(SchoolName):
return Driver.get_mssql(SchoolName, 'exec spTaskListCatGet')
class JJJZ:
def __init__(self):
self.Sql = Sql()
self.Driver = Driver()
self.db_conn = self.Sql.conn_db(db='fund')
def main(self):
fund = input("Fund ID: ")
driver = self.Driver.main()
root = 'http://fundf10.eastmoney.com/jjjz_'
sql = 'select id,fund from fund where fund = "{}"'.format(fund)
fund = self.Sql.exec_sql(self.db_conn, sql).fetchall()[0]
driver.implicitly_wait(2)
id = fund[0]
fund = fund[1]
jjjz_page = 0
url = root + fund + '.html'
driver.get(url)
jjjz_total_page = driver.find_elements_by_xpath(
'//div[@class="pagebtns"]/label')[-2].text
data = []
for i in range(int(jjjz_total_page)):
trs = driver.find_elements_by_xpath(
'//div[@id="jztable"]/table/tbody/tr')
for i in range(len(trs)):
date = driver.find_element_by_xpath(
'//div[@id="jztable"]/table/tbody/tr[{0}]/td[1]'.format(
i + 1)).text.strip()
unit_jz = driver.find_element_by_xpath(
'//div[@id="jztable"]/table/tbody/tr[{0}]/td[2]'.format(
i + 1)).text.strip()
total_jz = driver.find_element_by_xpath(
'//div[@id="jztable"]/table/tbody/tr[{0}]/td[3]'.format(
i + 1)).text.strip()
date_rate = driver.find_element_by_xpath(
'//div[@id="jztable"]/table/tbody/tr[{0}]/td[4]'.format(
i + 1)).text.strip()
buy_status = driver.find_element_by_xpath(
'//div[@id="jztable"]/table/tbody/tr[{0}]/td[5]'.format(
i + 1)).text.strip()
sale_status = driver.find_element_by_xpath(
'//div[@id="jztable"]/table/tbody/tr[{0}]/td[6]'.format(
i + 1)).text.strip()
red = driver.find_element_by_xpath(
'//div[@id="jztable"]/table/tbody/tr[{0}]/td[7]'.format(
i + 1)).text.strip()
data.append([
id, date, unit_jz, total_jz, date_rate, buy_status,
sale_status, red
])
print('Crawling Fund {0}, Crawled Page {1}'.format(
fund, jjjz_page))
jjjz_page += 1
jjjz_next_page = driver.find_elements_by_xpath(
'//div[@class="pagebtns"]/label')[-1]
jjjz_next_page.click()
time.sleep(1)
sql = "insert into jjjz(fundId,JZDate,unitJZ,totalJZ,dateRate,buyStatus,saleStatus,red) values (%s,%s,%s,%s,%s,%s,%s,%s)"
self.Sql.exec_sql(self.db_conn, sql, data)
@param self: Dispatcher
@param rider: Rider
@rtype: None
>>> rider_Bathe = Rider('Bathe','waiting', 5, Location(1,2), Location(5,8))
>>> dispatcher = Dispatcher()
>>> print(dispatcher.request_driver(rider_Bathe))
None
>>> print(dispatcher.cancel_ride(rider_Bathe))
None
"""
try:
self.waiting_riders.remove(rider)
except IndexError:
print('No waiting riders!!!')
except ValueError:
print('The rider is not waiting!!!')
if __name__ == "__main__":
import doctest
doctest.testmod()
dispatcher = Dispatcher()
rider1 = Rider('rider1', 'waiting', 5, Location(1, 2), Location(5, 8))
driver1 = Driver('driver1', Location(10, 9), 1)
print(dispatcher.request_driver(rider1))
print(dispatcher.request_rider(driver1))
dispatcher.cancel_ride(rider1)
print(dispatcher)
