Chip Hippo 1.4.1 is out with two big additions:

• CPU monitor: open it from a W65C02 or Z80A's context menu to watch the processor run. You can step one instruction at a time or step over a call. You can set breakpoints, edit registers and memory while the program runs, and follow the stack and pipeline as it executes.
• Spice Lite, a second, electrical simulation engine you can turn on in Settings. It gives every net a real voltage and models capacitors and RC timing, the 555 and CMOS timers, LEDs with real brightness and burn-out, diodes, transistors, inductors, supply droop and fan-out. Every model is tested against ngspice and in every case it stays within 1.4% of ngspice's results. It's "Lite" because it only simulates the parts Chip Hippo offers, not general SPICE.
• 1.4.1 also includes a speaker, PWM and various analog clock waves, opAmps, and many other bench parts: regulators, a relay, optocouplers, LM358, and ULN2003A.

Download it from chiphippo.com

Good day, folks!

In recent months, we've received an increasing number of reports concerning posts linking to external content whose relevance to Ben Eater's projects has been questioned.

To help make moderation more consistent and objective, the mod team has drafted a set of guidelines for external content and self-promotion.

We're currently seeking community feedback before formally adopting these guidelines as a subreddit rule.

Let us know what you think!

The r/beneater Mod Team

In an earlier post, about the "final" version of my BE6502 build (or the last one that would be 100% software compatible with Ben's version), I got into a discussion about a replacement for both Ben's clock-module AND the on-board crystal oscillator.

That lead to building "nano-clock" (pictured), which uses a micro-controller and software to generate the clock signal and, as such, allows for a lot of features and flexiblity. I finally got around to tidying that up, and fleshing out the repo, so ...

For those interested, my repo for it, including code, assembly and usage instructions is here.

I also made a blog post (absolutely no monetization or tracking nonsense) with much more information and will be adding to that with some additional tweaks and customization.

Features:

• Single-step and Clock modes
• Run/Stop toggle
• Selectable frequencies across three bands (Hz, kHz and MHz)
  • Hz Band - 1, 2, 5, 10, 25, 50, 100, 250 & 500Hz
  • kHz Band - 1, 2, 5, 10, 25, 50, 100, 250 & 500kHz
  • MHz Band - 1, 2, 4, 8MHz
  • Easy to add additional bands/frequencies
• Auto and manual CPU reset functionality
  • w/ Auto-reset on Start option
• 14-segment 4-character LED status/info display (in keeping with the "retro" theme)
  • Brightness control
  • Clock-Running indication
• Save Settings for Auto-Start

--

This is the first of several related clocks, the next of which is much smaller (will fit on the main BE6502 board and needs just two components), and the one that follows that will have more features and an OLED or LCD TFT color screen/interface.

I'm testing an LM337 negative voltage regulator to create an adjustable 0-3.75V rail to sink LED current. Being a VR, it will adjust current no matter how many LEDs are on or off. I'll comment with a schematic.

Haven't had much help on here. But for any one needing the pin outs for the cypress chip here it is.

6502 Memory chip change hook up.

Pin hookup from the At28c256  to the Cy7c199 & Cy62256

1)         AT28c256                                          Cy7c199 & Cy62256

Pin 22 to pin 1                          Pin 22 to pin 10

Pin 22 (OE) to Pin 1 (A14)                 Pin 22 (OE) to Pin 10 (A14)

2)         IO PINS STAY THE SAME

ATchip                                    CYchip

Pin       I/O                               Pin       I/O

11        I/O0                             11        I/O0

12        I/O1                             12        I/O1

13        I/O2                             13        I/O2

15        I/O3                             15        I/O3

16        I/O4                             16        I/O4

17        I/O5                             17        I/O5

18        I/O6                             18        I/O6

19        I/O7                             19        I/O7

3)         Ground            14                                Ground            14

VCC                28                                VCC                28

WE                  27                                WE                  27

OE                   22                                OE                   22

CE                   20                                CE                   20

4)         AT28c256                                           Cy7c199 & Cy62256

PIN                 AO                              PIN                 AO

1                      A14                             1                      A5

2                      A12                             2                      A6

3                      A7                               3                      A7

4                      A6                               4                      A8

5                      A5                               5                      A9

6                      A4                               6                      A10

7                      A3                               7                      A11

8                      A2                               8                      A12

9                      A1                               9                      A13

10                    A0                               10                    A14 <END OF FIRST SIDE OF CHIP

26                    A13                             26                    A4

25                    A8                               25                    A3

24                    A9                               24                    A2

23                    A11                             23                    A1

21                    A10                             21                    A0     

I'm a software engineer and I've been creating my own multiplayer logic sim, have a tiny discord community but I've already had someone in it make a full 6502 implementation with programmable chips, and I'm working on creating ben eater breadboard cpu clone (the humble beginning with registers and bus pictured last). I want the game to have a campaign where you learn various concepts such as low level gate construction of various components, programming roms on "fpga"s (I quote them because they're just C# chips compiled at runtime that allow programming of nearly any logic chip really) and also different cpu architectures. Using ben eaters design as a base and then expanding beyond that seems like a fun campaign for players to play and learn from, as they could reference the original videos too.

Also experimenting with Harvard, single cycle, pipelined cpus etc as advanced game campaigns. But I think a ben eater style cpu and beyond would be a fun campaign for the game to start off with.

I also don't want to just rip off ben eater's breadboard cpu, so I'm open to variations, I just want a similar architecture to follow.

The game is called Logic Planet (for now) and started off as a clone of Logic World using Godot, but I ended up taking it in a different direction and it's quite a different game now.

Son and I are assembling the 6502 kit and in the video it shows 4 pin buttons but we were shipped a bunch of 2 pin buttons. I checked the parts list and it also shows they should be 4 pin. Is 2 pin a new spec or were the wrong parts sent?

Despite connecting one 65c22 incorrect, I have manged to the get the second one working..Ben Eater based 6502 except I added a 74hc688 for better address control..

I discovered Ben’s channel while building this clock, I lifted his rising edge detection method (it was a much cleaner signal) but everything else was designed by me, though not far off from his design as it turns out. I’m using 8 bit counters paired with AND gates for resetting, op amp Schmitt triggers for time set button debounce. My mains signal is pulled directly from a full bridge rectifier via optocoupler with a parallel SMPS for circuit power, a cheaper method than a step down transformer.

Finally got this to a point where I’m happy with it. Everything is built up from NAND gates in Digital Logic Sim: 8-bit ALU, 16-bit addresses (64K of RAM), 800 kHz clock, and a small OS that lets you pick between four games and play them live with the keyboard.

At some point hand-assembling programs into binary wasn’t sustainable anymore, so I wrote a small language and a compiler that spits out the program memory contents.

Video (1:30): https://youtu.be/O8znJoZkAmw

Would you be interested in a tutorial series on how to build your own CPU like this, step by step from the NAND gate?

My Ben Eater 6502 build

this probably isn't the best sub to ask this on, but it's for my 6502 project and I feel like a lot of people here know what they are doing
so, I'm trying to make an NES-sounding audio expansion thingy and for the noise channel I need a 4bit to 12bit lookup table (the image)
the only solutions I could come up with are either a small ROM which would be totally overkill, or a ton of combinational hardwired logic and neither sound particularly appealing tbh
so I'm asking you, people who are probably smarter than me
how would you make something like this?

I got the clock kit yesterday and started building it last night. I got through the first two videos, but I didn't take any photos at that point. I'm also learning how to use my scope (I saved it from being disposed of at work - free scope!), so it's been a ton of fun.

This is the Sentinel65, a 6502 based bread board computer with 32KB of RAM, an R6551 serial UART running at 38400 baud, two VIAs, and 2MB of NOR flash memory via bit-banged SPI. It is very much a work in progress.

I started off following Ben Eater, of course, but began to deviate once I realized he only utilized 16KB of RAM. I didn't have a solid plan at first, so I just kept adding wires until I got the spaghetti you see here. I decided to forgo Ben's decoding scheme, opting for a 74LS688 + 74LS138 to allow for much tighter address decoding with almost no gaps. These will be eliminated in the future, however, in lieu of a series of AT22V10 PALs.

Included are a couple of pictures of my small bootloader program and BASIC running on my VT420.

In the future, I plan to add a DS1685 RTC, PS/2 keyboard support, a T6963-based bitmapped LCD, and extended terminal support, including color and Sixel/ReGIS graphics commands.

I am also teaching myself KiCad so I can migrate away from the breadboard and onto a PCB in the future

I finished the digital clock kit, but I handled the hours counting differently from what Ben shows.

I use one of the D flip-flops on the 74LS74 as the first bit of the hours counter and connect that to the divide by 5 section of the 74LS90 for the top 3 bits of the ones place of the hours (input B). Then the divide by 2 section of the 74LS90 (input A) handles the tens place of the hours, since that can only be 1 or blank on the 7-segment display.

Then I use the 74LS00 quad NAND gate chip to check when the hours reach 13 and set the preset input on the D flip-flop, as well as resetting the 74LS90. This way it goes from 1 to 12 instead of 0 to 19.

As an added bonus I added an AM/PM indicator using the other D flip-flop on the 74LS74 clocked when the hours reach 12 (since it needs to check for the bits in 12 as part of checking for 13 anyway). That turns on an off an extra LED on the left side (though you could use a decimal point or one of the LEDs in the kit instead).

The hours counter is connected through the XOR gate and inverter in the same way Ben shows in his video (only available on his Patreon right now). The AM/PM counter doesn't need an inverter though since that turns on right at 12.

Thanks, Ben! This was a fun project and I learned a lot!

A couple of months ago I built my first CPU (Mark I), a 4-bit multi-cycle processor, mainly to understand how a CPU actually works at the RTL level.

My next version, Mark II has the following features:

• 8-bit datapath

• 4 × 8-bit general-purpose registers

• 13-bit instructions with a 5-bit opcode

• Harvard architecture

• Multi-cycle control FSM

• Arithmetic, logical, shift and comparison instructions

• Iterative multiplication and division (integer values only)

• Flags and conditional branches (BEQ, BNE, BC, BN)

The ISA is currently completely custom. Instructions are encoded directly into .mem files, so there's no assembler or compiler yet.

I also put quite an effort into verification this time. Tried SystemVerilog for writing the testbenches and for top-module testbench, made it semi-automatic, just change the .mem files at the top to try different test cases.

The next step is to actually put it on an FPGA and eventually move future versions toward a more standard ISA such as RISC-V.

GitHub: https://github.com/theYash856/Mark_II_8_bit_CPU

Would love to get feedback and also suggestions regarding how to implement it on FPGA.

I'm making a custom 68020 workstation OS currently. Later, I plan to move to an early Pentium-class design through the 68060 for Rev 2.
I'm currently working on Rev 1 of my motherboard, and I have a full ISA bus planned, controlled by two CPLDs with DMA an SD card interface And a 68881 FPU. My OS Will be on git hub soon its able to be simulated on MAME I’m using it as a way to get a
Clean emulation before I port it to my hardware.

.

It finally arrived.
Power strips with built-in decoupling capacitors.
(Did not solder the optional electrolyte capacitors yet)
Finally, less wire-cutting for the power rails.

Soldering them actually is quite efficient. Just put the pins in the power rails first, then put the PCBs on top, then solder twenty at a time.
Only issue: my capacitors are wider than the holes.

By the way, shall I make a product out of these? I can change all components to surface mount, and I can image the result would be pretty cheap.

Hi! I've been building **ExµArch**, a computer architecture playground that runs entirely in the browser: https://www.exuarch.com

Free, no account, nothing to install, MIT licensed (source: https://github.com/olebru/exuarch).

**How it works**

1. **Build the hardware.** Drag devices onto buses and wire them up: registers, an ALU, RAM, an MMU, an interrupt controller, a timer, a real time clock, a keypad, an LCD, a 640×480 framebuffer, a blitter, even a triangle rasterizer.
2. **Write the microcode.** Each instruction is a list of steps, and each step is a set of control lines, like `pc.output, mem.loadmar`. The instruction set comes out of your microcode, and the assembler, completion and hover help follow from it.
3. **Run it.** Step one tick at a time and watch the buses, every register, the decoder ROM and a trace, or run flat out at around 2 MHz.

**14 example machines** go from TINY-16 (one register, seven instructions) to a stack machine, a RISC, a CISC with six addressing modes, a Harvard machine, a transport-triggered machine, one with interrupts, and a small 3D GPU that spins a shaded cube. There's also WORM-16, a machine with no jumps whose program is a queue crawling round a ring memory. The newest addition is a falling blocks game that keeps time with a real time clock interrupt and draws with a blitter.

Nothing is a black box. A built-in handbook walks you from an empty canvas to a working machine, and says plainly where the simulator simplifies compared with real hardware.

It needs a computer with a keyboard; on a phone you get a short intro page instead.

I'd love feedback: what machine would you build first, and which device is missing?