6502

148 Articles

Take A Little Bit Of Acorn To Work

March 28, 2025 by 5 Comments

When we think of 8-bit computers, it’s natural to start with home computers. That’s where they live on in the collective memory. But a Z80, a 6502, or similar was more likely to be found unseen in a piece of industrial machinery, doing the job for which we’d today reach for a microcontroller. Sometimes these two worlds intersected, and thus we come to the EuroBEEB, a derivative of Acorn’s BBC Micro on a Eurocard. [Steve Crozier] has performed extensive research into this system and even produced a recreated PCB, providing a fascinating window into embedded computing in the early 1980s.

The EuroBEEB was the work of Control Universal, a Cambridge-based company specialising in embedded computers. They produced systems based upon 6502 and 6809 processors, and joining their product line to the then-burgeoning BBC Micro ecosystem would have been an obvious step. The machine itself is a Eurocard with a simple 6502 system shipped with ACORN BBC Basic on ROM, and could be seen as a cut-down BBC Micro with plenty of digital I/O, accesible through a serial port. It didn’t stop there though, as not only could it export its graphics to a “real” BBC Micro, it had a range of expansion Eurocards that could carry the missing hardware such as analogue input, Teletext, or high-res graphics.

The reverse-engineered PCB comes from analysis of surviving schematics, and included a couple of gate array logic chips to replace address decoding ROMs in the original. If it seems overkill for anyone used to a modern microcontroller, it’s worth remembering that by the standards of the time this was a pretty simple system. Meanwhile if you only fancy trying BBC BASIC, there’s no need to find original hardware.

A 6502, In The Shell

March 17, 2025 by 8 Comments

Shell scripting is an often forgotten programming environment, relegated to simple automation tasks and little else. In fact, it’s possible to achieve much more complex tasks in the shell. As an example, here’s [calebccf] with an emulated 6502 system in a busybox ash shell script.

What’s in the emulator? A simple 6502 system with RAM, ROM, and an emulated serial port on STDIO. It comes with the wozmon Apple 1 monitor and BASIC, making for a very mid-1970s experience. There’s even a built-in monitor and debugger, which from our memories of debugging hand-assembled 8-bit code back in the day, should be extremely useful.

Although the default machine has a generous 32k of RAM and 16k ROM, you can easily adjust these limits by editing machine.sh. In addition, you can get a log of execution via a socket if you like. Don’t expect it to run too fast, and we did have to adjust the #! line to get it to run on our system (we pointed it to bash, but your results may vary).

What you use this for is up to you, but we’re sure you’ll all agree it’s an impressive feat in the shell. It’s not the first time we’ve seen some impressive feats there, though. Our Linux Fu column does a lot with the shell if you want further inspiration.

Retrotechtacular: Point-of-Sale Through The Years

February 8, 2025 by 12 Comments

In days gone by, a common retail hack used by some of the less honorable of our peers was the price tag switcheroo. You’d find some item that you wanted from a store but couldn’t afford, search around a bit for another item with a more reasonable price, and carefully swap the little paper price tags. As long as you didn’t get greedy or have the bad luck of getting a cashier who knew the correct prices, you could get away with it — at least up until the storekeeper wised up and switched to anti-tamper price tags.

For better or for worse, those days are over. The retail point-of-sale (POS) experience has changed dramatically since the time when cashiers punched away at giant cash registers and clerks applied labels to the top of every can of lima beans in a box with a spiffy little gun. The growth and development of POS systems is the subject of [TanRu Nomad]’s expansive video history, and even if you remember the days when a cashier kerchunked your credit card through a machine to take an impression of your card in triplicate, you’ll probably learn something.

Continue reading “Retrotechtacular: Point-of-Sale Through The Years” →

Building A Reproduction Apple I

November 14, 2024 by 3 Comments

If you think of Apple today, you probably think of an iPhone or a Mac. But the original Apple I was a simple PC board and required a little effort to start up a working system. [Artem] has an Apple I reproduction PCB, and decided to build it on camera so we could watch.

For the Apple I, the user supplied a keyboard and some transformers, so [Artem] had to search for suitable components. He wisely checks the PCB to make sure there are no shorts in the traces. From there, you can watch him build the machine, but be warned: even with speed ups and editing, the video is over an hour long.

If you want to jump to the mostly working device, try around the 57-minute mark. The machine has a basic ROM monitor and, of course, needs a monitor. There was a small problem with memory, but he eventually worked it out by inhibiting some extra RAM on the board. Troubleshooting is half of the battle getting something like this.

Want to look inside the clock generator chip? Or skip the PCB and just use an FPGA.

Continue reading “Building A Reproduction Apple I” →

Using AI To Help With Assembly

November 7, 2024 by 30 Comments

Although generative AI and large language models have been pushed as direct replacements for certain kinds of workers, plenty of businesses actually doing this have found that using this new technology can cause more problems than it solves when it is given free reign over tasks. While this might not be true indefinitely, the real use case for these tools right now is as a kind of assistant to certain kinds of work. For this they can be incredibly powerful as [Ricardo] demonstrates here, using Amazon Q to help with game development on the Commodore 64.

The first step here was to generate code that would show a sprite moving across the screen. The AI first generated code in all caps, as was the style at the time of the C64, but in [Ricardo]’s development environment this caused some major problems, so the code was converted to lowercase. A more impressive conversion was done in the next steps, as the program needed to take advantage of the optimizations found in the Assembly language. With the code converted to 6502 Assembly that can run on the virtual Commodore, [Ricardo] was eventually able to show four sprites moving across the screen after several iterations with the AI, as well as change the style of the sprites to arbitrary designs.

Although the post is a bit over-optimistic on Amazon Q as a tool specifically for developers, it might have some benefits over other generative AIs especially if it’s capable at the chore of programming in Assembly language. We’d love to hear anyone with real-world experience with this and whether it is truly worth the extra cost over something like Copilot or GPT 4. For any of these generative AI models, though, it’s probably worth trying them out while they’re in their early stages. Keep in mind that there’s a lot more than programming that can be done with some of them as well.

2024 Tiny Games Contest: A Flappy Seagull Game With Sound In Only 500 Bytes

September 12, 2024 by 4 Comments

It was probably a reasonable assumption that the “Tiny” in our recently concluded Tiny Games Contest mostly referred to the physical footprint of the game. And indeed, that’s the way most of the entries broke, which resulted in some pretty amazing efforts. [Anders Nielsen], however, took the challenge another way and managed to stuff a seagull-centric side-scroller into just 500 bytes of code.

That’s not to say that the size of [Anders]’s game is physically huge either. Flappy Larus, as he calls his game, runs on his popular 65uino platform, a 6502 microcontroller in the familiar Arduino Uno form factor. So it’s pretty small to begin with, and doesn’t even need any additional components other than the tiny OLED screen which has become more or less standard for the 65uino at this point. The only real add-on is a piezo speaker module, which when hooked up to the I2C data line happens to make reasonable approximations of a squawking seagull, all without adding a single byte of code. Check out a little game play in the video below.

Flappy Larus may be pretty simplistic, but as we recall, the game it’s based on was similarly minimalist and still managed to get people hooked. The 2024 Tiny Games contest is closed now, but if you’ve got an idea for a tiny game, we’d still love to feature it. Hit the tip line and we’ll take a look! Continue reading “2024 Tiny Games Contest: A Flappy Seagull Game With Sound In Only 500 Bytes” →

Single-Stepping The 6502 Processor

July 18, 2024 by 19 Comments

Although marketing folk and laypeople may credit [Steve Jobs] as the man behind the success of Apple, those in the tech world know the real truth that without [Steve Wozniak] nothing would have ever gotten off the ground during the early days of the computer company. As an exhibit of his deep knowledge of the machines he was building, take a look at this recreation of a circuit by [Anders] which allows the 6502 processor to step through instructions one at a time, originally designed by [Woz] himself, even though there are still myths floating around the Internet that this type of circuit can’t work.

Like a lot of Internet myths, though, there’s a kernel of truth at the middle. The original 6502 from the mid-70s had dynamic registers, meaning they would lose their values if the chip was run below a critical clock speed. Since single-stepping the processor is much lower than this speed, it seems logical that this might corrupt the data in the registers. But if the clock is maintained to the registers the processor can be halted after each instruction, allowing even the original 6502 to go through its instructions one at a time.

[Anders]’s project sets up this circuit originally laid out by [Steve Wozniak] but updates it a bit for the modern times. Since the technology of the era would have been TTL, modern CMOS logic requires pull-up resistors to keep any inputs from floating. The key design of the original circuit is a set of flip-flops which latch the information on the data bus, and a switch that can be pressed to let the processor grab its next instruction, as well as a set of LEDs that allow the user to see the value on the data bus directly.

Of course, a computer processor of this era would be at a major handicap without a way to debug code that it was running, so there are even dedicated pins that allow this functionality to occur. Perhaps the Internet myth is a bit overblown for that reason alone, but [Anders] is no stranger to the 6502 and has developed many other projects that demonstrate his mastery of the platform.

Continue reading “Single-Stepping The 6502 Processor” →