def get_all(self):
self.c.execute("SELECT id,name,ip,status FROM devices")
list_devices = []
for i in self.c:
d = Device(i[0], i[1], i[2], i[3])
list_devices.append(d)
return list_devices
def init_theano_devices():
"""
Only for Theano.
:rtype: list[Device.Device]|None
"""
if not BackendEngine.is_theano_selected():
return None
from Util import TheanoFlags
from Config import get_devices_init_args
from Device import Device
old_device_config = ",".join(config.list('device', ['default']))
if config.value("task", "train") == "nop":
return []
if "device" in TheanoFlags:
# This is important because Theano likely already has initialized that device.
config.set("device", TheanoFlags["device"])
print("Devices: Use %s via THEANO_FLAGS instead of %s." % (TheanoFlags["device"], old_device_config), file=log.v4)
dev_args = get_devices_init_args(config)
assert len(dev_args) > 0
devices = [Device(**kwargs) for kwargs in dev_args]
for device in devices:
while not device.initialized:
time.sleep(0.25)
if devices[0].blocking:
print("Devices: Used in blocking / single proc mode.", file=log.v4)
else:
print("Devices: Used in multiprocessing mode.", file=log.v4)
return devices
def __init__(self,
number_of_edge=3,
number_of_user=3,
epsilon=0.01,
number_of_chs=None,
cpu=None,
d_cpu=None,
H=None):
self.number_of_user = number_of_user
self.users = []
for n in range(self.number_of_user):
self.users.append(
Device(d_cpu[n],
n,
H[n],
transmission_power=random.uniform(0.5, 1),
epsilon=epsilon))
self.number_of_edge = number_of_edge
self.edges = []
for k in range(self.number_of_edge):
self.edges.append(
EdgeCloud(k, cpu[k], number_of_chs=number_of_chs[k]))
self.network = number_of_chs
def ModifyDevices():
conn = dbconn()
device_obj = Device(conn)
# retrieve all devices
# devices = conn.execute_read_query("SELECT * FROM devices")
if request.method == 'POST':
device_plan_id = request.form['plan_id']
device_name = request.form['name']
device_type = request.form['type']
device_owner = request.form['owner']
device_obj.add_device(device_plan_id, device_name, device_type,
device_owner)
# device = device_obj.view_device(device_name)
# devices = conn.execute_read_query("SELECT * FROM devices")
return redirect('/devices/list')
else:
return render_template('device.html')
def _init_devices(self, config):
"""
Initiates the required devices for a config. Same as the funtion initDevices in
rnn.py.
:param config:
:return: A list with the devices used.
"""
oldDeviceConfig = ",".join(config.list('device', ['default']))
if "device" in TheanoFlags:
# This is important because Theano likely already has initialized that device.
config.set("device", TheanoFlags["device"])
print("Devices: Use %s via THEANO_FLAGS instead of %s." %
(TheanoFlags["device"], oldDeviceConfig),
file=log.v4)
devArgs = getDevicesInitArgs(config)
assert len(devArgs) > 0
devices = [Device(**kwargs) for kwargs in devArgs]
for device in devices:
while not device.initialized:
time.sleep(0.25)
if devices[0].blocking:
print("Devices: Used in blocking / single proc mode.", file=log.v4)
else:
print("Devices: Used in multiprocessing mode.", file=log.v4)
return devices
def initDevices():
"""
:rtype: list[Device]
"""
oldDeviceConfig = ",".join(config.list('device', ['default']))
if BackendEngine.is_tensorflow_selected():
if os.environ.get("TF_DEVICE"):
config.set("device", os.environ.get("TF_DEVICE"))
print("Devices: Use %s via TF_DEVICE instead of %s." %
(os.environ.get("TF_DEVICE"), oldDeviceConfig),
file=log.v4)
if not BackendEngine.is_theano_selected():
return None
if config.value("task", "train") == "nop":
return []
if "device" in TheanoFlags:
# This is important because Theano likely already has initialized that device.
config.set("device", TheanoFlags["device"])
print("Devices: Use %s via THEANO_FLAGS instead of %s." % \
(TheanoFlags["device"], oldDeviceConfig), file=log.v4)
devArgs = getDevicesInitArgs(config)
assert len(devArgs) > 0
devices = [Device(**kwargs) for kwargs in devArgs]
for device in devices:
while not device.initialized:
time.sleep(0.25)
if devices[0].blocking:
print("Devices: Used in blocking / single proc mode.", file=log.v4)
else:
print("Devices: Used in multiprocessing mode.", file=log.v4)
return devices
def __init__(self):
wx.Frame.__init__(self, None, wx.ID_ANY, "Tutorial", size=(500, 500))
self.panel = wx.Panel(self)
self.tbIcon = SystemTray(self)
device = Device()
self.tbIcon.addDevice(device)
self.tbIcon.ShowBalloon("Test", "Test", 5, wx.ICON_WARNING)
self.Bind(wx.EVT_CLOSE, self.onClose)
def __init__(self, names, adb_path='adb'):
Adb.setup(adb_path)
mapping_file = load_json(op.join(ROOT_DIR, 'devices.json'))
self._device_map = {n: mapping_file.get(n, None) for n in names}
for name, device_id in self._device_map.items():
if not device_id:
raise ConfigError(name)
self.devices = [Device(name, device_id) for name, device_id in self._device_map.items()]
def main():
global machine_list
machine_list = []
device_1 = Device(5, 20, 10000)
device_2 = Device(7, 30, 10001)
device_3 = Device(2, 15, 10002)
CAP_1 = AccessPoint(10, 10, 10003)
server_1 = Server(50, 70, 10004)
machine_list.append(device_1)
machine_list.append(device_2)
machine_list.append(device_3)
machine_list.append(CAP_1)
machine_list.append(server_1)
gui_process = Process(target=guiFunc())
gui_process.start()
def insertDeviceData(self, devId, time, x, y, z, lat, long):
connection = MongoClient('localhost:27017')#'mongodb://192.168.1.65:27017')
db = connection.vandrico
dev = Device(devId, time, x, y, z, lat, long)
serializedDev = json.dumps(dev.__dict__)
deserializedDev = json.loads(serializedDev)
db.devices.insert_one(deserializedDev)
connection.close()
def YieldAllDevices(self):
"""
A generator that yields all of the devices that belong to the
virtual machine.
"""
for deviceManagedObject in self.managedObject.config.hardware.device:
yield Device(vm=self, managedObject=deviceManagedObject)
def Run(isDebugging=False):
if isDebugging == False:
device = Device("127.0.0.1:62001")
device.Connect()
profile = Profile("GaChien")
profile.Load()
gameManager = GameManager(device, profile)
screenManager = ScreenManager()
while True:
screenshot = device.CaptureScreen()
if screenshot.image is None:
print("Can not capture screenshot. Retry...")
time.sleep(5)
continue
screen = screenManager.GetScreen(screenshot)
screen.ShowName()
gameManager.SetScreen(screen)
gameManager.Play()
print("")
time.sleep(5)
else:
device = Device(None)
device.Connect()
profile = Profile("GaChien")
profile.Load()
gameManager = GameManager(device, profile)
screenManager = ScreenManager()
print("Debugging...")
filePath = os.path.abspath("PendingScreens/Screenshot.png")
screenshot = ScreenShot(filePath)
screen = screenManager.GetScreen(screenshot)
screen.ShowName()
gameManager.SetScreen(screen)
gameManager.Play()
def testRentalCheckOut(self):
for n in xrange(NUM_TESTS):
# Create User
user = User()
user.first_name = self.v.validRandomString(MAX_STRING_LENGTH)
user.family_name = self.v.validRandomString(MAX_STRING_LENGTH)
user.group = randomGroupEnum()
user.device_id = None
user.start_datetime = None
user_key = user.put()
# Verify User has no device
q = User.query().fetch(n + 1)
self.assertEqual(q[n].first_name, user.first_name)
self.assertEqual(q[n].family_name, user.family_name)
self.assertEqual(q[n].group, user.group)
self.assertEqual(q[n].device_id, user.device_id)
self.assertEqual(q[n].start_datetime, user.start_datetime)
# Create Device
device = Device()
device.color = randomColorEnum()
device.model = randomDeviceModelEnum()
device.serial_no = self.v.validRandomString(MAX_STRING_LENGTH)
device_key = device.put()
# Verify Device is not rented
q = Device.query().fetch(n + 1)
device_id = q[n].key.urlsafe()
self.assertEqual(q[n].color, device.color)
self.assertEqual(q[n].model, device.model)
self.assertEqual(q[n].serial_no, device.serial_no)
self.assertEqual(q[n].is_rented, False)
# Add Device to User
start_datetime = datetime.now()
result = user.checkOutDevice(device_id, start_datetime)
self.assertNotEqual(result, None)
# Verify User has device ID
q = User.query().fetch(n + 1)
self.assertEqual(q[n].first_name, user.first_name)
self.assertEqual(q[n].family_name, user.family_name)
self.assertEqual(q[n].group, user.group)
self.assertEqual(q[n].device_id, user.device_id)
self.assertEqual(q[n].device_id, device_id)
self.assertEqual(q[n].start_datetime, user.start_datetime)
self.assertEqual(q[n].start_datetime, start_datetime)
# Verify Device is rented
q = Device.query().fetch(n + 1)
device_id = q[n].key.urlsafe()
self.assertEqual(q[n].color, device.color)
self.assertEqual(q[n].model, device.model)
self.assertEqual(q[n].serial_no, device.serial_no)
self.assertEqual(q[n].is_rented, True)
def addComputer(self, name):
device = Device('computer.jpg', name, 'computer', self)
device.move(100, 65)
device.show()
self.deviceList.append(device)
try:
self.detailsWindow.updateDetails()
except Exception as e:
pass
class MeasureDeviceConnect(BaseMeasureInfo):
try:
dev = Device()
ldc = dev.get_ldc4005_instance()
pm100 = dev.get_pm100_instance()
BaseMeasureInfo.OUT_MSG += "Connections with device successful"
except Exception as err:
BaseMeasureInfo.logger.error(err)
BaseMeasureInfo.OUT_MSG += ("Error %s" % err)
def selectDevicesFromDb(self, devID):
connection = MongoClient('localhost:27017')#'mongodb://192.168.1.65:27017')
db = connection.vandrico
devices = []
for doc in db.devices.find({"deviceID":devID}).sort("timestamp",1):
dev = Device(str(doc['deviceID']),str(doc['timestamp']),str(doc['x']),str(doc['y']),
str(doc['z']),str(doc['latitude']),str(doc['longitude']))
devices.append(dev)
connection.close()
return devices
def dList_init(self, initial_conditions):
"""
Initializes and instanciates all devices given their initial conditions;
initial_conditions is of the form [(x_0, y_0), (vx_0, vy_0), ..., (x_n, y_n), (vx_n, vy_n)] describing the initial parameters all devices (from 0 to n)
"""
for dID, (pos, vel) in enumerate(initial_conditions):
self.dList.append(Device(dID, pos, vel))
return self.dList
def close_Button(self):
self.window.destroy()
Device().capture_screenshot()
droid = AQMdroid(self.img_path, self.img_dim, self.filename)
try:
droid.getorigin()
except Exception as e:
print "\nFrame Clossed."
def update(self):
device_names = self.hal_manager.GetAllDevices()
self.manager.device = {}
for name in device_names:
device_dbus_obj = self.bus.get_object('org.freedesktop.Hal', name)
properties = device_dbus_obj.GetAllProperties(
dbus_interface="org.freedesktop.Hal.Device")
d = Device(name, properties)
self.manager.append_device(d)
self.add_dev_sig_recv(name)
def interfaceState():
R = Device('R2')
RTelnet = telnetlib.Telnet(GET_IP, 23, 60)
RTelnet.write(GET_USERNAME + "\n")
RTelnet.write(GET_PASSWORD + "\n")
if verifyInterfaceState(RTelnet, 'lo0', state="up"):
return 1
else:
return 0
def search_for_device(self):
notificationSource = None
controlPoint = None
dataSource = None
deviceID = None
# TODO: use functional pattern to simplify the loop
# characteristics = self.all_children(hci, "dev_")
# .filter(lambda x: (...).connected)
# .map(lambda x: self.all_children(x, "service"))
# .filter(lambda x: uuid == ancsID)
# notificationSource = characteristics
# .first(lambda x: uuid == notificationSourceID)
hci = self.bus.get_object("org.bluez", "%s" % self.path)
for deviceID in self.all_children(hci, "dev_"):
device = self.bus.get_object(
"org.bluez", "%s/%s" % (self.path, deviceID))
props = dbus.Interface(device, "org.freedesktop.DBus.Properties")
connected = props.Get("org.bluez.Device1", "Connected")
if not connected:
continue
for serviceID in self.all_children(device, "service"):
service = self.bus.get_object(
"org.bluez", "%s/%s/%s" % (self.path, deviceID, serviceID))
props = dbus.Interface(
service, "org.freedesktop.DBus.Properties")
uuid = props.Get("org.bluez.GattService1", "UUID")
if uuid != ancsID:
continue
for characteristicID in self.all_children(service, "char"):
characteristic = self.bus.get_object(
"org.bluez", "%s/%s/%s/%s" % (self.path,
deviceID, serviceID,
characteristicID))
props = dbus.Interface(
characteristic, "org.freedesktop.DBus.Properties")
uuid = props.Get("org.bluez.GattCharacteristic1", "UUID")
if uuid == notificationSourceID:
notificationSource = characteristic
deviceID = deviceID
elif uuid == controlPointID:
controlPoint = characteristic
elif uuid == dataSourceID:
dataSource = characteristic
if notificationSource is None \
or controlPoint is None \
or dataSource is None:
return None
return Device(self,
notificationSource,
controlPoint,
dataSource,
deviceID)
def createDevice(deviceCount):
devices = []
with open('locs.csv', 'rb') as f:
reader = csv.reader(f)
locs = list(reader)
for i in range(0, deviceCount):
device = Device('TFP' + str(i + 1).zfill(4), locs[i][0], locs[i][1],
'Generic Sensor')
devices.append(device)
return devices
def addDeviceNoPar(self):
nameRes = self.name.text()
portRes = self.port.text()
if self.checkStringForNumber(self.value.text()):
valRes = int(self.value.text())
else:
self.showPopup("e", "Not a number",
"You have to enter a valid number")
self.value.setText("0")
return
try:
maxRollRes = float(self.maxRollLength.text())
except:
self.showPopup("e", "Not a number",
"You have to enter a valid number")
self.value.setText("0")
return
self.name.setText("")
self.port.setText("COM0")
self.value.setText("0")
self.maxRollLength.setText("0")
if nameRes == "":
self.showPopup("e", "Error: No name",
"New device can not be created without a name.")
return
for device in self.devices:
if device.name == nameRes:
self.showPopup("e", "Error: Duplicate names",
"There already is a device with this name.")
self.name.setText("")
return
try:
newDevice = Device(nameRes, portRes, self.sensorType, valRes,
maxRollRes) # lightRes, tempRes)
self.devices.append(newDevice)
self.setCurrentDevice(self.devices[0].name)
self.log.writeInLog(
"i",
"New device added: name: " + nameRes + " | Port: " + portRes +
" | Sensor type: " + self.sensorType + " | Minimum value: " +
str(valRes) + " | Max roll length: " + str(maxRollRes))
self.showPopup("i", "New Device",
"Device with name: " + nameRes + " has been added!")
self.updateMaingrid(self.MainWindow)
except:
self.log.writeInLog("w", "Could not add device: " + nameRes)
self.showPopup("e", "Could not add device!",
"An error has occurred")
newDevice = None
def __init__(self, manager=None):
if manager != None:
self.manager = manager
else:
self.manager = None
DBusGMainLoop(set_as_default=True)
self.bus = dbus.SystemBus()
obj = self.bus.get_object('org.freedesktop.Hal',
'/org/freedesktop/Hal/Manager')
self.hal_manager = dbus.Interface(obj, 'org.freedesktop.Hal.Manager')
try:
self.hal_manager.connect_to_signal(
'DeviceAdded', lambda *args: self.handle('DeviceAdded', *args))
except:
pass
try:
self.hal_manager.connect_to_signal(
'DeviceRemoved',
lambda *args: self.handle('DeviceRemoved', *args))
except:
pass
try:
self.hal_manager.connect_to_signal(
'NewCapability',
lambda *args: self.handle('NewCapability', *args))
except:
pass
device_names = self.hal_manager.GetAllDevices()
self.icon = gtk.StatusIcon()
self.icon.set_from_stock(gtk.STOCK_INFO)
for name in device_names:
try:
self.add_dev_sig_recv(name)
device_dbus_obj = self.bus.get_object('org.freedesktop.Hal',
name)
properties = device_dbus_obj.GetAllProperties(
dbus_interface="org.freedesktop.Hal.Device")
d = Device(name, properties)
if manager != None:
self.manager.append_device(d)
self.add_dev_sig_recv(name)
except:
pass
def testInsertDevice(self):
for n in xrange(NUM_TESTS):
device = Device()
device.color = randomColorEnum()
device.model = randomDeviceModelEnum()
device.serial_no = self.v.validRandomString(MAX_STRING_LENGTH)
device_key = device.put()
q = Device.query().fetch(n + 1)
self.assertEqual(q[n].color, device.color)
self.assertEqual(q[n].model, device.model)
self.assertEqual(q[n].serial_no, device.serial_no)
self.assertEqual(q[n].is_rented, False)
def SetupDeviceConnection():
deviceConnection = ServerlessDeviceConnection()
BlinkyLEDDevice = Device()
BlinkyLEDDevice.DeviceID = 444
BlinkyLEDDevice.SetDeviceName('BlinkyLED')
OnOffControls = ControlValue()
OnOffControls.ControlName = 'LEDState'
OnOffControls.ControlValueType = OnOffControls.OnOff
OnOffControls.ControlID = 0
BlinkyLEDDevice.ControlList.append(OnOffControls)
deviceConnection.SetDeviceData(BlinkyLEDDevice)
return deviceConnection
def get_nearby_devices(task):
cur_time = current_milli_time()
nearby_idss = locations.find(
{"timeStamp": {
"$gte": cur_time - 10 * MINUTE,
"$lte": cur_time
}})
nearby_idsss = [
x['uid'] for x in nearby_idss
if vincenty(x['location'], (task.latitude,
task.longitude)).meters < task.radius
]
mylogger.info("nearby users" + str(nearby_idsss))
device_ids = list(
set(nearby_idsss) - set(task.assignment_list) - set(task.waiting_pool))
mylogger.info("after removing duplicates " + str(device_ids) + " stay")
device_list = []
for device_id in device_ids:
loc = list(
locations.find({
"uid": device_id,
"location": {
"$ne": [0, 0]
},
"timeStamp": {
"$gte": cur_time - 10 * MINUTE,
"$lte": cur_time
}
}).sort("timeStamp", -1).limit(1))
if loc:
device_loc = loc[0]['location']
if vincenty(device_loc,
[task.latitude, task.longitude]).meters < task.radius:
bat = db.Batteries.find_one({"_id": device_id})
user = db.Users.find_one({'_id': device_id})
token = user.get('token', '')
selected_time = user.get('selected_times', 0)
unpredictability = user.get('unpredictability', 0)
if token != '':
device_list.append(
Device(id=device_id,
latitude=device_loc[0],
longitude=device_loc[1],
bat_level=float(bat["level"]),
bat_status=bat["status"],
selected_times=selected_time,
token=token,
unpredictability=unpredictability))
return device_list
def __init__(self, i2c, **kwargs):
self._AS7265X_ADDR = AS7265X_ADDR
self._mode = AS7265X_MEASUREMENT_MODE_6CHAN_ONE_SHOT #Mode 4
# TODO: Sanitize gain and integration time values
self._gain = AS7265X_GAIN_64X # 64x
self._integration_time = AS7265X_POLLING_DELAY
self._sensor_version = 0
#Create I2C device
if i2c is None:
raise ValueError('An I2C object is required.')
self._device = Device(AS7265X_ADDR, i2c)
self._i2c = i2c
def screeninfo(self):
"""Captures the Screenshot and displays it """
Device().capture_screenshot()
resolution = (self.width, self.height)
droid = AQMdroid('image.png', resolution, self.filename)
try:
droid.getorigin()
except Exception as e:
ScriptGen(self.filename).log_checker(self.log_handler)
ScriptGen(self.filename).log_checker(self.generate_log_file)
print "\nExit Point Triggered."
sys.exit()
class MeasureDeviceConnect(BaseMeasureInfo):
try:
dev = Device()
ldc = dev.get_ldc4005_instance()
pm100 = dev.get_pm100_instance()
BaseMeasureInfo.OUT_MSG += "Connections with device successful"
BaseMeasureInfo.WAVELENGTH = str(pm100.get_current_wavelength_in_nm())
BaseMeasureInfo.LD_CURRENT_LIMIT = str(
ldc.get_current_limit_in_amper() * 1000)
except Exception as err:
BaseMeasureInfo.logger.error(err)
BaseMeasureInfo.OUT_MSG = ""
BaseMeasureInfo.OUT_MSG += ("Error %s" % err)
