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 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 __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'))
