2b:null 2c:["$","title",null,{"children":"Motorola 6800 | Tech30k | Observable"}] 31:T68b0,function machine_6800(start_address) { function assemble(machine, assembly) { var binary_code = [] var byte_addresses = [] var byte_address = 0 var line_byte_addresses = [] var instruction_lengths = [] var labels = {} var labels_pass_2 = [] let assembly_lines = assembly.split("\n") for (var k = 0; k < assembly_lines.length; k++){ var byte_address_line = byte_address; var assembly_line_trim = assembly_lines[k].trim().split(";")[0] if (assembly_line_trim == "") { instruction_lengths.push(0); } else { var assembly_line_split = assembly_line_trim.split(" "); var a = assembly_line_split.filter(function (e) {return e != '';}); if (a.length > 0) { if (a[0].slice(-1) == ":") { var label = a[0].slice(0, -1); if (label.length > 0 && /^[a-z][a-z0-9]+$/.test(label)) { labels[label] = byte_address; a.shift(); } else { return {"error": "Incorrect label format for " + label}; } } } if (a.length > 0) { if (a.length > 2) { a = [a[0], a.slice(1).join("")]; } if (a.length == 2) { var hex = a[1].match(/\$[0-9a-fA-F]+/g); console.log(a[1]); if (hex != null) { for(var i=0; i 1) { var arg_value = a[1].match(/[0-9]+/)[0]; if (parseInt(arg_value) > 255) { possible_args = possible_args.filter(function(value) { return value[1] != "zpg" && value[1] != "zpg,X"; }) } } if (possible_args.length == 0){ return {"error": "Invalid opcode & addressing mode combination " + a, "assembly_output": ""}; } var opcode = possible_args[0][0]; var args = possible_args[0][1]; var code_length = machine.instructions.lengths[args]; binary_code.push(parseInt(opcode)); byte_addresses.push(byte_address); byte_address += 1; if (labels_found != null) { if (a.length > 1 && labels_found.length > 0) { for(var i=0; i 11) { i = {"code": il1[l] + " B", "mode": am1[h - 12]}; } else if (h > 7) { i = {"code": il1[l] + " A", "mode": am1[h - 8]}; } else if (h > 3) { i = {"code": il4[l] + reg_ext[h - 4], "mode": am2[h - 4]}; } else if (h == 2) { i = {"code": il2[l], "mode": "rel"}; } else if (h == 3) { i = {"code": il3[l], "mode": am3[l]}; } else if (h == 0) { i = {"code": il5[l], "mode": "inh"}; } else if (h == 1) { i = {"code": il6[l], "mode": "inh"}; } instructions.push(i); } } const no_op = {"code": "-", "mode": "-"} for(var i = 0; i < 256; i++){ if (instructions[i]["code"][0] == "-") { instructions[i] = no_op } else if (instructions[i]["code"] == "LDS B") { instructions[i]["code"] = "LDX" } else if (instructions[i]["code"] == "STS B") { instructions[i]["code"] = "STX" } else if (instructions[i]["code"] == "LDS A") { instructions[i]["code"] = "LDS" } else if (instructions[i]["code"] == "STS A") { instructions[i]["code"] = "STS" } } const no_op_ins = [78, 94, 205, 221, 237, 253, 204, 220, 236, 252, 157, 207] for (var i = 0; i< no_op_ins.length; i++){ instructions[no_op_ins[i]] = no_op; } console.log(instructions); for(var i = 0; i < 256; i++) { instructions[i]["cycles"] = calculate_cycles(instructions[i]["code"], instructions[i]["mode"], 0); } return instructions; } function generate_instructions_index(instructions_opcodes){ var instructions_index = {}; for (const [opcode, assembly] of Object.entries(instructions_opcodes)) { if (assembly.instructions_opcodes != "-") { if (instructions_index.hasOwnProperty(assembly.code)){ instructions_index[assembly.code].push([opcode, assembly.mode]); } else { instructions_index[assembly.code] = new Array(); instructions_index[assembly.code].push([opcode, assembly.mode]); } } } return instructions_index; } function generate_instructions_lengths(){ return {"imm": 2, "dir": 2, "idx": 2, "ext": 3, "rel":2, "acc":1, "-": 1, "inh": 1, "ind": 2} } function generate_argument_options(){ return {"A": ["A"], "@": ["zpg", "abs", "rel"], "#@": ["#"], "@,X": ["zpg,X", "abs,X"], "@,Y": ["abs,Y"], "(@,X)":["(zpg,X)"], "(@),Y": ["(zpg),Y"], "(@)":["(abs)"] }; } function generate_instruction_descriptions(){ return {"ABA": "Add accumulator B to accumulator A", "ADC": "Add with carry", "ADD": "Add without carry", "AND": "Logical AND", "ASL": "Arithmetic shift left", "ASR": "Arithmetic shift right", "BCC": "Branch on carry clear", "BCS": "Branch on carry set", "BEQ": "Branch if equal", "BGE": "Branch if greater than or equal to zero", "BGT": "Branch if greater than zero", "BIT": "Test bits with accumulator", "BLE": "Test bits with accumulator", "BLS": "Test bits with accumulator", "BLT": "Test bits with accumulator", "BMI": "Branch on result minus", "BNE": "Branch on result not zero", "BPL": "Branch on result plus", "BRA": "Branch on result plus", "BSR": "Branch on result plus", "BVC": "Branch on result plus", "BVS": "Branch on result plus", "CBA": "Branch on result plus", "CLC": "Branch on result plus", "CLI": "Branch on result plus", "CLR": "Branch on result plus", "CLV": "Branch on result plus", "CMP": "Branch on result plus", "COM": "Branch on result plus", "CPX": "Branch on result plus", "DAA": "Branch on result plus", "DEC": "Branch on result plus", "DES": "Branch on result plus", "DEX": "Branch on result plus", "EOR": "Branch on result plus", "INC": "Branch on result plus", "INS": "Branch on result plus", "INX": "Branch on result plus", "JMP": "Branch on result plus", "JSR": "Branch on result plus", "LDA": "Branch on result plus", "LDS": "Branch on result plus", "LDX": "Branch on result plus", "LSR": "Branch on result plus", "NEG": "Branch on result plus", "NOP": "Branch on result plus", "ORA": "Branch on result plus", "PSH": "Branch on result plus", "PUL": "Branch on result plus", "ROL": "Branch on result plus", "ROR": "Branch on result plus", "RTI": "Branch on result plus", "RTS": "Branch on result plus", "SBA": "Branch on result plus", "SBC": "Branch on result plus", "SEC": "Branch on result plus", "SEI": "Branch on result plus", "SEV": "Branch on result plus", "STA": "Branch on result plus", "STS": "Branch on result plus", "STX": "Branch on result plus", "SUB": "Branch on result plus", "SWI": "Branch on result plus", "TAB": "Branch on result plus", "TAP": "Branch on result plus", "TBA": "Branch on result plus", "TPA": "Branch on result plus", "TST": "Branch on result plus", "TSX": "Branch on result plus", "TXS": "Branch on result plus", "WAI": "Branch on result plus", } } function generate_mode_descriptions(){ return {"imm": "Accumulator", "dir": "Immediate", "ext": "Zero Page", "idx": "Relative", "inh": "Absolute", "rel": "Absolute,X", "acc": "Absolute,X", "-": "-" } } function calculate_cycles(op, mode){ const cycle_mode_base = {"imm": 2, "dir": 3, "idx": 5, "ext": 4, "rel":4, "acc":1, "-": 0, "inh": 2, "ind": 5} const cycle_instruction_base = {} var cycles = cycle_mode_base[mode]; if (op in cycle_instruction_base) { cycles = cycle_instruction_base[op]; } return cycles; } function generate_registers(regs) { var reg = {}; for (var i = 0; i < regs.length; i++) { reg[regs[i]] = 0; } return reg; } function init_memory() { memory = Array(0xffff); for (let m = 0; m <= 0xffff; m++) { memory[m] = 0; } return memory; } function backstep(machine) { var memory = machine.state.memory; var memory_type = machine.state.memory_type; var execution_record = machine.state.execution_record; if (execution_record.length > 0) { var fer = execution_record[execution_record.length - 1]; var f = fer.flags; var r = fer.registers; machine.state.flags = {"c": f.c, "s": f.s, "z": f.z, "d": f.d, "o": f.o, "i":f.i} machine.state.registers = {"a": r.a, "x": r.x, "y":r.y, "p":r.p, "pc":r.pc, "sp":r.sp} for (var i = 0; i < fer.memory_changes.length; i++) { var mc = fer.memory_changes[i]; memory[mc.address] = mc.old; } machine.state.cycles = machine.state.cycles - fer.cycles; execution_record.pop(); } return machine; } function execute_instructions(machine, no_instructions, no_cycles) { var instructions = machine.instructions.opcodes; var flag = machine.state.flags; var reg = machine.state.registers; var memory = machine.state.memory; var memory_type = machine.state.memory_type; var cycles = machine.state.cycles; var execution_records = machine.state.execution_records; const max_execution_records = 1000; let branch_options = {}; branch_options["CC"] = ["C", 0]; branch_options["CS"] = ["C", 1]; branch_options["EQ"] = ["Z", 1]; branch_options["NE"] = ["Z", 0]; branch_options["PL"] = ["N", 0]; branch_options["NI"] = ["N", 1]; branch_options["VC"] = ["V", 0]; branch_options["VS"] = ["V", 1]; function set_memory(address, value) { memory_changes.push({"address": address, "old": memory[address], "new": value}); memory[address] = value; } function push(byte) { set_memory(reg.sp + 0x100, byte); reg.sp = (reg.sp - 1) & 0xff; } function pop() { reg.sp = (reg.sp + 1) & 0xff; return memory[reg.sp + 0x100]; } function update_flags() { flag.n = (reg.p & 0x80) / 0x80; flag.v = (reg.p & 0x40) / 0x40; flag.d = (reg.p & 0x08) / 0x08; flag.i = (reg.p & 0x04) / 0x04; flag.z = (reg.p & 0x02) / 0x02; flag.c = (reg.p & 0x01) / 0x01; } function test_nz(v) { if (v == 0) { flag.z = 1; } else { flag.z = 0; } if ((v & 0x80) == 0) { flag.n = 0; } else { flag.n = 1; } } function test_nzc(v, a, c) { test_nz(v); if (a < c) { flag.c = 0; } else { flag.c = 1; } } var i_no = 1; var c_no = 1; while (true) { var memory_changes = []; var reg_old = JSON.parse(JSON.stringify(reg)); var flag_old = JSON.parse(JSON.stringify(flag)); if (memory[reg.pc] == -1) { return machine; } if (no_instructions != 0 && i_no > no_instructions) { return machine; } if (no_cycles != 0 && c_no > no_cycles) { return machine; } var op = instructions[memory[reg.pc]]; var opc = op["code"]; var opm = op["mode"]; var b2 = memory[(reg.pc + 1) & 0xffff]; var b3 = memory[(reg.pc + 2) & 0xffff]; var abs = (b3 * 256 + b2) & 0xffff; var operand; var address; var pc_inc = machine.instructions.lengths[opm]; switch (opm) { case "acc": operand = reg.a; case "dir": address = memory[abs] + 256 * memory[(abs + 1) & 0xffff]; break; case "ext": address = abs; operand = memory[abs]; break; case "idx": address = [reg.x + b2] & 0xffff; operand = memory[address]; break case "imm": operand = b2; break; } var op_letter_23 = opc.substring(0, 2); if (opc[0] == "B" && opc != "BIT") { var branch_details = branch_options[opc.substring(1, 3)]; if (flag[branch_details[0].toLowerCase()] == branch_details[1]) { var branch_vector = b2 < 128 ? b2 : b2 + 256 * 255; reg.pc = (reg.pc + branch_vector) & 0xffff; } } else if (op_letter_23 == "ST") { set_memory(address, reg[opc.substring(2).toLowerCase()]); } else if (op_letter_23 == "LD") { reg[opc.substring(2).toLowerCase()] = operand; test_nz(operand); } else if (op_letter_23 == "SE") { flag[opc.substring(2).toLowerCase()] = 1; } else if (op_letter_23 == "CL") { flag[opc.substring(2).toLowerCase()] = 0; } else if (opc[0] == "T") { reg[opc[2].toLowerCase()] = reg[opc[1].toLowerCase()]; } else { switch (opc) { case "ABA": break; case "ADC": var tmpa = reg.a + operand + flag.c; reg.a = tmpa & 0xff; flag.c = (tmpa & 0x100) / 0x100; test_nz(reg.a); break; case "ADD": break; case "AND": reg.a = reg.a & operand; test_nz(reg.a); break; case "ASL": if (opm != "A") { var tmpa = memory[address] * 2; flag.c = tmpa & 0x100; set_memory(address, tmpa & 0xff); } else { reg.a = reg.a * 2; flag.c = reg.a & 0x100; reg.a = reg.a & 0xff; } break; case "ASR": break; case "BIT": if (reg.a & (operand == 0)) { flag.z = 1; } else { flag.z = 0; } flag.n = (operand & 0x80) / 0x80; flag.v = (operand & 0x40) / 0x40; update_flags(); break; case "CBA": break; case "CMP": test_nzc(reg.a - operand, reg.a, operand); break; case "COM": break; case "CPX": break; case "DAA": break; case "DEC": set_memory(address, (memory[address] - 1) & 0xff); test_nz(memory[address]); break; case "INC": set_memory(address, (memory[address] + 1) & 0xff); test_nz(memory[address]); break; case "DEX": reg.x = (reg.x - 1) & 0xff; test_nz(reg.x); break; case "DEY": reg.y = (reg.y - 1) & 0xff; test_nz(reg.y); break; case "EOR": reg.a = reg.a ^ operand; test_nz(reg.a); break; case "INC": set_memory(address, (memory[address] + 1) & 0xff); test_nz(memory[address]); break; case "INX": reg.x = (reg.x + 1) & 0xff; test_nz(reg.x); break; case "INY": reg.y = (reg.y + 1) & 0xff; test_nz(reg.y); break; case "JMP": reg.pc = address; pc_inc = 0; break; case "JSR": push(((reg.pc + 3) & 0xff00) / 256); push((reg.pc + 3) & 0xff); reg.pc = address; pc_inc = 0; break; case "LSR": if (opm != "A") { flag.c = memory[address] & 0x1; set_memory(address, Math.floor(memory[address] / 2)); } else { flag.c = reg.a & 0x1; reg.a = Math.floor(reg.a / 2); } break; case "NEG": break; case "NOP": break; case "ORA": reg.a = reg.a | operand; test_nz(reg.a); break; case "ROL": if (opm != "A") { var tmpa = memory[address] * 2 + flag.c; flag.c = tmpa & 0x100; set_memory(address, tmpa & 0xff); } else { reg.a = reg.a * 2 + flag.c; flag.c = reg.a & 0x100; reg.a = reg.a & 0xff; } break; case "ROR": if (opm != "A") { var tmp_fc = flag.c; flag.c = memory[address] & 0x1; set_memory(address, Math.floor(memory[address] / 2) + 128 * tmp_fc); } else { var tmp_fc = flag.c; flag.c = reg.a & 0x1; reg.a = Math.floor(reg.a / 2) + 128 * tmp_fc; } break; case "RTI": reg.p = pop(); update_flags(); reg.pc = 0x100 * pop() + pop(); pc_inc = 0; break; case "RTS": var low_pop_address = pop(); reg.pc = 0x100 * pop() + low_pop_address; pc_inc = 0; break; case "SBC": tmpa = reg.a - operand - flag.c; reg.a = tmpa & 0xff; if (tmpa < 0) { flag.c = 1; } else { flag.c = 0; } test_nz(reg.a); break; case "TST": break; case "WAI": break; } } reg.pc = (reg.pc + pc_inc) & 0xffff; var cycles_new = calculate_cycles(opc, opm); machine.state.cycles += cycles_new; machine.state.execution_record.push(JSON.parse(JSON.stringify({"registers": reg_old, "flags": flag_old, "memory_changes": memory_changes, "cycles": cycles_new}))) if (execution_record.length > max_execution_records) { execution_record.shift(); } i_no += 1; c_no += cycles_new; } return machine; } var instructions = {}; instructions.opcodes = generate_instructions_opcodes(); instructions.index = generate_instructions_index(instructions.opcodes); instructions.lengths = generate_instructions_lengths(); instructions.instruction_descriptions = generate_instruction_descriptions(); instructions.mode_descriptions = generate_mode_descriptions(); instructions.argument_options = generate_argument_options(); var registers = generate_registers(["a", "b", "x", "sp", "pc", "s"]); var flags = generate_registers(["h", "v", "n" ,"i", "z", "c"]) registers.pc = parseInt(start_address); // Bit 5 of registers / P register is always set to 1 registers.p = 0x10; var memory = init_memory(); // memory type : 0 = RAM, 1 = ROM var memory_type = init_memory(); var cycles = 0; var execution_record = []; return {"instructions":instructions, "state": {"registers":registers, "flags":flags, "memory":memory, "memory_type": memory_type, "cycles":cycles, "execution_record": execution_record}, "execute":execute_instructions, "assemble":assemble, "backstep":backstep, "save_memory":save_memory, "reset":reset}; }32:T495,modelControls = () => { const buttons = html` ` buttons.value = true buttons.run.onclick = event => { buttons.onclick = () => mutable machine = mutable machine.execute(mutable machine, 10000, 0); } buttons.step.onclick = event => { buttons.onclick = () => mutable machine = mutable machine.execute(mutable machine, 1, 0); } buttons.backstep.onclick = event => { buttons.onclick = () => mutable machine = mutable machine.backstep(mutable machine); } buttons.save_assembly.onclick = event => { buttons.onclick = () => mutable machine = mutable machine.save_memory(binary_code, mutable machine); } buttons.reset.onclick = event => { buttons.onclick = () => mutable machine = mutable machine.reset(mutable machine, start_address); } return buttons }33:T563,function show_instructions(instructions, instruction_descriptions) { function generate_instructions(x, y) { var new_instructions = new Array; for(var i = 0; i < 256; i++){ new_instructions.push({"opcode": i, "code": x[i]["code"], "mode": x[i]["mode"], "cycles": x[i]["cycles"], "ins_desc": y[x[i]["op"]]}); } return new_instructions; } function generate_mode(mode) { return mode.length; } return Plot.plot({ height: 1000, width: 1000, padding: 0.05, grid: true, x: { axis: "top", label: "Low Nibble" }, y: { label: "High Nibble" }, color: { scheme: "blues", label: "Clock Cycles", legend: true }, marks: [ Plot.cell(generate_instructions(instructions, instruction_descriptions), { x: d => d.opcode - Math.floor(d.opcode / 16) * 16, y: d => Math.floor(d.opcode / 16), fill: d => d.cycles }), Plot.text( generate_instructions(instructions, instruction_descriptions), colorContrast({ x: d => d.opcode - Math.floor(d.opcode / 16) * 16, y: d => Math.floor(d.opcode / 16), fill: d => d.cycles, text: d => d.code + "\n" + d.mode, title: d => d.ins_desc + "\n" + d.cycles + " cycles", }) ) ] })}34:T4ac,function show_memory(memory, start, bytes) { function convert_memory(memory, mem_start, bytes){ var mem_objects = []; for(var i=mem_start; i< mem_start + bytes; i++){ mem_objects.push({address:i, memory:memory[i]}) } return mem_objects; } return Plot.plot({ width: 600, height: 600, padding: 0.03, grid: true, x: { axis: "top", label: "Low", }, y: { label: "High" }, color: { scheme: "blues", domain: [-128,384], }, marks: [ Plot.cell(convert_memory(memory, start, bytes), { x: d => d.address - Math.floor(d.address / 16) * 16, y: d => Math.floor(d.address / 16) * 16, fill: d => d.memory, }), Plot.text(convert_memory(memory, start, bytes), colorContrast({ x: d => d.address - Math.floor(d.address / 16) * 16, y: d => Math.floor(d.address / 16) * 16, fill: d => d.memory, text: d => ('00' + d.memory.toString(16).toUpperCase()).slice(-2), title: d => "#" + ('0000' + d.address.toString(16).toUpperCase()).slice(-4) + " : " + d.memory.toString(16).toUpperCase().slice(-2), })) ] }) }35:[{"id":"1d3ca806418a9f63ec1b4de719e5cc93b73f1d0e3f92dbd17a8049d0fd3ad3ad470e0a93fd80598b6e18925bbbe86e9bed7b3ee0cd06e8a07c7e12a6b1cbc4b9","href":"https://static.observableusercontent.com/files/1d3ca806418a9f63ec1b4de719e5cc93b73f1d0e3f92dbd17a8049d0fd3ad3ad470e0a93fd80598b6e18925bbbe86e9bed7b3ee0cd06e8a07c7e12a6b1cbc4b9","name":"Motorola_MC6800_microprocessor.jpg","type":"image/jpeg","lastModified":1659171058940.087,"size":47787}] 2f:{"id":"9a7a3a4f53430a9c","slug":null,"title":"Motorola 6800","thumbnail":"386bc1b63e1850d992731f78da8470a38835bbdd39c7f51263d9f703fc74df39","access_level":"public","create_time":"$D2022-07-30T08:49:20.770Z","update_time":"$D2022-07-31T09:39:16.828Z","view_time":null,"first_public_time":"$D2023-12-04T16:27:34.635Z","has_unpublished_edits":null,"fork":{"id":"4b3a684e96824d62","slug":"6502","title":"MOS Technology 6502","owner":{"id":"36ce9e29a2f21176","login":"tech30k","name":"Tech30k"}},"stars":1,"starred":false,"owner":{"type":"team","id":"36ce9e29a2f21176","login":"tech30k","name":"Tech30k","avatar_url":"https://avatars-next.observableusercontent.com/03221d4877d5f522ff1458722a34c1e534efc5b92fbaca29f6e910e5185a0d11","tier":"starter_2024"},"version":2046,"publish_version":null,"role":null,"authored":false,"authors":[{"type":"individual","id":"589c50682671c69f","login":"tech30k","name":"Tech30k","avatar_url":"https://avatars-next.observableusercontent.com/03221d4877d5f522ff1458722a34c1e534efc5b92fbaca29f6e910e5185a0d11","tier":null}],"members":[{"type":"individual","id":"589c50682671c69f","login":"tech30k","name":"Tech30k","avatar_url":"https://avatars-next.observableusercontent.com/03221d4877d5f522ff1458722a34c1e534efc5b92fbaca29f6e910e5185a0d11","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":0,"collection":null,"type":"notebook","body":{"titling":"auto","title":"Motorola 6800","cells":[{"id":0,"value":"# Motorola 6800","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1941,"value":"This should be considered as early beta software!","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1973,"value":"motorola_mc6800_microprocessor = FileAttachment(\"Motorola_MC6800_microprocessor.jpg\").image()","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1920,"value":"The Motorola 6800 is an 8-bit microprocessor launched in 1974.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1922,"value":"This notebook contains a 6800 assembler and emulator. It allows entry of 6800 assembly language in the \"Assembly Input\" box below. This code is then assembled and can be saved into the emulator. The emulator can then be run (until the program completes) or can be run one machine code instruction at a time. Execution can also be moved back one step at a time.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1690,"value":"#### Assembly Input","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1611,"value":"viewof code_input = Inputs.select([\"Loop to fill page zero\"], {value: \"Loop to fill page zero\", label: \"Code Examples\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1031,"value":"viewof code = Inputs.textarea({rows: 15, monospace: true, submit: true, value: code_examples[code_input]})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1693,"value":"#### Assembly Output","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1635,"value":"","pinned":false,"hidden":false,"mode":"html","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1937,"value":"Any errors in the assembly language are displayed below.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1465,"value":"machine.assemble(machine, code, 0)[\"error\"];","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1939,"value":"We can specify the start address for the machine code when it's run in the emulator.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1788,"value":"viewof start_address = Inputs.text({label: \"Execution Start Address\", placeholder: \"512\", value: \"512\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1950,"value":"The following controls allow code to be saved to the emulator, for it to be run and for it to be reset to its initial state.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1451,"value":"viewof x = modelControls()","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1910,"value":"---","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":485,"value":"### CPU\n#### Registers\n| A | B | X | S | SP | PC |\n| ----------- | ----------- | ----------- | ----------- | ----------- | ----------- |\n| `${hex(machine.state.registers.a,2)}` |`${hex(machine.state.registers.b,2)}` | `${hex(machine.state.registers.x,4)}` | `${hex(machine.state.registers.s,2)}` | `${hex(machine.state.registers.sp,4)}` | `${hex(machine.state.registers.pc,4)}` |\n\n#### Flags\n| H | I | N | Z | V | C |\n| ---------- | ---------- | ---------- | ---------- | ---------- | ---------- |\n| `${hex(machine.state.flags.h,1)}` |`${hex(machine.state.flags.i,1)}` | `${hex(machine.state.flags.n,1)}` | `${hex(machine.state.flags.z,1)}` | `${hex(machine.state.flags.v,1)}` | `${hex(machine.state.flags.c,1)}` |\n\n#### Cycles *\n\n${machine.state.cycles}\n\n* This is the number of machine cycles since the start of program execution.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"Registers","database":"$undefined"},{"id":1908,"value":"---","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1577,"value":"### Memory","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1400,"value":"#### Select Page Number","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1394,"value":"viewof memory_page = Inputs.range([0, 255], {value: 2, step: 1})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1582,"value":"sm3 = show_memory(machine.state.memory, memory_page * 256, 256);","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1935,"value":"### Opcodes\n\nOur emulator allows us to generate a chart with the assembly instruction corresponding to each of the opcodes used by the 6800. ","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":236,"value":"show_instructions(machine.instructions.opcodes, machine.instructions.instruction_descriptions)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1946,"value":"### Calculations\n\nThe following cells contain the code that generates the previous cell output.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1477,"value":"#### Define functions to create and run machine","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":4,"value":"$31","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1473,"value":"#### Create new machine","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":95,"value":"mutable machine = machine_6800(start_address);\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1833,"value":"binary_code = machine.assemble(machine, code)[\"machine_code\"];","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1625,"value":"#### Code Examples","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1627,"value":"code_examples = ({\"Loop to fill page zero\": \"org $200\\n\"});","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1496,"value":"### Utility Functions","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":1447,"value":"$32","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":29,"value":"$33","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":158,"value":"$34","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1376,"value":"function hex(n, d) {\n return n.toString(16).padStart(d, '0').toUpperCase();\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":933,"value":"colorContrast = ({ luminance = 60, ...options }) =>\n Plot.initializer(options, (data, facets, channels, scales) => {\n const contrast = (color) =>\n d3.hcl(color).l > luminance ? \"black\" : \"white\";\n return {\n channels: {\n fill: {\n ...channels.fill,\n scale: undefined,\n value:\n channels.fill == null // when options.fill is a constant color such as \"red\"\n || scales.color == null // when the scale isn't yet available (e.g. hexbin below)\n ? Array.from(data).fill(contrast(options.fill))\n : Array.from(channels.fill.value, (value) => contrast(scales.color(value)))\n }\n }\n };\n })","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1520,"value":"import {Plot} from \"@mkfreeman/plot-tooltip\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1962,"value":"machine","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W35","stdlib":"1"}} 30:"$2f:body"