Creating a Computer using Transistors and Logic gates

Explore how a computer executes programs by fetching instructions from memory, moving zeros and ones through buses to CPU, guided by transistors, logic gates, and the arithmetic and logic unit.

The lecture uses lamps as switches to illustrate how information is encoded in binary, mapping lamp states to bits, digits, and bytes.

Explore decimal and binary numbering, explain how numbers map to powers of two, illustrate converting 45 to binary, compare memory addressing with different bit lengths, and show simple decimal-to-binary conversion.

Explore how binary, decimal, and hexadecimal numbering reveal memory sizing and addressing, and how grouping four bits into hex simplifies conversion and understanding of bytes, kilobytes, and megabytes.

Explore how a transistor acts as a switch controlled by gate voltage, around 0.7 volt, turning on to connect drain and source in mosfets and enabling nand and not logic.

Learn how to build a nand gate from transistors with two inputs a and b, analyze its four states, and recognize nand as a universal gate for computing.

Demonstrate a not gate built from transistors, showing input zero gives output one and input one gives output zero, using four transistors and an abstraction box.

Analyze how a 1-bit register is built from transistors and logic gates, using inputs I and Y to determine the output.

Explore how a transistor network forms a 1-bit register that writes with S=1 and remembers the last input state I, enabling readback from the output as memory.

design an eight-bit memory cell by wiring eight bit blocks in parallel with a shared input and a write enable signal, storing and recalling a byte.

Control an eight-bit register by adding enable and clock inputs; only when both enable and clock are high does the output update, forming an eight-bit register from eight one-bit blocks.

Understand how a decoder enables selective addressing of memory cells and registers by controlling enable lines from a shared bus, using a two-to-four example.

Describe a two-to-four decoder built from transistors that uses i1 and i2 to select one of four outputs, and show how it enables RAM registers via addressing.

demonstrates cascaded decoders to address 64 kilobytes of ram, using 16-bit addresses and an 8-bit data path, with enables, nand gates and not gates to select a single memory cell.

Explain how decoders and enable bits select a single register input from many to the data bus, and why a multiplexer is needed to route that data.

Demonstrates a transistor circuit that creates a multiplex, using gates on M1–M4 to control the output, and boxes the mux as an abstraction with three inputs, labeled A and B.

Discover how real chips use nand gates, decoders, and ram to implement registers and memory, guided by data sheets, pinouts, and breadboard wiring.

Build a one-bit adder as the arithmetic logic unit, showing left bit and right bit of the result, a truth table, and an and gate circuit to perform addition.

Explore how to realize an xor gate with transistors by analyzing a four-state truth table and transistor paths (M1–M4) to control the output.

Learn to create a 1-bit adder using transistors, and view it through both transistor-level and logic-gate representations. Validate the left and right bits in binary addition.

Explore a one-bit adder built from transistors and logic gates, analyze carry in and carry out at the transistor level, and extend to an eight-bit adder across stages.

Build an eight-bit adder from single-bit adders, explore carry in/out and scaling, and introduce the arithmetic and logical unit abstraction for addition and subtraction.

Use the same adder hardware to perform subtraction by encoding minus b via two's complement (bitwise not plus one) and using a carry-in to switch between add and subtract.

Designs an eight-bit controlled not gate using transistors, applying a single control bit to switch each bit between B and not B on the output.

Build an eight-bit alu from transistors, using an opcode to switch between add and subtract and produce a carry-aware output. Compare this transistor-level design to the 8085 eight-bit microprocessor architecture.

Hook RAM memory cells to the CPU via an address bus and decoders, using a bus and an eight-to-one multiplexer to transfer data to registers.

Learn how a 15-led monitor driven by ram, rom, and an out register displays hexadecimal and decimal values using a simple text-based graphics card and three by five pixels.

Demonstrate manually executing a simple addition with registers, a bus, memory, and a multiplexer to show instruction flow and motivate an automated control unit.

The lecture explains how a CPU speeds up via a fetch, decode, and execute loop using the program counter, instruction register, and a clock to form an eight-step instruction cycle.

Explore how a simple CPU control unit fetches, decodes, and executes instructions, using the program counter and registers to fetch from memory, and how interrupts alter control flow.

The control unit part 2 shows how high address bits and counter outputs drive RAM through a multiplexer, set the control pins, and update the program counter to execute instructions.

Demonstrates how a simple control unit uses ROM, registers, and a carry/flag mechanism to implement if statements and conditional execution, including printing from the out register.

Explain fetch for all instructions by copying the PC into the instruction register, reading the next RAM word, and incrementing the PC using micro instructions and RAM control signals.

Implement the fetch stage by routing the selected memory data to the instruction register, enabling it, and incrementing the program counter to move to the next instruction.

Build a Logisim computer by wiring RAM, registers, a data and address bus, and an ALU with decoders and a control unit to perform addition and subtraction.

Outline an instruction set architecture for binary instructions addressing RAM, with 16 operations (14 implemented, 2 reserved). Group into data transfer, data manipulation, and program control, starting with nop.

Explains implementing nop and lda in the control unit, covering opcode handling, fetch and execute cycles, and memory transfers via registers, the bus, and the counter.

Implement data transfer instructions in the control unit, loading immediate values into the A register and moving A to B or C, with Haig's representation and bus control explained.

Store keyboard data into a memory cell using opcode 1001, selecting the address with the I register and transferring through the MR register before writing on the bus.

Discover how to perform addition and subtraction in a transistor-based computer by using registers A, B, and C, calculating A+B in C, and leveraging the carry flag for jumps.

Explore program flow control with unconditional jump and jump if carry, detailing opcode encoding, PC manipulation, and two jump methods: direct jump and jump adr from memory.

Encode the isa in the control unit rom. Fill retrieved data into memory addresses and connect register inputs; test the 15 instructions across program control, data manipulation, and data transfer.

Test our computer by loading a program into memory, verify correct instruction execution with proper bit wiring, and explore immediate versus direct addressing while comparing von Neumann and Harvard approaches.

Build a toy computer from transistors and logic gates, writing a high level program using loops and if-else to generate opcodes like LDA, ADD, and JUMP.

Showcases loading instructions and data into memory, executing a program on a transistor-based computer with a loop and if-else using registers, memory addresses, and a program counter, plus clock timing.

Understand how assemblers translate assembly language to machine code and compilers translate high-level languages to assembly, balancing control, speed, and programmer ease.

Build a transistor-level computer using nine-gate blocks to form eight eight-bit registers, a memory address register, an alu, ram, and a data bus controlled by eight-to-one multiplexers.

Explore building and simulating digital circuits in logisim, including wiring gates, creating multi-inputs, using subcircuits, panels, clocks, and memory concepts to assemble a computer from transistors and logic gates.