def main():
if algorithm == 'daxpy':
RAM_size = 3 * dimension * float_size
cpu = CPU(RAM_size=RAM_size,
cache_size=cache_size,
block_size=block_size,
associativity=associativity,
replacement=replacement)
Daxpy(cpu)
results(cpu, RAM_size)
if algorithm == 'mxm':
RAM_size = 3 * dimension**2 * float_size
cpu = CPU(RAM_size=RAM_size,
cache_size=cache_size,
block_size=block_size,
associativity=associativity,
replacement=replacement)
MXM(cpu)
results(cpu, RAM_size)
if algorithm == 'mxm_block':
RAM_size = 3 * dimension * dimension * float_size
cpu = CPU(RAM_size=RAM_size,
cache_size=cache_size,
block_size=block_size,
associativity=associativity,
replacement=replacement)
MXMblock(cpu)
results(cpu, RAM_size)
def get_exercise_three():
return [
[CPU(Constants.FIFO, get_exercise_three_processes()), Constants.FIFO],
[CPU(Constants.SJF, get_exercise_three_processes()), Constants.SJF],
[CPU(Constants.SRTF, get_exercise_three_processes()), Constants.SRTF],
[CPU(Constants.RR, get_exercise_three_processes(), 4), Constants.RR]
]
def main():
print(sys.argv)
# if len(sys.argv) > 2:
# if sys.argv[2] == 'true':
# DEBUG().ON()
# if sys.argv[2] == 'false':
# DEBUG().OFF()
if len(sys.argv) == 2:
if sys.argv[1].endswith('.bin'):
CPU().LOAD(sys.argv[1])
else:
print('Please select a microVM BIN file!')
elif len(sys.argv) == 3:
if sys.argv[1] == '--compile' or sys.argv[1] == '-c':
if sys.argv[2].endswith('.mvm'):
compile(sys.argv[2])
else:
print('Please select a microVM source file!')
else:
print('microVM: A Micro Virtual Machine!')
print('')
print('Options:')
print('<bin> | ex: mvm test.bin')
print('-c <file> | ex: mvm -c test.mvm | --compile')
print('')
def main():
"""main part"""
temphumi = DHT22_AM2302(19) # BCM 19 = PIN 35
temp_cpu = CPU()
measurements = {DS_TEMP1: Measurements(3), \
DS_TEMPCPU: Measurements(3), \
DS_TEMP2: Measurements(3), \
DS_HUMI: Measurements(3)}
rrd_template = DS_TEMP1 + ":" + \
DS_TEMPCPU + ":" + \
DS_TEMP2 + ":" + \
DS_HUMI
while (True):
_temp, _humi = temphumi.read()
measurements[DS_TEMP1].append(_temp)
measurements[DS_HUMI].append(_humi)
measurements[DS_TEMPCPU].append(temp_cpu.read())
measurements[DS_TEMP2].append(0) # empty, for later useage
rrd_data = "N:{:.2f}".format(measurements[DS_TEMP1].last()) + \
":{:.2f}".format(measurements[DS_TEMPCPU].last()) + \
":{:.2f}".format(measurements[DS_TEMP2].last()) + \
":{:.2f}".format(measurements[DS_HUMI].last())
print strftime("%H:%M:%S", localtime()), rrd_data
rrdtool.update(RRDFILE, "--template", rrd_template, rrd_data)
sleep(35)
def playGame(self) -> None:
player1 = Human("X","Player 1")
player2 = None
players = [player1]
numPlayers = self.getNumPlayers()
if numPlayers==1:
player2 = CPU()
player2.setOrder(2)
else:
player2 = Human("O", "Player 2")
players.append(player2)
self.modifyTurnOrder(players)
turn = 1
playedMoves = []
while not self.board.isGameOver() and turn<=9:
self.board.display()
print(players[(turn-1)%2].getName()+"'s Turn")
move = players[(turn-1)%2].getMove(self.board.getBoard(), turn,copy.copy(playedMoves))
playedMoves.append(move)
self.board.update(move,players[(turn-1)%2].getSymbol())
turn+=1
self.board.display()
if not self.board.isGameOver():
print("It's a Draw :|")
elif self.board.rowWinner()<0 or self.board.columnWinner()<0 or self.board.diagonalWinner()<0:
print(players[1].getName(), "wins!")
else:
print(players[0].getName(), "wins!")
def main():
"""main part"""
sq = SensorQueueClient_write("../../configs/weatherqueue.ini")
qvalue_temp = SensorValue("ID_06", "TempKinderzimmer",
SensorValue_Data.Types.Temp, "°C")
qvalue_humi = SensorValue("ID_07", "HumiKinderzimmer",
SensorValue_Data.Types.Humi, "% rF")
sq.register(qvalue_temp)
sq.register(qvalue_humi)
temphumi = DHT22_AM2302(19, qvalue_temp, qvalue_humi) # BCM 19 = PIN 35
temp_cpu = CPU()
measurements = {DS_TEMP1: Measurements(3), \
DS_TEMPCPU: Measurements(3), \
DS_TEMP2: Measurements(3), \
DS_HUMI: Measurements(3)}
udp = Sender(CREDENTIALS)
while (True):
_temp, _humi = temphumi.read()
measurements[DS_TEMP1].append(_temp)
measurements[DS_HUMI].append(_humi)
measurements[DS_TEMPCPU].append(temp_cpu.read_temperature())
measurements[DS_TEMP2].append(0) # empty, for later useage
rrd_data = "N:{:.2f}".format(measurements[DS_TEMP1].last()) + \
":{:.2f}".format(measurements[DS_TEMPCPU].last()) + \
":{:.2f}".format(measurements[DS_TEMP2].last()) + \
":{:.2f}".format(measurements[DS_HUMI].last())
# Log(rrd_data)
udp.send(rrd_data)
sleep(35)
def __init__(self, rom="invaders.rom"):
self.cpu = CPU()
self.memory = Memory()
self.memory.Load(rom)
self.ports = Puertos()
self.Screen = Screen()
def __init__(self):
super().__init__()
self.code = 0
self.cpu = CPU(None) # 初始IM中的元素是none，到时候判断是否为none即可
self.initUI()
def main():
parser = argparse.ArgumentParser(description="Nes Emulator")
parser.add_argument("rom_path",
type=str,
metavar="ROM",
help="Path to rom")
args = parser.parse_args()
# TODO: Verify ROM Path
rom = ROM(args.rom_path)
cpu = CPU()
def LoadCode(self):
fname = QFileDialog.getOpenFileName(self, 'open file', '.') # 直接打开本文件夹
if fname[0]:
with open(fname[0], 'r', encoding='utf-8') as file:
if self.cpu.isForwarding is False:
self.cpu = CPU(None)
else:
self.cpu = CPU(None)
self.cpu.isForwarding = True
self.code = file.read()
# 解析代码同时把解析后的代码放入cpu的IM中
anaylser = LexicalAnalyzer(self.code)
self.cpu.IM.initIM(anaylser.returnCodeAnalyse())
self.winSummary.getMessage(self.cpu)
self.winCode.getMessage(self.code)
self.winPipeLine.getMessage(None)
self.winRegFile.getMessage(self.cpu.RegFile.rf)
self.winDataMem.getMessage(self.cpu.DM.mem)
def main():
"""main part"""
temp1 = DS1820("/sys/bus/w1/devices/28-000006d62eb1/w1_slave")
temp2 = DS1820("/sys/bus/w1/devices/28-000006dd6ac1/w1_slave")
temp4 = DS1820("/sys/bus/w1/devices/28-000006de535b/w1_slave")
temphumi = DHT22_AM2302(21) # BCM 21 = PIN 40
tempcpu = CPU()
heatcontrol = Schedules.Control(Schedules.ScheduleHeat(), heatlamp)
lightcontrol = Schedules.Control(Schedules.ScheduleLight(), lightlamp)
measurements = {DS_TEMP1: Measurements(), \
DS_TEMP2: Measurements(), \
DS_TEMP3: Measurements(), \
DS_TEMP4: Measurements(), \
DS_TEMPCPU: Measurements(), \
DS_HUMI: Measurements()}
rrd_template = DS_TEMP1 + ":" + \
DS_TEMP2 + ":" + \
DS_TEMP3 + ":" + \
DS_TEMP4 + ":" + \
DS_TEMPCPU + ":" + \
DS_HUMI + ":" + \
DS_HEATING + ":" + \
DS_LIGHTING
while (True):
measurements[DS_TEMP1].append(temp1.read())
measurements[DS_TEMP2].append(temp2.read())
measurements[DS_TEMP4].append(temp4.read())
_temp3, _humi = temphumi.read()
measurements[DS_TEMP3].append(_temp3)
measurements[DS_HUMI].append(_humi)
measurements[DS_TEMPCPU].append(tempcpu.read())
heatcontrol.control(measurements[DS_TEMP3].avg())
lightcontrol.control(measurements[DS_TEMP3].avg())
rrd_data = "N:{:.2f}".format(measurements[DS_TEMP1].last()) + \
":{:.2f}".format(measurements[DS_TEMP2].last()) + \
":{:.2f}".format(measurements[DS_TEMP3].last()) + \
":{:.2f}".format(measurements[DS_TEMP4].last()) + \
":{:.2f}".format(measurements[DS_TEMPCPU].last()) + \
":{:.2f}".format(measurements[DS_HUMI].last()) + \
":{:}".format(heatlamp.status()) + \
":{:}".format(lightlamp.status())
print strftime("%H:%M:%S", localtime()), rrd_data
rrdtool.update(RRDFILE, "--template", rrd_template, rrd_data)
sleep(35)
def main():
"""main part"""
sq = SensorQueueClient_write("../../configs/weatherqueue.ini")
qvalue_temp = SensorValue("ID_06", "TempKinderzimmer",
SensorValue_Data.Types.Temp, "°C")
qvalue_humi = SensorValue("ID_07", "HumiKinderzimmer",
SensorValue_Data.Types.Humi, "% rF")
sq.register(qvalue_temp)
sq.register(qvalue_humi)
temphumi = DHT22_AM2302(19, qvalue_temp, qvalue_humi) # BCM 19 = PIN 35
temp_cpu = CPU()
measurements = {DS_TEMP1: Measurements(3), \
DS_TEMPCPU: Measurements(3), \
DS_TEMP2: Measurements(3), \
DS_HUMI: Measurements(3)}
rrd_template = DS_TEMP1 + ":" + \
DS_TEMPCPU + ":" + \
DS_TEMP2 + ":" + \
DS_HUMI
while (True):
_temp, _humi = temphumi.read()
measurements[DS_TEMP1].append(_temp)
measurements[DS_HUMI].append(_humi)
measurements[DS_TEMPCPU].append(temp_cpu.read_temperature())
measurements[DS_TEMP2].append(0) # empty, for later useage
rrd_data = "N:{:.2f}".format(measurements[DS_TEMP1].last()) + \
":{:.2f}".format(measurements[DS_TEMPCPU].last()) + \
":{:.2f}".format(measurements[DS_TEMP2].last()) + \
":{:.2f}".format(measurements[DS_HUMI].last())
# print(strftime("%H:%M:%S", localtime()), rrd_data)
# rrdtool.update(RRDFILE, "--template", rrd_template, rrd_data)
# python rrdtool seems not to work here; the pi needs a proper reinstall.
# as a workaround, i just call the os for rrd update
# rrd = "/usr/bin/rrdtool update {} --template {} {}".format(RRDFILE, rrd_template, rrd_data)
rrd = [
"/usr/bin/rrdtool", "update", RRDFILE, "--template", rrd_template,
rrd_data
]
print(rrd)
subprocess.call(rrd)
sleep(35)
def __init__(self):
self.gameOver = False
self.computerWins = False
self.playerWins = False
self.rows = 15
self.cols = 15
self.boxWidth = 50
self.objectGameBoard = []
self.stoneRadius = 20
self.firstPlayer = self.chooseFirstPlayerEasyDifficulty()
self.currTurn = self.firstPlayer
self.check = [False]
self.countfiv = [0, 0, 0, 0]
self.checkcom = [False]
self.countfivcom = [0, 0, 0, 0]
self.cpu = CPU(self.cols, self.rows)
def __init__(self, inputData):
self.inputData = inputData
nTasks = self.inputData.nTasks
nThreads = self.inputData.nThreads
nCPUs = self.inputData.nCPUs
nCores = self.inputData.nCores
rh = self.inputData.rh
rc = self.inputData.rc
CK = self.inputData.CK
TH = self.inputData.TH
self.tasks = [] # vector with tasks
for tId in xrange(0, nTasks): # tId = 0..(nTasks-1)
task = Task(tId)
for hId in xrange(0, nThreads): # hId = 0..(nThreads-1)
# if thread hId belongs to task tId
if (TH[tId][hId]):
# add thread hId requiring res resources to task tId
resources = rh[hId]
task.addThreadAndResources(hId, resources)
self.tasks.append(task)
self.cpus = [] # vector with cpus
self.maxCapacityPerCPUId = [
0
] * nCPUs # vector with max capacity of each CPU. initialized to nCPUs zeros [ 0 ... 0 ]
self.maxCapacityPerCoreId = [
0
] * nCores # vector with max capacity of each core. initialized to nCores zeros [ 0 ... 0 ]
for cId in xrange(0, nCPUs): # cId = 0..(nCPUs-1)
cpu = CPU(cId)
for kId in xrange(0, nCores): # kId = 0..(nCores-1)
# if core kId belongs to CPU cId
if (CK[cId][kId]):
# add core kId with capacity to CPU cId
capacity = rc[cId]
cpu.addCoreAndCapacity(kId, capacity)
self.maxCapacityPerCPUId[cId] += capacity
self.maxCapacityPerCoreId[kId] = capacity
self.cpus.append(cpu)
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 main():
# Ask the user for the hilillos to use
hilillos_to_use = -1
while hilillos_to_use != 0 and hilillos_to_use != 1 and hilillos_to_use != 2:
result = input(
"Ingrese un 0 para correr el hilillo facilísimo, "
"un 1 para los hilillos simples "
"o un 2 para los hilillos de la prueba final(Para ayuda, digite una h)\n"
)
if (str(result)).lower() == 'h':
print(
"\n\nAYUDA: Para utilizar hilillos distintos de los que se encuentran en el directorio del proyecto, remplace"
" el hilillo que se encuentra en Hilillos/Hilillo-FACILISIMO, y luego seleccione 0 al correr el "
"programa\n\n")
elif result.isdigit():
hilillos_to_use = int(result)
# Initialize CPU
quantum = input("Ingrese el quantum\n")
cpu = CPU(hilillos_to_use, int(quantum))
# Start the simulation
cpu.start_cores()
def main():
"""main part"""
temp_fridge = DS1820("/sys/bus/w1/devices/28-000006dc8d42/w1_slave")
temp_cpu = CPU()
temphumi = DHT22_AM2302(21) # BCM 21 = PIN 40
measurements = {DS_TEMP1: Measurements(3), \
DS_TEMPCPU: Measurements(3), \
DS_TEMP2: Measurements(3), \
DS_HUMI: Measurements(3)}
rrd_template = DS_TEMP1 + ":" + \
DS_TEMPCPU + ":" + \
DS_TEMP2 + ":" + \
DS_HUMI + ":" + \
DS_ON + ":" + \
DS_OPEN
while (True):
measurements[DS_TEMP1].append(temp_fridge.read_temperature())
measurements[DS_TEMPCPU].append(temp_cpu.read())
_temp, _humi = temphumi.read()
measurements[DS_TEMP2].append(_temp)
measurements[DS_HUMI].append(_humi)
if (measurements[DS_TEMP2].avg() > 5.2):
fridge.on()
if (measurements[DS_TEMP2].avg() < 5.0):
fridge.off()
# if (temp > 6): fridge.on()
# else if (temp > 5):
# fridge_on_time(60,90) # für 60 sekunden einschalten; 90 Sekunden mindestens aus
# else if (temp < 5.0):
# fridge.off()
# class fridge_... derived from class Heating
# threading: https://docs.python.org/2/library/threading.html
# multi inheritance: https://docs.python.org/2/tutorial/classes.html#multiple-inheritance
# class DerivedClassName(Base1, Base2, Base3):
# fridge_on_time:
# thread:
# with lock:
# timing = active
# __on()
# sleep(60)
# __off()
# sleep(90)
# with lock:
# timing = non_active
# in on(), off()
# ...
# if (active): pass
rrd_data = "N:{:.2f}".format(measurements[DS_TEMP1].last()) + \
":{:.2f}".format(measurements[DS_TEMPCPU].last()) + \
":{:.2f}".format(measurements[DS_TEMP2].last()) + \
":{:.2f}".format(measurements[DS_HUMI].last()) + \
":{:}".format(fridge.status()) + \
":{:}".format(reedcontact.status_stretched())
print strftime("%H:%M:%S", localtime()), rrd_data
rrdtool.update(RRDFILE, "--template", rrd_template, rrd_data)
writeMonitoringData(rrd_data)
sleep(35)
def __init__(self):
self.process_table = ProcessTable()
self.cpu = CPU(self.process_table.getRunningProcessRegisters())
from myhdl import *
from CPU import CPU
from helpers.Clock_Generator import clock_generator
from helpers.Random_Signal import random_signal
if (__name__ == "__main__"):
rst = Signal(bool(0))
regOut = []
for i in range(0, 32):
regOut.append(Signal(intbv(0, 0, 2**32)))
CPU_driver = traceSignals(CPU(rst, regOut))
sim = Simulation(CPU_driver)
sim.run(100000)
import time
from CPU import CPU
from GPU import GPU
from Memory import Memory
RUNNING = True
STEP = False
# Memory Init
Memory = Memory("TETRIS.gb")
# CPU Init
CPU = CPU(Memory)
CPU.DEBUG = False
# GPU Init, pass in the memory that has been initialized in the CPU
GPU = GPU(Memory)
time_display = time.clock()
while RUNNING:
cycles_before = CPU.cycles
CPU.fetch()
if CPU.PC >= 0x100:
print("0x" + hex(CPU.PC)[2:].zfill(4).upper() + " : ", end="")
CPU.decode()
print(CPU.debug_string + " ", end="")
for i in range(0, CPU.instruction_length - 1):
print(hex(CPU.args[i])[2:].zfill(2).upper() + " ", end="")
def main():
"""main part"""
qvalue_tempbox = SensorValueLock("ID_08", "TempDonutBox", SensorValue.Types.Temp, u'°C', Lock())
qvalue_humi = SensorValueLock("ID_09", "HumiDonut", SensorValue.Types.Humi, u'% rF', Lock())
qvalue_tempoutdoor = SensorValueLock("ID_12", "TempDonutOutDoor", SensorValue.Types.Temp, u'°C', Lock())
qvalue_heatlamp = SensorValueLock("ID_10", "SwitchHeatlamp", SensorValue.Types.Switch, u'Heizung:', Lock())
qvalue_lightlamp = SensorValueLock("ID_11", "SwitchLightlamp", SensorValue.Types.Switch, u'Beleuchtung:', Lock())
sq.register(qvalue_tempbox)
sq.register(qvalue_humi)
sq.register(qvalue_tempoutdoor)
sq.register(qvalue_heatlamp)
sq.register(qvalue_lightlamp)
sq.start()
temp1 = DS1820("/sys/bus/w1/devices/28-000006d62eb1/w1_slave", qvalue_tempoutdoor)
temp2 = DS1820("/sys/bus/w1/devices/28-000006dd6ac1/w1_slave")
temp4 = DS1820("/sys/bus/w1/devices/28-000006de535b/w1_slave")
temphumi = DHT22_AM2302(21, qvalue_tempbox, qvalue_humi) # BCM 21 = PIN 40
tempcpu = CPU()
heatcontrol = Schedules.Control(Schedules.ScheduleHeat(), heatlamp, qvalue_heatlamp)
lightcontrol = Schedules.Control(Schedules.ScheduleLight(), lightlamp, qvalue_lightlamp)
measurements = {DS_TEMP1: Measurements(), \
DS_TEMP2: Measurements(), \
DS_TEMP3: Measurements(), \
DS_TEMP4: Measurements(), \
DS_TEMPCPU: Measurements(), \
DS_HUMI: Measurements()}
rrd_template = DS_TEMP1 + ":" + \
DS_TEMP2 + ":" + \
DS_TEMP3 + ":" + \
DS_TEMP4 + ":" + \
DS_TEMPCPU + ":" + \
DS_HUMI + ":" + \
DS_HEATING + ":" + \
DS_LIGHTING
while (True):
measurements[DS_TEMP1].append(temp1.read_temperature())
measurements[DS_TEMP2].append(temp2.read_temperature())
measurements[DS_TEMP4].append(temp4.read_temperature())
_temp3, _humi = temphumi.read()
measurements[DS_TEMP3].append(_temp3)
measurements[DS_HUMI].append(_humi)
measurements[DS_TEMPCPU].append(tempcpu.read())
heatcontrol.control(measurements[DS_TEMP3].avg())
lightcontrol.control(measurements[DS_TEMP3].avg())
rrd_data = "N:{:.2f}".format(measurements[DS_TEMP1].last()) + \
":{:.2f}".format(measurements[DS_TEMP2].last()) + \
":{:.2f}".format(measurements[DS_TEMP3].last()) + \
":{:.2f}".format(measurements[DS_TEMP4].last()) + \
":{:.2f}".format(measurements[DS_TEMPCPU].last()) + \
":{:.2f}".format(measurements[DS_HUMI].last()) + \
":{:}".format(heatlamp.status()) + \
":{:}".format(lightlamp.status())
print strftime("%H:%M:%S", localtime()), rrd_data
rrdtool.update(RRDFILE, "--template", rrd_template, rrd_data)
sleep(35)
from Memory import Memory
from CPU import CPU
from Stack import Stack
from Register import Register, Flags, FlagRegister
memory = Memory()
register = Register()
flag_register = FlagRegister()
stack = Stack()
cpu = CPU(memory=memory,
registers=register,
flag_register=flag_register,
stack=stack)
def __init__(self, rom_file):
self.mem = Mem()
self.mem.load_rom(rom_file)
self.cpu = CPU(START_ADDRESS, self.mem)
import time
import RAM
from CPU import CPU
from RAM import RAM
from Discs import Discs
from GPU import GPU
PC_Id = 1
#import datetime
#import serial
#ser = serial.Serial(port='/dev/ttyUSB0', baudrate=115200, timeout=1, xonxoff=False, dsrdtr=False, interCharTimeout=False)
import requests
PC_Id = 1
scanCpu = CPU()
ScanRam = RAM()
scanHdd = Discs()
scanGpu = GPU()
while True:
hddt = scanHdd.getTempOfDiscs()
cput = scanCpu.getTempOfCPU()
cpuu = scanCpu.getLoadOfCpuByUptime()
cpul = scanCpu.getLoadOfCpuByIostat()
gld = scanGpu.getTempOfGPU()
ram = ScanRam.getUnusedRAM()
print("-----------------")
payload = {
'HDD_temp': hddt,
'CPU_temp': cput,
from myhdl import *
from CPU import CPU
from helpers.Clock_Generator import clock_generator
from helpers.Random_Signal import random_signal
if (__name__ == "__main__"):
rst = Signal(bool(0))
clock = Signal(intbv(0, 0, 2**1))
clock_driver = clock_generator(clock)
regOut = []
for i in range(0, 32):
regOut.append(Signal(intbv(0, 0, 2**32)))
CPU_driver = traceSignals(CPU(clock, rst, regOut))
sim = Simulation(CPU_driver, clock_driver)
sim.run(10000)
def __init__(self):
self.memory = Memory()
self.cpu = CPU(self.memory)
self.memory.Init()
from CPU import CPU
from Assembler import Assembler
Assembler('example/example.asm', 'example/example.bin')
CPU('example/example.bin')
from GUI import HackComputerGUI
from CPU import CPU
from ROM import ROM
from RAM import RAM
from VRAM import VRAM
if __name__ == "__main__":
#def __init__(self, ROM, RAM, is_print_state=False, log_path="log.txt"):
cpu = CPU(ROM(), RAM(), VRAM(), is_print_state=False)
hack_computer_GUI = HackComputerGUI(cpu)
hack_computer_GUI.run()
from Memory import Memory
from globalHelp import *
from SystemQueue import SystemQueue
from CPU import CPU
from Printer import Printer
from Logger import Logger
#---------------------------- Global Variables ----------------------------------------------
CPU = CPU()
Memory.initialise()
SystemBuffer.initialise()
Printer.initialize()
Logger.initialize()
def main():
channel.channel1.ChannelBusy = True
channel.channel3.ChannelBusy = True
channel.channel2.ChannelBusy = True
while (not channel.ChannelIdle()):
simulate()
CPU.Process()
CPU.IOInterrupt()
def simulate():
busyList = []
for ch in channel.channelList:
if ch.ChannelBusy:
def setUp(self):
self.cpu = CPU("tkinter")
