In this video I pull out the fetch unit, so we now have something resembling a classic pipeline, though the processor is not yet pipelined. It's also a big clean up / refactoring episode so I mostly just sped through it. I realized in editing perhaps a bit more explanation would have been helpful. Maybe I will make episode 10 a walkthrough episode to fill in any gaps.

So yeah, here's [008] Fetch & Clean Up!: https://youtu.be/8tC27yB67Wk

edit: As an aside, this is the first episode properly implementing the auto-editing. I think I have most of the kinks worked out, but there's still a couple left. If folks are interested I can post a description of my workflow and some of the settings I use in OBS and auto-editor.

(sorry I haven't really had a chance to have a good look at your videos recently.)

That's okay BigEd, I can see there's still some people watching these so I will keep posting them.

Here is the next video where I add the ability to add two registers together with the goal of completing the first milestone: running a Fibonacci sequence program.

[009] Fibonacci! https://youtu.be/oUsSsA2-8T8

The next video will be the walkthrough / review / catch up video. I am also thinking I might try recording an episode 1.5 where I go into more basics and show how to use the program more. Despite asking people to watch the intro videos linked in the description, most people don't, and I lose them in episode 2. I mean I am not expecting crazy viewership on these videos, but I also want to be helpful. They're interested enough to start watching the second episode, so.... I would like to help them get further into the series if I can.

If you happen to have some ideas on what I could cover in an episode 1.5 I would be very interested.

So here's the sync-up episode to hopefully fill in any gaps. I suppose it could be used as a summary too. It's a bit shorter because I cut out a pretty long rant/tangent at the end. But I talk about my development strategy and do a walk-through of what has been built so far.

[010] Sync-Up / Walk-Through https://youtu.be/7m7gBFkVm8U

Next episode is up, implementing the move instruction. There's some background noise in this one which isn't great. Really debating getting a better mic, but well... I am not entirely sure how much that will help.

[011] Move! https://youtu.be/rbOpUv4IdBQ

BTW I have some fun episodes coming up I just need to edit

This is a short video where I just change the bit-widths of most of the components so we now have a 32-bit processor with 16-bit instructions.

This isn't the fun episodes just yet. Hopefully I will get time to edit those and put them up soon. Work has been crazy, pretty much no hobby time this week, and likely not next week either.

[012] 32-bits! https://youtu.be/x8m37QaytCU

Here's the start of the fun videos. In this I build an ASCII display for the name of the currently executing instruction:

[013] Instruction Blinkenlights! https://youtu.be/Ouk9r-wIQ14

So far this weekend I have been hung up trying to convert binary to BCD in logic. My goodness is it ever a lot of logic to do that. I opened a ticket on Digital to see if a less heavy solution could be made.

But anyway, I had no idea how expensive it was to do such a simple thing in a circuit. The algorithm by the way is the Double Dabble Algorithm. It's actually a lot less expensive to just do math in BCD and not convert from binary to BCD, which is probably why old processors have BCD math instructions / modes.

More blinkenlight building, this time with the registers and their contents.

[014] Register Blinkenlights! https://youtu.be/SWK62ufW_iY

One more video coming up on this topic, and then I am on to other things.

I think what I want to do after this is figure out how to add a "test suite" where I can program in a number of programs that test various instructions and can emit a failure or success. Thoughts? I suppose I could also get into building a proper assembler?

Blinkenlights always good - and a milestone!

Yes, I would think an assembler, even a rudimentary one, would be pretty useful at this point.

I've seen various approaches to testsuites: py65 has a collection of trivial sequences, klaus' 6502 tests are self-contained and self-checking. Perhaps see
http://visual6502.org/wiki/index.php?ti ... stPrograms

Here's the next video, I finish up the blinkenlight display with some binary to bcd (decimal) conversion.

[015] Decimal Blinkenlights! https://youtu.be/ifZsbNm-qg8

Next up is the assembler video, and then I try to build a test runner which is going to take a while, it's more complicated than I thought

Finally a new video. Work has been crazy!

This is the assembler video I promised. I also got a new microphone! Let me know what you think!

[016] A Proper Assembler! https://youtu.be/i2WE-NaqHvU

I had a false start with the last few videos and I decided to re-record them. But I am regaining some hobby time that work was eating so, hopefully I will get more videos soon.

Nice - customasm looks handy, for builders of homebrew CPUs.

The next video on automated testing is up.

This was the third attempt at recording this -- the first attempt took something like 4 episodes and it turned out so complicated that I couldn't figure out how to get it to work. The second was similar but I did manage to get it working. I am not sure why I though that the second attempt would be any simpler... it wasn't.

I was trying to build a custom circuit to run the test cases, and I had kind of dismissed the built-in testing functionality Digital has, but that was silly and when I really dug in and investigated that functionality I figured out how to adapt it to what I wanted to do. In the end, it all fit into one video and I think it's more powerful than the circuit version.

[017] Automated Testing! https://youtu.be/8ImcOexoXvE

So, with automated testing in place, I think it's time to move on to some serious features that really require that automated testing. But I am not really sure what to tackle next.

When do you think I should pipeline this processor? Should I do that now while it's still fairly simple? Or should I implement conditional branches and memory access before I tackle pipelining it? What do you think?

Keep in mind I would like my videos to be understandable, so that's one reason to delay pipelining it -- adding major features will be a lot more complex once it's pipelined. On the other hand, making the processor pipelined will be a lot more complex with those features and it will be hard to do it incrementally -- I would have to have many episodes with a broken processor before I got it working again.

I think it'd be better to build up to a simple but functionally useful micro before pipelining. (For one thing, I suspect the challenges of pipelining become manifest when you have conditional branches.)

Never

People seem thinking that "real men" are only those who do pipeline, cache, and all the modern stuff we have today, and as result we are plenty of super-complex and unfriendly processors that nobody wants to program in assembly.

You asked what I think. I think "must be pipelined to be a good challenge" is rather a modern hype.

For me the "pipeline" is evil, the "cache" is bad, and don't want to deal with that for hobby since I already have to deal with that for a living.

The real challenge for me it's making a CPU and an high level compiler friendly, elegant, useful, well written and documented, and rich of useful features to make the development process comfortable.