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():
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 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 __init__(self, rom="invaders.rom"):
self.cpu = CPU()
self.memory = Memory()
self.memory.Load(rom)
self.ports = Puertos()
self.Screen = Screen()
def placePieceGeneric(self, locI, locJ):
board = CPU.convertBoard(self.cpu, self.getGameBoard())
currTurn = self.getCurrTurn()
if currTurn == "Player":
player = -1
else:
player = 1
five = self.fiveInARow(board, player)
self.checkWin()
if not self.getGameBoard()[locI][locJ].hasStone and not self.gameOver:
# Check who's turn it is
if currTurn == "Player":
self.getGameBoard()[locI][locJ].click(currTurn)
self.setCurrTurn("CPU")
board = CPU.convertBoard(self.cpu, self.getGameBoard())
five = self.fiveInARow(board, -1)
self.checkWin()
self.placePieceCPU()
elif currTurn == "CPU":
self.getGameBoard()[locI][locJ].click(currTurn)
self.setCurrTurn("Player")
board = CPU.convertBoard(self.cpu, self.getGameBoard())
five = self.fiveInARow(board, 1)
self.checkWin()
else:
return -1 # A problem occurred
five = self.fiveInARow(board, player)
board = CPU.convertBoard(self.cpu, self.getGameBoard())
self.checkWin()
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 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():
"""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 __init__(self):
super().__init__()
self.code = 0
self.cpu = CPU(None) # 初始IM中的元素是none，到时候判断是否为none即可
self.initUI()
class Chip8:
def __init__(self, rom_file):
self.mem = Mem()
self.mem.load_rom(rom_file)
self.cpu = CPU(START_ADDRESS, self.mem)
def run(self):
while True:
self.cpu.emulate_cycle()
def main():
channel.channel1.ChannelBusy = True
channel.channel3.ChannelBusy = True
channel.channel2.ChannelBusy = True
while (not channel.ChannelIdle()):
simulate()
CPU.Process()
CPU.IOInterrupt()
class Machine:
def __init__(self):
self.memory = Memory()
self.cpu = CPU(self.memory)
self.memory.Init()
def starting_up(self):
self.cpu.run()
def shut_down(self):
pass
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"""
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 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('')
class Computer:
cpu = None
process_table = None
# def startPc(self):
# self.process_table = ProcessTable()
#self.cpu = CPU(self.process_table.getRunningProcessRegisters())
def __init__(self):
self.process_table = ProcessTable()
self.cpu = CPU(self.process_table.getRunningProcessRegisters())
def print(self):
print()
print()
self.cpu.printRegisters()
print()
self.process_table.printProcess()
def ALUMemHelper(f, opcode: bytes, cpu: CPU.CPU):
#find the addressing mode of this operation. The addressing mode for the ALU operations are stored in bit 2, 3 and 4.
code = (opcode & 0b11100) >> 2
#use the helper function to retrieve the byte from memory
print("Counter: " + str(cpu.PC))
print(cpu.instructions[0:100])
nextbytes = cpu.instructions[cpu.PC + 1:cpu.PC + 1 + 2]
try:
print("Next bytes: " + str(nextbytes[0]) + " : " + str(nextbytes[1]))
except:
print("Next bytes: " + str(nextbytes[0]))
print("code: " + str(code))
val = getMemArray[code](cpu, nextbytes)
print("Memory address to be accessed: " + str(val[0]))
cpu.PC += val[1]
if (code == 2):
val = cpu.instructions[val[0]:val[0] + 1]
else:
val = cpu.ram.read_bytes(val[0], 1)
print("Val retrieved from memory: " + str(val))
#perform the ALU operation on the retrieved byte
result = f(cpu.A, val[0])
print("Result: " + str(result))
#TODO: not sure of the exact functionality of the carry bit. Should it be cleared if no carry occurs in bit 7?
#set cpu flags
if not (opcode >> 7 == 1):
fresult = result % 256
carry = result > fresult
cpu.P = (cpu.P & 0b01111100) | carry | (
(fresult == 0) << 1) | (fresult & 0b10000000)
result = fresult
#save result to accumulator
cpu.A = result
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 __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 main():
parser = ArgumentParser(description="Interpreter for the register machine")
parser.add_argument("infile", type=FileType("rb"), metavar="input", help="input file")
args = parser.parse_args()
cpu = CPU()
cpu.load_file(args.infile)
instr = 0
start = time.time()
while(not cpu.exit):
cpu.next_instruction()
instr += 1
taken = time.time() - start
ips = instr / taken
print("time elapsed: {:.6f} instructions executed: {}".format(taken, instr))
print("ips: {:.0f}".format(ips))
sys.exit(cpu.err)
def checkWin(self):
# Check which player wins and output it
board = CPU.convertBoard(self.cpu, self.getGameBoard())
cpuWon = self.fiveInARow(board, 1)
playerWon = self.fiveInARow(board, -1)
if not self.gameOver:
if playerWon > 0:
self.playerWins = True
self.gameOver = True
if cpuWon > 0:
self.computerWins = True
self.gameOver = True
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 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 bot():
"""
Loop runs to retrieve and process all new mentions
"""
lastSeen = get_last_seen()
batch = get_new_mentions() # pulls and processes new Tweets
commandsInBatch = process_tweet_batch(batch)[::-1]
for command in commandsInBatch: # for each command in the batch
log_user(command)
if command['cmd'] == "start":
userBoard = Board() # initializes the Board
if command['flag'] is None:
userBoard.gameDifficulty = 'easy'
elif command['flag'] == 'easy':
userBoard.gameDifficulty = 'easy'
elif command['flag'] == 'medium':
userBoard.gameDifficulty = 'medium'
elif command['flag'] == 'hard':
userBoard.gameDifficulty = 'hard'
playerFirst = bool(
random.getrandbits(1)) # determines if player is first
if playerFirst:
reply_board_message(
YOUR_TURN + str(userBoard), command['id'],
command['player']) # replies that it's player's turn
save_progress(userBoard,
command['player']) # creates player save file
elif not playerFirst:
CPU.play_move(userBoard, O) # plays CPU move on Board
reply_board_message("I'll start, I'll be " + Board.O + ": " +
str(userBoard), command['id'],
command['player'],
YOUR_TURN) # replies Board to Tweet
save_progress(
userBoard,
command['player']) # saves the user's game progress
elif command['cmd'] == "play":
try:
userBoard = load_progress(command['player'])
flagValid = (1 <= command['flag'] <= 9)
hasBeenPlayed = userBoard.has_been_played(command['flag'])
if flagValid and not hasBeenPlayed:
userBoard.play_move(
command['flag'], X
) # if the flag is valid and the move hasn't already been
# played
if userBoard.is_won(
): # if the user won the game with their move
botReply = reply_board_message(
YOU_PLAYED + str(userBoard.lastPlayed) + '\n' +
str(userBoard), command['id'], command['player']
) # replies the current board and the WON message
retweet_winner(botReply.id)
reply_message(random.choice(YOU_WON), botReply.id,
command['player'])
os.remove(
cache + command["player"] + ".txt"
) # deletes the save file if the game is over
elif userBoard.is_draw(
): # if the user forced a draw on the game with their move
botReply = reply_board_message(
YOU_PLAYED + str(userBoard.lastPlayed) + '\n' +
str(userBoard), command['id'],
command['player']) # replies the current board
# and the DRAW message
retweet_winner(botReply.id)
reply_message(random.choice(DRAW), botReply.id,
command['player'])
os.remove(cache + command["player"] +
".txt") # deletes the save file if the
# game is over
else: # if the user's move doesn't cause the end of the game
botReply = reply_board_message(
YOU_PLAYED + str(userBoard.lastPlayed) + '\n' +
str(userBoard), command['id'], command['player'],
MY_TURN)
CPU.play_move(userBoard,
O) # the CPU plays the best move
if userBoard.is_won(
): # if the CPU won the game with their move
botReply = reply_board_message(
I_PLAYED + str(userBoard.lastPlayed) + '\n' +
str(userBoard), botReply.id,
command['player']) # replies the current board
# and the WON message
retweet_winner(botReply.id)
reply_message(random.choice(I_WON), botReply.id,
command['player'])
os.remove(
cache + command["player"] + ".txt"
) # deletes the save file if the game is over
elif userBoard.is_draw(
): # if the CPU forced a draw on the game with their move
botReply = reply_board_message(
I_PLAYED + str(userBoard.lastPlayed) + '\n' +
str(userBoard), botReply.id,
command['player']) # replies the current board
# and the DRAW message
retweet_winner(botReply.id)
reply_message(random.choice(DRAW), botReply.id,
command['player'])
os.remove(cache + command["player"] +
".txt") # deletes the save file if
# the game is over
else: # if the CPU's move doesn't cause the end of the game
reply_board_message(
I_PLAYED + str(userBoard.lastPlayed) + '\n' +
str(userBoard), botReply.id, command['player'],
YOUR_TURN)
save_progress(userBoard, command['player']
) # saves the user's game progress
else:
if not flagValid: # if the given command flag isn't valid
reply_message(INCORRECT_INPUT, command['id'],
command['player'])
elif userBoard.has_been_played(
command['flag']
): # if the given command flag has already been
# played
reply_message(BEEN_PLAYED, command['id'],
command['player'])
except FileNotFoundError: # if the user tries to play a move on a game that hasn't started
reply_message(COMMAND_BEFORE_START, command['id'],
command['player'])
elif command['cmd'] == "quit":
try:
os.remove(cache + command["player"] + ".txt")
reply_message(COME_AGAIN, command['id'], command['player'])
except OSError:
reply_message(COMMAND_BEFORE_START, command['id'],
command['player'])
lastSeen = command['id']
update_last_seen(lastSeen)
time.sleep(600)
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 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())
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())
def do_init(self,args): """Initialize the CPU""" verbose=bool(args) self.cpu=CPU(verbose) self.initialized=True
class Shell(cmd.Cmd):
prompt='8008>'
initialized=False
def do_help(self,args):
rargs='do_'+args
if args and rargs in dir(self) and hasattr(self.__getattribute__(rargs),'__doc__'):
if self.__getattribute__(rargs).__doc__:
for line in self.__getattribute__(rargs).__doc__.splitlines():
print(line.strip())
elif args and not rargs in dir(self):
print('Command "{}" does not exists'.format(args))
else:
for cmd in dir(self):
if cmd.startswith('do_') and hasattr(self.__getattribute__(cmd),'__doc__'):
if self.__getattribute__(cmd).__doc__:
print(cmd[3:]+':',self.__getattribute__(cmd).__doc__)
def do_asm(self,args):
"""Enter Assembling mode"""
self.lastcmd=''
try:
if self.initialized:
self.cpu.load(code=asmsh())
else:
print('CPU not Initialized')
except Exception as e:
print(e)
def do_asm_img(self,args):
"""Enter Assembling mode (RAM Image Output)"""
self.lastcmd=''
try:
if self.initialized:
self.cpu.load(code=asmsh(fill=True))
else:
print('CPU not Initialized')
except Exception as e:
print(e)
def do_asm_file(self,args):
"""Load Assembler File"""
file=args
fill=True
if len(args)>1:
fill=args[1]
if self.initialized:
self.cpu.load(code=asm_file(file,fill))
else:
print('CPU not Initialized')
def do_init(self,args):
"""Initialize the CPU"""
verbose=bool(args)
self.cpu=CPU(verbose)
self.initialized=True
def do_load(self,args):
"""Load Assembled Program into RAM"""
if len(args):
file=args.split()[0]
if self.initialized:
print("Loading file {}".format(file))
self.cpu.load(file)
else:
print('CPU not Initialized')
def do_exit(self,args):
"""Exit"""
exit(0)
def do_EOF(self,args):
exit(0)
def do_rr(self,args):
"""print values of Registers"""
if self.initialized:
if args in self.cpu.registers:
print(self.cpu.registers[args])
else:
for r,v in self.cpu.registers.items():
print(r,v)
else:
print('CPU not Initialized')
def do_wr(self,args):
"""write value to Registers"""
value,reg='',''
if len(args.split())==2:
reg,value=args.split()
if value.isnumeric and reg in self.cpu.registers:
if self.initialized:
try:
self.cpu.registers[reg][0]=int(value)
except Exception as e:
print(e)
else:
print('CPU not Initialized')
def do_dumpmem(self,args):
"""Dump Memory"""
m_base=0
m_len=0
if len(args.split())>=2:
m_base=int(args.split()[0])
m_len=int(args.split()[1])
elif args:
m_len=int(args.split()[0])
else:
print('missing Argument "length"')
if self.initialized:
self.cpu.memory.dump(m_base,m_len)
else:
print('CPU not Initialized')
def do_go(self,args):
"""Execute Assembled Code"""
if self.initialized:
while 1:
if self.cpu.verbose:
self.cpu.dumpregs()
print("Flags:",self.cpu.flags)
print("Memory:")
self.cpu.memory.dump(length=8,width=32)
print('-'*10)
if not self.cpu():
break
else:
print('CPU not Initialized')
def do_bp(self,arg):
if self.initialized:
self.cpu.breakpoints.append(int(arg.split()[0]))
else:
print('CPU not Initialized')
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)
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)
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 __init__(self, rom_file):
self.mem = Mem()
self.mem.load_rom(rom_file)
self.cpu = CPU(START_ADDRESS, self.mem)
queueTypeList = ['SRT', 'RR']
memTypeList = ['nextfit', 'bestfit', 'firstfit']
burst_num = 0
urg_burst_sum = 0
for ptuple in processList:
burst_num += ptuple[3]
urg_burst_sum += ptuple[2] * ptuple[3]
outfile = open("simout.txt", "w")
for qtype in queueTypeList:
for mtype in memTypeList:
print "time 0ms: Simulator started for RR (t_slice 80) and ",
sys.stdout.write(mtype[:-3].capitalize()+"-"+mtype[-3:].capitalize())
print ""
cpu = CPU(queuetype=qtype, memtype = mtype)
for ptuple in processList:
cpu.addProcess(ProcessInfo(*ptuple))
cpu.run()
print ""
print ""
outfile.write("Algorithm %s with %s\n" %(qtype, mtype))
#outfile.write("-- average CPU burst time: %.2f ms\n" % (1.0 * cpu.burstTimeSum/burst_num))
outfile.write("-- average CPU burst time: %.2f ms\n" % (1.0 * urg_burst_sum/burst_num))
outfile.write("-- average wait time: %.2f ms\n" %(1.0 * cpu.waitTimeSum/ cpu.waitTimeNum))
outfile.write("-- average turnaround time: %.2f ms\n" %(1.0 * cpu.waitTimeSum/ cpu.waitTimeNum + urg_burst_sum/burst_num))
outfile.write("-- time spent on defragmentation : %.2f ms %.2f/100\n" %(cpu.defragtime, (100.0 * cpu.defragtime / urg_burst_sum) ))
outfile.write("-- total number of context switches: %d\n" % cpu.contentSwitchSum)
outfile.close()
