def test_registration_build(self): tmpdir = tempfile.gettempdir() ver_dir = os.path.join(tmpdir, "infra") config = AgentConfig(tmpdir, ver_dir) config.set("agent", "prefix", tmpdir) config.set("agent", "current_ping_port", "33777") register = Register(config) data = register.build(State.INIT, State.INIT, {}, {}, "tag", 1) # print ("Register: " + pprint.pformat(data)) self.assertEquals(data["label"] != "", True, "hostname should not be empty") self.assertEquals(data["publicHostname"] != "", True, "publicHostname should not be empty") self.assertEquals(data["responseId"], 1) self.assertEquals(data["timestamp"] > 1353678475465L, True, "timestamp should not be empty") self.assertEquals(data["agentVersion"], "1", "agentVersion should not be empty") self.assertEquals(data["actualState"], State.INIT, "actualState should not be empty") self.assertEquals(data["expectedState"], State.INIT, "expectedState should not be empty") self.assertEquals(data["allocatedPorts"], {}, "allocatedPorts should be empty") self.assertEquals(data["logFolders"], {}, "allocated log should be empty") self.assertEquals(data["tags"], "tag", "tags should be tag") self.assertEquals(len(data), 10) self.assertEquals(posixpath.join(tmpdir, "app/definition"), config.getResolvedPath("app_pkg_dir")) self.assertEquals(posixpath.join(tmpdir, "app/install"), config.getResolvedPath("app_install_dir")) self.assertEquals(posixpath.join(ver_dir, "."), config.getResolvedPath("app_log_dir")) self.assertEquals(posixpath.join(ver_dir, "."), config.getResolvedPath("log_dir")) self.assertEquals(posixpath.join(ver_dir, "."), config.getResolvedPath("app_task_dir"))
def __init__( s ): s.src = Source() s.sink = Sink() s.r00 = Register( int ) s.r01 = Register( int ) s.dmu = DumbUnit( int ) s.r10 = Register( int ) s.r11 = Register( int ) s.connect_dict({ s.src.out0: s.r00.in_, s.src.out1: s.r01.in_, s.r00.out: s.dmu.in0, s.r01.out: s.dmu.in1, s.dmu.out0: s.r10.in_, s.dmu.out1: s.r11.in_, s.r10.out: s.sink.in0, s.r11.out: s.sink.in1, })
def __init__(self, config, range=30): threading.Thread.__init__(self) logger.debug('Initializing Controller RPC thread.') self.lock = threading.Lock() self.safeMode = True self.credential = None self.config = config self.hostname = hostname.hostname() server_secured_url = 'https://' + config.get( 'server', 'hostname') + ':' + config.get('server', 'secured_url_port') self.registerUrl = server_secured_url + '/agent/v1/register/' + self.hostname self.unregisterUrl = server_secured_url + '/agent/v1/unregister/' + self.hostname self.heartbeatUrl = server_secured_url + '/agent/v1/heartbeat/' + self.hostname self.netutil = NetUtil() self.responseId = -1 self.repeatRegistration = False self.cachedconnect = None self.range = range self.hasMappedComponents = True self.actionQueue = ActionQueue(self.config) self.actionQueue.start() self.register = Register(self.config) self.unregister = Unregister(self.config) self.heartbeat = Heartbeat(self.actionQueue, self.config)
def test_registration_build(self): tmpdir = tempfile.gettempdir() ver_dir = os.path.join(tmpdir, "infra") app_ver = "1.0.0" config = AgentConfig(tmpdir, ver_dir) config.set('agent', 'prefix', tmpdir) config.set('agent', 'current_ping_port', '33777') register = Register(config) data = register.build(State.INIT, State.INIT, {}, {}, app_ver, "tag", 1) #print ("Register: " + pprint.pformat(data)) self.assertEquals(data['label'] != "", True, "hostname should not be empty") self.assertEquals(data['publicHostname'] != "", True, "publicHostname should not be empty") self.assertEquals(data['responseId'], 1) self.assertEquals(data['timestamp'] > 1353678475465L, True, "timestamp should not be empty") self.assertEquals(data['agentVersion'], '1', "agentVersion should not be empty") self.assertEquals(data['actualState'], State.INIT, "actualState should not be empty") self.assertEquals(data['expectedState'], State.INIT, "expectedState should not be empty") self.assertEquals(data['allocatedPorts'], {}, "allocatedPorts should be empty") self.assertEquals(data['logFolders'], {}, "allocated log should be empty") self.assertEquals(data['appVersion'], app_ver, "app version should match") self.assertEquals(data['tags'], "tag", "tags should be tag") self.assertEquals(len(data), 11) self.assertEquals(posixpath.join(tmpdir, "app/definition"), config.getResolvedPath("app_pkg_dir")) self.assertEquals(posixpath.join(tmpdir, "app/install"), config.getResolvedPath("app_install_dir")) self.assertEquals(posixpath.join(ver_dir, "."), config.getResolvedPath("app_log_dir")) self.assertEquals(posixpath.join(ver_dir, "."), config.getResolvedPath("log_dir")) self.assertEquals(posixpath.join(ver_dir, "."), config.getResolvedPath("app_task_dir"))
def run_register_cmd(self): register = Register(self.fileHandler) output = register.execute(self.entry_username.get(), self.entry_password.get(), self.entry_fullname.get(), self.entry_email.get(), self.entry_phone.get()) self.lbl_status.config(text=output)
def __init__(self, sock, buffersize): super().__init__() self.sock = sock self.bufsize = buffersize self.regUI = Register(sock, buffersize) self.readUI = Reader(sock, buffersize) self.pushButton.clicked.connect(self.__register) self.pushButton_2.clicked.connect(self.__login_triger)
def __init__(self, num_size, cell_range, temp_amount, register_amount, debug=False): register_list = [Register('r_heap_value', False, False, num_size), Register('r_stack_value', False, False, num_size), Register('r_cell_index', False, False, num_size), Register('r_target_cell', True, False, num_size), # This register is not strictly necessary Register('r_cur_cmd', False, False, num_size), Register('r_stack_pointer', True, False, num_size), Register('r_flow_reserved', False, False, num_size)] register_list += [Register(f'r{i}', True, True, num_size) for i in range(register_amount)] register_list += [Register(f't{i}', False, False, num_size) for i in range(temp_amount)] self.register_list = RegisterList(register_list) self.vmc_size = self.register_list.total_size() self.cur_offset = 0 self.num_size = num_size self.cell_range = cell_range self.offset_heap_value = self.register_list.get_register_offset('r_heap_value') self.offset_stack_value = self.register_list.get_register_offset('r_stack_value') self.offset_cell_index = self.register_list.get_register_offset('r_cell_index') self.offset_target_cell = self.register_list.get_register_offset('r_target_cell') self.offset_cur_cmd = self.register_list.get_register_offset('r_cur_cmd') self.offset_stack_pointer = self.register_list.get_register_offset('r_stack_pointer') self.offset_flow_reserved = self.register_list.get_register_offset('r_flow_reserved') self.offset_reg = [self.register_list.get_register_offset(f'r{i}') for i in range(register_amount)] self.offset_temp = [self.register_list.get_register_offset(f't{i}') for i in range(temp_amount)] self.temp_allocator = TempAllocator(self.vmc_size, self.offset_temp) self.debug = debug
def addRegister(self, name: str, register:dict): r = Register(name, register) self.RegistersTreeRoot.appendRow(r.getRegisterViewRow()) address = "#/registers/" + name self.objectHandles[address] = r #Check if there are fields point to this register for fieldname, field in self.getFieldsOfRegister(name).items(): self.addFieldToRegisterTree(field)
def write_back(read_data: Bin, alu_result: Bin, write_reg: Register, control_signal: dict, instruction_eng): temp = namedtuple('Write_back', ['instruction_eng']) if (read_data is None and alu_result is None) or write_reg is None or control_signal is None: return temp(False) if control_signal.pop('reg_write'): write_data = mux([alu_result, read_data], control_signal.pop('mem_to_reg')) write_reg.write_data(write_data) return temp(instruction_eng)
def get_instructions(self, function=None, memory_allocation=None): operator = self._get_operator() # if not memory_allocation.in_register(self.left.name): # address = memory_allocation.get_address_by_variable_name(self.left.name, function) # self.instructions.append(Instruction(opcode="HIA", acc="Rx", operand=address)) # if not memory_allocation.in_register(self.right.name): # address = memory_allocation.get_address_by_variable_name(self.right.name, function) # self.instructions.append(Instruction(opcode="HIA", acc="Ry", operand=address)) # comment = self.left.name + " " + self.operation + " " + self.right.name self.instructions.append( Instruction(opcode=operator, acc=Register(1), operand=Register(2))) return self.instructions
def execute(pc, txt): nimonic, val, register = map(ord, txt[0:3]) if register == 0x00: regname = 'ax' else: raise "unknown register name specified" pcInc = 3 reg.setReg(regname, val) return pcInc
def test_registration_build(self): tmpdir = tempfile.gettempdir() ver_dir = os.path.join(tmpdir, "infra") config = AgentConfig(tmpdir, ver_dir) config.set('agent', 'prefix', tmpdir) config.set('agent', 'current_ping_port', '33777') try: os.mkdir(ver_dir) except OSError as exception: if exception.errno != errno.EEXIST: raise pass ver_file = os.path.join(ver_dir, "version") with open(ver_file, "w") as text_file: text_file.write("1.3.0") register = Register(config) data = register.build(State.INIT, State.INIT, {}, 1) #print ("Register: " + pprint.pformat(data)) self.assertEquals(data['hostname'] != "", True, "hostname should not be empty") self.assertEquals(data['publicHostname'] != "", True, "publicHostname should not be empty") self.assertEquals(data['responseId'], 1) self.assertEquals(data['timestamp'] > 1353678475465L, True, "timestamp should not be empty") self.assertEquals(data['agentVersion'], '1.3.0', "agentVersion should not be empty") self.assertEquals(data['actualState'], State.INIT, "actualState should not be empty") self.assertEquals(data['expectedState'], State.INIT, "expectedState should not be empty") self.assertEquals(data['allocatedPorts'], {}, "allocatedPorts should be empty") self.assertEquals(len(data), 8) self.assertEquals(os.path.join(tmpdir, "app/definition"), config.getResolvedPath("app_pkg_dir")) self.assertEquals(os.path.join(tmpdir, "app/install"), config.getResolvedPath("app_install_dir")) self.assertEquals(os.path.join(ver_dir, "."), config.getResolvedPath("app_log_dir")) self.assertEquals(os.path.join(ver_dir, "."), config.getResolvedPath("log_dir")) self.assertEquals(os.path.join(ver_dir, "."), config.getResolvedPath("app_task_dir")) os.remove(ver_file) os.removedirs(ver_dir)
def get_address(self, variable, function): """ Returns the address of a variable. A variable's address is calculated as follows: a) If the keyword 'register' is enabled, it is stored in a register, regardless whether it is a global variable or a local variable b) Otherwise, if it is a global variable, it is stored on the heap c) Otherwise, if it is a local variable, it is stored on the stack :param variable: :param function: :return: """ if variable.in_register(): return str( self.variables[variable.name]) # Return register location else: if variable.is_global_variable(): return variable.name else: # The local variable is stored in the stack of a function m = -1 for local_variable in function.local_variables: if variable == local_variable: return str(m) + str(Register(8)) else: m -= local_variable.get_size()
def start(self): # Create an object of the class MFRC522 MIFAREReader = MFRC522.MFRC522() # This loop keeps checking for chips. If one is near it will get the UID and authenticate while self.CONTINUE_READING: # Scan for cards (status,TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL) # Get the UID of the card (status,uid) = MIFAREReader.MFRC522_Anticoll() # If a card is found if status == MIFAREReader.MI_OK: self.__led(self.LED_GREEN, 1) time.sleep(0.5) self.__led(self.LED_GREEN, 0) # If we have the UID, continue if status == MIFAREReader.MI_OK: RFID = str(uid[0])+","+str(uid[1])+","+str(uid[2])+","+str(uid[3]) if self.MODE: record = Attendance().markAttendance(RFID) else: record = Register().new(RFID) if record: self.__led(self.LED_GREEN, 1) time.sleep(1) self.__led(self.LED_GREEN, 0)
class Controller(threading.Thread): def __init__(self, config): threading.Thread.__init__(self) logger.debug('Initializing Controller RPC thread.') self.lock = threading.Lock() self.safeMode = True self.credential = None self.config = config self.hostname = socket.gethostname() server_secured_url = 'https://' + config.get( 'server', 'hostname') + ':' + config.get('server', 'secured_url_port') self.registerUrl = server_secured_url + '/agent/register/' + self.hostname self.heartbeatUrl = server_secured_url + '/agent/heartbeat/' + self.hostname self.netutil = NetUtil() def start(self): self.actionQueue = ActionQueue(self.config) self.actionQueue.start() self.register = Register() self.heartbeat = Heartbeat(self.actionQueue) pass def __del__(self): logger.info("Server connection disconnected.") pass def registerWithServer(self): retry = False firstTime = True registered = False id = -1 ret = {} while registered == False: try: data = json.dumps(self.register.build(id)) logger.info("Registering with the server " + pprint.pformat(data)) req = urllib2.Request(self.registerUrl, data, {'Content-Type': 'application/json'}) stream = security.secured_url_open(req) response = stream.read() stream.close() ret = json.loads(response) logger.info("Registered with the server with " + pprint.pformat(ret)) registered = True pass except Exception, err: delay = self.netutil.CONNECT_SERVER_RETRY_INTERVAL_SEC logger.info("Unable to connect to: " + self.registerUrl, exc_info=True) """ Sleeping for {0} seconds and then retrying again """.format( delay) time.sleep(delay) pass pass return ret
class Login(LoginUI): def __init__(self, sock, buffersize): super().__init__() self.sock = sock self.bufsize = buffersize self.regUI = Register(sock, buffersize) self.readUI = Reader(sock, buffersize) self.pushButton.clicked.connect(self.__register) self.pushButton_2.clicked.connect(self.__login_triger) def __login_triger(self): user_id = self.lineEdit.text() password = self.lineEdit_2.text() if len(user_id) <= 0: QtWidgets.QMessageBox.warning(self.pushButton, "Warning", "User ID can not be empty!", QtWidgets.QMessageBox.Yes) self.lineEdit.setFocus() elif len(password) <= 0: QtWidgets.QMessageBox.warning(self.pushButton, "Warning", "Password can not be empty!", QtWidgets.QMessageBox.Yes) self.lineEdit.setFocus() elif login(self.sock, user_id, password, self.bufsize) == 1: self.readUI.set_login(user_id) self.readUI.initUi() self.readUI.show() self.close() else: QtWidgets.QMessageBox.warning(self.pushButton, "Warning", "Wrong User ID or Password!", QtWidgets.QMessageBox.Yes) self.lineEdit.setFocus() def __register(self): self.regUI.show()
def __init__(self): self.db = DB() self.__employees = Employees(self) self.__vendors = Vendors(self) self.__time_clock = TimeClock(self) self.__orders = Orders(self) self.__inventory = Inventory(self) self.__register = Register(self) self.account = Account()
def get_instructions(self, function=None, memory_allocation=None): memory_allocation.set_active_register(Register(1)) self.instructions.append( Instruction(opcode='HIA', modus='w', acc='R1', operand=self.value, comment='R1 <- ' + str(self.value))) return self.instructions
def __init__(self, *args, **kwargs): self._state = "start" super(MessageCounter, self).__init__(*args, **kwargs) self._msgContent = "" self.cnx = DBHelper.connection(); self.cursor = DBHelper.setup_cursor(self.cnx) self.reg = Register(self.sender) login = KeyboardButton(text='ورود', request_contact=True) reg = KeyboardButton(text='ثبت نام') self.initial = [[login , reg]] self.userInfo = { 'name': "", 'age': "", 'sex': "", 'field': "" }
def register(): form = signup(request.form) if request.method == 'POST' and form.validate(): if form.accountType.data == "iuser" or form.accountType.data == "idoctor" or form.accountType.data == "iinstructor": accountType = form.accountType.data username = form.username.data password = form.password.data user = Register(accountType, username, password) user_db = root.child('accounts') user_db.push({ 'account type': user.get_accountType(), 'username': user.get_username(), 'password': user.get_password(), }) # flash("Hello"+user.get_username(),"success") return redirect(url_for('login')) return render_template('register.html', form=form)
def execution(read_data1: Register, read_data2: Register, sign_extend: Bin, write_reg: Register, control_signal: dict, instruction_eng): temp = namedtuple('Execution', [ 'alu_result', 'write_data', 'write_reg', 'control_signal', 'instruction_eng' ]) if read_data1 is None or\ read_data2 is None or\ sign_extend is None or\ write_reg is None or\ control_signal is None: return temp(None, None, None, None, None) alu_control = alu_control_unit(control_signal.pop('alu_op'), sign_extend[0:6]) read_data_2_alu = mux([read_data2.read_data(), sign_extend], control_signal.pop('alu_src')) alu_out = alu(read_data1.read_data(), read_data_2_alu, alu_control) return temp(alu_out.result, read_data2, write_reg, control_signal, instruction_eng)
def test_registration_build(self): tmpdir = tempfile.gettempdir() ver_dir = os.path.join(tmpdir, "infra") config = AgentConfig(tmpdir, ver_dir) config.set('agent', 'prefix', tmpdir) config.set('agent', 'current_ping_port', '33777') register = Register(config) data = register.build(State.INIT, State.INIT, {}, {}, "tag", 1) #print ("Register: " + pprint.pformat(data)) self.assertEquals(data['label'] != "", True, "hostname should not be empty") self.assertEquals(data['publicHostname'] != "", True, "publicHostname should not be empty") self.assertEquals(data['responseId'], 1) self.assertEquals(data['timestamp'] > 1353678475465L, True, "timestamp should not be empty") self.assertEquals(data['agentVersion'], '1', "agentVersion should not be empty") self.assertEquals(data['actualState'], State.INIT, "actualState should not be empty") self.assertEquals(data['expectedState'], State.INIT, "expectedState should not be empty") self.assertEquals(data['allocatedPorts'], {}, "allocatedPorts should be empty") self.assertEquals(data['logFolders'], {}, "allocated log should be empty") self.assertEquals(data['tags'], "tag", "tags should be tag") self.assertEquals(len(data), 10) self.assertEquals(posixpath.join(tmpdir, "app/definition"), config.getResolvedPath("app_pkg_dir")) self.assertEquals(posixpath.join(tmpdir, "app/install"), config.getResolvedPath("app_install_dir")) self.assertEquals(posixpath.join(ver_dir, "."), config.getResolvedPath("app_log_dir")) self.assertEquals(posixpath.join(ver_dir, "."), config.getResolvedPath("log_dir")) self.assertEquals(posixpath.join(ver_dir, "."), config.getResolvedPath("app_task_dir"))
def __init__(self, root=None, log=None): self.log = log #initialize database self.database = FGR_DB(LOG_HANDLE) #{self.database.test_populate_database() #initialize register self.register = Register(root, self.database, LOG_HANDLE) #initialize Guests self.guests = Guests(root, self.database, LOG_HANDLE, self.child_window_closes) #initialize Registrations self.registrations = Registrations(root, self.database, LOG_HANDLE, self.child_window_closes) #initialize Export self.export = Export(root, self.database, LOG_HANDLE, self.child_window_closes) #initialize GUI self.root = root self.root_frm = tk.Frame(self.root) self.root_frm.grid() self.init_menu() self.init_widgets() #initialize mode self.mode = self.Mode.admin self.change_mode() #set the minimum size of the window root.update() root.minsize(root.winfo_width(), root.winfo_height())
def load_svd_definitions(self, svd_file): self.tree = ElementTree.ElementTree() self.tree.parse(path.expanduser(svd_file)) # Parse the svd defs into eclipse format peripherals = self.tree.findall('.//peripheral') for peripheral in peripherals: self.parse_svd_peripheral(peripheral, peripherals) #self.reg_defs = self.tree.getiterator('register') self.reg_defs = [] for i in self.tree.getiterator('register'): self.reg_defs.append(Register(i)) print("Loaded register definitions from SVD:", path.expanduser(svd_file))
def convert_operand_to_object(op): if op: if is_register(op): if op not in globals(): globals()[op] = Register(op) return globals()[op] if is_memory(op): return Memory(op) if is_address(op): return Address(op) if 'gs:' in op: return None return int(op, 16) else: return None
def __init__(self, manufacturer, build_date, purpose, ram, clock, visualizations): super().__init__(manufacturer, build_date, purpose) self.ram = RAM(manufacturer, build_date, "Random access memory", 16, ram) #RAM self.alu = ALU(manufacturer, build_date, "Arithmetic and Logic unit") #ALU #clock self.clock = Clock(manufacturer, build_date, "This component manages the time", clock) #Registers self.a = Register(manufacturer, build_date, "Register A", 4, "") self.b = Register(manufacturer, build_date, "Register B", 4, "") self.c = Register(manufacturer, build_date, "Register C", 4, "") self.d = Register(manufacturer, build_date, "Register D", 4, "") self.pc = Register(manufacturer, build_date, "Program Counter", 4, 0) self.ir = Register(manufacturer, build_date, "Instruction Register", 4, "") self.irb = Register(manufacturer, build_date, "Instruction Register", 4, "") self.oR = ORegister(manufacturer, build_date, "Output Register", 4, "") self.visualizations = visualizations
def get_base_registers(self): base_registers = [] if not self.get_type(): # not immediate type tmp_string = self.__string # "+" "-" "*" -> "." tmp_string = tmp_string.replace('+', '.').replace('-', '.').replace( '*', '.') for i in tmp_string.split('.'): ##v1.42 data should be striped to avoid space i = i.strip() ## if is_register(i): base_registers += [Register(i)] return base_registers
def __get_register_field(self, f): addr = f[0:2] if not addr in self.__registers: self.__registers[addr] = Register(addr) R = self.__registers[addr] if len(f) == 2: (s, e) = (0, 7) elif len(f) == 5: p = int(f[3:-1]) (s, e) = (p, p) elif len(f) > 5: (s, e) = map(int, f[3:-1].split(":")) else: raise InternalError("Cannot find register info from '%s'" % f) return R.get_register_field(s, e)
def load_definitions(self, defs_file): self.tree = ElementTree.ElementTree() self.tree.parse(path.expanduser(defs_file)) self.reg_defs = [] for rg in self.tree.findall(".//registergroup"): # Create a full name for the register based on the register group if required # Some registers don't use the base/group name, so fall back to register name for r in rg.findall('./register'): try: fullname = rg.attrib['name'] + '_' + r.attrib['name'].split('_',1)[1] except: fullname = r.attrib['name'] r.set('fullname',fullname) self.reg_defs.append(Register(r)) print("Loaded register definitions:", path.expanduser(defs_file))
def memory(alu_result: Bin, write_data: Register, write_reg: Register, control_signal: dict, instruction_eng): temp = namedtuple('Memory', [ 'read_data', 'alu_result', 'write_reg', 'control_signal', 'instruction_eng' ]) if alu_result is None or\ write_data is None or\ write_reg is None or\ control_signal is None: return temp(None, None, None, None, None) if control_signal.pop('mem_write'): data_mem[int(alu_result)] = write_data.read_data() if control_signal.pop('mem_read'): read_data = data_mem[int(alu_result)] else: read_data = None return temp(read_data, alu_result, write_reg, control_signal, instruction_eng)
def __init__(self, config, range=30): threading.Thread.__init__(self) logger.debug('Initializing Controller RPC thread.') self.lock = threading.Lock() self.safeMode = True self.credential = None self.config = config self.hostname = hostname.hostname() server_secured_url = 'https://' + config.get('server', 'hostname') + ':' + config.get('server', 'secured_url_port') self.registerUrl = server_secured_url + '/agent/v1/register/' + self.hostname self.unregisterUrl = server_secured_url + '/agent/v1/unregister/' + self.hostname self.heartbeatUrl = server_secured_url + '/agent/v1/heartbeat/' + self.hostname self.netutil = NetUtil() self.responseId = -1 self.repeatRegistration = False self.cachedconnect = None self.range = range self.hasMappedComponents = True self.actionQueue = ActionQueue(self.config) self.actionQueue.start() self.register = Register(self.config) self.unregister = Unregister(self.config) self.heartbeat = Heartbeat(self.actionQueue, self.config)
def allocate(self, variable, function): """ A variable is allocated as follows: a) If the keyword 'register' is enabled, it must be stored in a register, regardless whether it is a global variable or a local variable b) Otherwise, if it is a global variable, memory must be allocated on the heap (RESGR) c) Otherwise, if it is a local variable, memory must be allocated on the stack (AFT.w R9, size) :param function: :param variable: :return: """ if variable.in_register(): for i in range(self.nr_registers - 1, 0, -1): if self.registers[i] is None: self.registers[i] = Register(i, variable) self.variables[variable.name] = i if not variable.is_global_variable(): function.add_local_variable(variable) return raise Exception("All registers are full") elif not variable.is_global_variable(): # Local variable, not in register -> heap function.add_local_variable(variable)
from Register import Register r = Register(3) print(r)
class Controller(threading.Thread): def __init__(self, config, range=30): threading.Thread.__init__(self) logger.debug('Initializing Controller RPC thread.') self.lock = threading.Lock() self.safeMode = True self.credential = None self.config = config self.hostname = hostname.hostname() server_secured_url = 'https://' + config.get( 'server', 'hostname') + ':' + config.get('server', 'secured_url_port') self.registerUrl = server_secured_url + '/agent/v1/register/' + self.hostname self.unregisterUrl = server_secured_url + '/agent/v1/unregister/' + self.hostname self.heartbeatUrl = server_secured_url + '/agent/v1/heartbeat/' + self.hostname self.netutil = NetUtil() self.responseId = -1 self.repeatRegistration = False self.cachedconnect = None self.range = range self.hasMappedComponents = True self.actionQueue = ActionQueue(self.config) self.actionQueue.start() self.register = Register(self.config) self.unregister = Unregister(self.config) self.heartbeat = Heartbeat(self.actionQueue, self.config) def __del__(self): logger.info("Server connection disconnected.") pass def unregisterWithServer(self): id = -1 ret = self.retriedRequest(self.unregisterUrl, lambda: self.unregister.build(id)) if ret["response"] == "OK": logger.info("Unregistered with the server") print("Unregistered with the server") else: logMsg = "Error while unregistering with server: %s" % ret[ "errorMessage"] logger.info(logMsg) print(logMsg) return ret def registerWithServer(self): id = -1 ret = self.retriedRequest(self.registerUrl, lambda: self.register.build(id)) logger.info("Registered with the server") print("Registered with the server") return ret def retriedRequest(self, requestUrl, payloadBuilder): successfulRequest = False id = -1 ret = {} while not successfulRequest: try: data = json.dumps(payloadBuilder()) logger.info("Sending request to url " + requestUrl + " " + pprint.pformat(data)) response = self.sendRequest(requestUrl, data) ret = json.loads(response) logger.info("Request successful " + pprint.pformat(ret)) self.responseId = int(ret['responseId']) successfulRequest = True if 'statusCommands' in ret.keys(): logger.info("Got status commands on registration " + pprint.pformat(ret['statusCommands'])) self.addToQueue(ret['statusCommands']) pass else: self.hasMappedComponents = False pass except ssl.SSLError: self.repeatRegistration = False return except Exception, err: # try a reconnect only after a certain amount of random time delay = randint(0, self.range) logger.info("Unable to connect to: " + requestUrl, exc_info=True) """ Sleeping for {0} seconds and then retrying again """.format( delay) time.sleep(delay) pass pass return ret
class Controller(threading.Thread): def __init__(self, config, range=30): threading.Thread.__init__(self) logger.debug('Initializing Controller RPC thread.') self.lock = threading.Lock() self.safeMode = True self.credential = None self.config = config self.hostname = hostname.hostname() server_secured_url = 'https://' + config.get('server', 'hostname') + ':' + config.get('server', 'secured_url_port') self.registerUrl = server_secured_url + '/agent/v1/register/' + self.hostname self.unregisterUrl = server_secured_url + '/agent/v1/unregister/' + self.hostname self.heartbeatUrl = server_secured_url + '/agent/v1/heartbeat/' + self.hostname self.netutil = NetUtil() self.responseId = -1 self.repeatRegistration = False self.cachedconnect = None self.range = range self.hasMappedComponents = True self.actionQueue = ActionQueue(self.config) self.actionQueue.start() self.register = Register(self.config) self.unregister = Unregister(self.config) self.heartbeat = Heartbeat(self.actionQueue, self.config) def __del__(self): logger.info("Server connection disconnected.") pass def unregisterWithServer(self): id = -1 ret = self.retriedRequest(self.unregisterUrl, lambda: self.unregister.build(id)) if ret["response"] == "OK": logger.info("Unregistered with the server") print("Unregistered with the server") else: logMsg = "Error while unregistering with server: %s" % ret["errorMessage"] logger.info(logMsg) print(logMsg) return ret def registerWithServer(self): id = -1 ret = self.retriedRequest(self.registerUrl, lambda: self.register.build(id)) logger.info("Registered with the server") print("Registered with the server") return ret def retriedRequest(self, requestUrl, payloadBuilder): successfulRequest=False id = -1 ret = {} while not successfulRequest: try: data = json.dumps(payloadBuilder()) logger.info("Sending request to url " + requestUrl + " " + pprint.pformat(data)) response = self.sendRequest(requestUrl, data) ret = json.loads(response) logger.info("Request successful " + pprint.pformat(ret)) self.responseId= int(ret['responseId']) successfulRequest = True if 'statusCommands' in ret.keys(): logger.info("Got status commands on registration " + pprint.pformat(ret['statusCommands']) ) self.addToQueue(ret['statusCommands']) pass else: self.hasMappedComponents = False pass except ssl.SSLError: self.repeatRegistration=False return except Exception, err: # try a reconnect only after a certain amount of random time delay = randint(0, self.range) logger.info("Unable to connect to: " + requestUrl, exc_info = True) """ Sleeping for {0} seconds and then retrying again """.format(delay) time.sleep(delay) pass pass return ret
if force or changed_q: self.send_update_clock() def __freq_to_register_value(self,freq,twos_complement=False): """ Returns an integer that can be used to program the 6 byte frequency registers. """ if twos_complement: c1 = float(2**47) else: c1 = float(2**48) return int(freq*(c1/self.__SYSCLK)) def __get_frequency_resolution(self): c1 = float(2**48) return self.__SYSCLK/c1 if __name__ == "__main__": from Recipe import Recipe R = Recipe(r"D:\tmp\bcode.utb") R.start() D = DDS(address=30,refclock=15*10**6,refclock_multiplier=20) reg = Register("1f",D) reg.set(4,0,5) reg.set_bit(5,1) reg.set_bit(6,1) R.end() print reg
def execute(): sys.exit(reg.getReg('ax'))