def __init__(self,
name=_NAME_,
pins=_PINS_,
degree_per_step=_DEGREE_PER_STEP_,
max_rpm=_MAX_RPM_,
GPIO=None,
pigpio=None,
pigpio_pi=None,
**kwargs):
IODevice.__init__(self,
name=name,
dtype='Stepper Motors',
display=True,
GPIO=GPIO,
pigpio=pigpio,
pigpio_pi=pigpio_pi)
self.MCP = None
self.driver = 'DRV8825'
self.pins = pins
self.degree_per_step = degree_per_step
self.max_rpm = max_rpm
self.rpm = 0
self.direction = 'stopped'
self.resolution = None
self.waveform_id = None
self.waveform = None
self.continuous_pulse_delay = None
self.operation_type = None
def start_io_device(self, device):
self.devices[device] = IODevice(device,
systemManager=self,
processList=self.system_process_list)
self.devices[device].setDaemon(True)
self.devices[device].start()
Logger().log(["{0} Device Started".format(device)])
def __init__(self, cpu, mmu, hard_disk, scheduling_policy=RoundRobin(3)):
self.pids = 0
# Queues
self.ready_queue = queue.Queue()
# Hardware
self.hard_disk = hard_disk
self.mmu = mmu
# Interruption Manager
self.interruption_manager = InterruptionManager(self)
# Scheduling
self.short_term_scheduler = ShortTermScheduler(self.ready_queue, scheduling_policy)
self.long_term_scheduler = LongTermScheduler(self.ready_queue)
# Cpu
self.cpu = cpu
self.cpu.set_scheduler(self.short_term_scheduler)
self.cpu.set_mmu(self.mmu)
self.cpu.set_interruption_manager(self.interruption_manager)
# IO
self.console = Console()
self.io = IODevice(self.interruption_manager)
self.clock = Clock("Cpu - IntManager clock", [self.cpu, self.interruption_manager])
def boot(self):
self.os_start = time()
self.number_of_processes = 0
self.io = IODevice(self.Wait_Queue, self.Ready_Queue)
self.io.start()
self.cpu = CPU(self.time_slice)
with open(self.file_name, 'r') as csvfile:
processReader = csv.reader(csvfile)
for row in processReader:
ID, arrival, priority, program = row
ID = int(ID)
arrival = int(arrival)
priority = int(priority)
program = program.strip().strip(';')
program = [int(i) for i in program]
program = interpret(program)
process = ProcessImage(ID, arrival, priority, program)
self.New_Queue.put(process)
self.number_of_processes += 1
self.put_in_ready_queue()
def available_device(self):
list_of_path_usb_device = self._create_list_of_usb_device()
for path_usb_device in list_of_path_usb_device:
self.map_device[path_usb_device] = (
IODevice(path_usb_device).get_name())
return self.map_device
def __init__(self, usb_port):
try:
self.device = IODevice(usb_port)
self._check_if_device_is_correct()
except BadDeviceException:
print("Bad device. This is not PM100")
class PM100:
def __init__(self, usb_port):
try:
self.device = IODevice(usb_port)
self._check_if_device_is_correct()
except BadDeviceException:
print("Bad device. This is not PM100")
def _check_if_device_is_correct(self):
correct_name = b'Thorlabs,PM100USB,P2001205,1.3.0\n'
device_name = self.device.get_name()
if correct_name != device_name:
raise BadDeviceException
def get_current_wavelength_in_nm(self):
self.device.write("CORRection:WAVelength? ")
current_wavelength = self.device.read(100)
return float(current_wavelength)
def set_wavelength_in_nm(self, value):
self.device.write("CORRection:WAVelength " + str(value))
def get_power(self):
self.device.write("INITiate")
self.device.write("MEASure:POWer")
self.device.write("FETCh?")
value = self.device.read(100)
return float(value)
def get_minimum_wavelength_in_nm(self):
self.device.write("CORRection:WAVelength? MIN")
minimum_wavelength = self.device.read(30)
return float(minimum_wavelength)
def get_maximum_wavelength_in_nm(self):
self.device.write("CORRection:WAVelength? MAX")
maximum_wavelength = self.device.read(30)
return float(maximum_wavelength)
def connect_with_device(port_to_device):
device = IODevice(port_to_device)
return device
class LDC4005:
def __init__(self, usb_port):
try:
self.device = IODevice(usb_port)
self._check_if_device_is_correct()
except BadDeviceException:
print("Bad device. This is not LDC4005")
def _check_if_device_is_correct(self):
correct_name = b'Thorlabs,LDC4005,M00298547,1.5.0/1.5.0\n'
device_name = self.device.get_name()
if correct_name != device_name:
raise BadDeviceException
def on(self):
self.device.write("OUTPut ON")
def off(self):
self.device.write("OUTPut OFF")
def ld_current_in_A_setpoint(self, level):
self.device.write("SOURce:CURRent:LEVel:AMPLitude " + str(level))
def ld_current_reading(self):
self.device.write("INITiate")
self.device.write("MEASure:CURRent")
self.device.write("FETCh:CURRent?")
value = self.device.read(100)
return float(value)
def ld_voltage_reading(self):
self.device.write("INITiate")
self.device.write("MEASure:VOLTage")
self.device.write("FETCh:VOLTage?")
value = self.device.read(100)
return float(value)
def query_shape(self):
self.device.write("SOURce:FUNCtion:SHAPe?")
shape = self.device.read(100)
return str(shape)
def set_shape_dc(self):
self.device.write("SOURce:FUNCtion:SHAPe DC")
def set_shape_pulse(self):
self.device.write("SOURce:FUNCtion:SHAPe PULSe")
class Kernel:
def __init__(self, cpu, mmu, hard_disk, scheduling_policy=RoundRobin(3)):
self.pids = 0
# Queues
self.ready_queue = queue.Queue()
# Hardware
self.hard_disk = hard_disk
self.mmu = mmu
# Interruption Manager
self.interruption_manager = InterruptionManager(self)
# Scheduling
self.short_term_scheduler = ShortTermScheduler(self.ready_queue, scheduling_policy)
self.long_term_scheduler = LongTermScheduler(self.ready_queue)
# Cpu
self.cpu = cpu
self.cpu.set_scheduler(self.short_term_scheduler)
self.cpu.set_mmu(self.mmu)
self.cpu.set_interruption_manager(self.interruption_manager)
# IO
self.console = Console()
self.io = IODevice(self.interruption_manager)
self.clock = Clock("Cpu - IntManager clock", [self.cpu, self.interruption_manager])
#===============
#=== Methods ===
#===============
def save_program(self, program):
self.hard_disk.save_program(program)
def run(self, programs_name):
# get program
program = self.hard_disk.get_program(programs_name)
# create the new pcb with the current id
new_pcb = self.create_pcb_of(program)
# add the new process to the new process list
self.long_term_scheduler.add_new_process(new_pcb)
# NewPcb Interruption
self.interruption_manager.dispatch(NewPcb())
def create_pcb_of(self, a_program):
# load the program in memory
program_counter = self.mmu.load(a_program, self.pids)
# create the new Pcb with the current id
new_pcb = Pcb(self.pids, program_counter, a_program.length())
self.raise_pid()
return new_pcb
def raise_pid(self):
self.pids += 1
def start(self):
self.clock.start()
self.io.start()
def stop(self):
self.clock.stop()
self.io.clock.stop()
class OS(object):
def __init__(self, file_name, time_slice, scheduler_type):
self.New_Queue = Queue()
self.scheduler_type = scheduler_type
if scheduler_type is SchedulerType.FCFS:
self.Ready_Queue = Queue()
elif scheduler_type is SchedulerType.RR:
self.Ready_Queue = RoundRobinQueue()
elif scheduler_type is SchedulerType.Priority:
self.Ready_Queue = PriorityQueue()
self.Wait_Queue = Queue()
self.Terminated_Queue = Queue()
self.file_name = file_name
self.os_start = None
self.number_of_processes = 0
self.time_slice = time_slice
self.io = None
self.cpu = None
def __str__(self):
if self.scheduler_type is SchedulerType.FCFS:
return 'Class OS with Scheduler: FCFS'
elif self.scheduler_type is SchedulerType.RR:
return 'Class OS with Scheduler: RR'
elif self.scheduler_type is SchedulerType.Priority:
return 'Class OS with Scheduler: Priority'
def is_finished(self):
return self.New_Queue.empty() and self.Ready_Queue.empty(
) and self.Wait_Queue.empty() and self.io.is_finished(
) and not self.cpu.isCPUbusy()
def boot(self):
self.os_start = time()
self.number_of_processes = 0
self.io = IODevice(self.Wait_Queue, self.Ready_Queue)
self.io.start()
self.cpu = CPU(self.time_slice)
with open(self.file_name, 'r') as csvfile:
processReader = csv.reader(csvfile)
for row in processReader:
ID, arrival, priority, program = row
ID = int(ID)
arrival = int(arrival)
priority = int(priority)
program = program.strip().strip(';')
program = [int(i) for i in program]
program = interpret(program)
process = ProcessImage(ID, arrival, priority, program)
self.New_Queue.put(process)
self.number_of_processes += 1
self.put_in_ready_queue()
def put_in_ready_queue(self):
if self.New_Queue.empty():
return -1
else:
while not self.New_Queue.empty():
gettingReady = self.New_Queue.get()
gettingReady.set_ready()
self.Ready_Queue.put(gettingReady)
# process from the Ready_Queue for CPU execution
# Always check whether the CPU is idle or not; if yes, use your scheduler algorithm to select a
# According to the return value of CPU execute(), put the process into the corresponding queue
def scheduler(self):
if not self.cpu.isCPUbusy():
process = self.Ready_Queue.get()
else:
process = self.current_process
process.set_running()
remaining_time = self.cpu.execute(process)
if remaining_time == 0:
burst = process.next_instruction()
if burst is None:
process.set_terminated()
self.Terminated_Queue.put(process)
else:
process.set_waiting()
self.Wait_Queue.put(process)
else:
process.set_instruction_length(remaining_time)
if isinstance(self.Ready_Queue, RoundRobinQueue):
self.current_process = None
process.set_ready()
self.Ready_Queue.put(process)
else:
self.current_process = process
self.cpu.setCPUBusy()
def printReadyQueue(self):
for process in list(self.Ready_Queue.queue):
print(process)
def print_queue(self, queue):
if queue == "New":
for process in list(self.New_Queue.queue):
print(process.ID, process.arrival, process.priority,
process.program_counter, process.state)
if queue == "Ready":
for process in list(self.Ready_Queue.queue):
print(process.ID, process.arrival, process.priority,
process.program_counter, process.state)
if queue == "Wait":
for process in list(self.Wait_Queue.queue):
print(process.ID, process.arrival, process.priority,
process.program_counter, process.state)
if queue == "Terminated":
for process in list(self.Terminated_Queue.queue):
print(process.ID, process.arrival, process.priority,
process.program_counter, process.state)
# Record the time of every operation for computing your latency and response
def close(self):
self.io.join()
self.io.close()
def get_throughput(self):
return self.number_of_processes / (time() - self.os_start)