Tiny Operating System For Tiny Computer

June 28, 2021 by 12 Comments

Before the World Wide Web became ubiquitous as the de facto way to access electronic information, there were many other ways of retrieving information online. One of the most successful of these was Minitel, a French videotex service that lasted from 1980 all the way until 2012. But just because the service has been deactivated doesn’t mean its hardware can’t be used for modern builds like this Arduino-based operating system. (Google Translate from French)

Called ZARDOS, the operating system is built to run on an Arduino MEGA although a smaller version is available for the Uno. The Arduino is connected by a serial cable to the Minitel terminal. It can take input from a keyboard and PS/2 mouse and displays video on the terminal screen with the same cable. There is functionality built-in for accessing data on a cartridge system based on SD cards which greatly expands the limited capabilities of the Atmel chip as well, and there is also support for a speaker and a Videotex printer.

Even though the build uses a modern microcontroller, it gives us flashbacks to pre-WWW days with its retro terminal. All of the code is available on the project site for anyone looking to build an Arduino-based operating system, although it will take a little bit of hardware hacking to build a Minitel terminal like this. Either way, it’s a great way to revive some antique French hardware similar to a build we’ve seen which converts one into a Linux terminal.

Thanks to [troisieme_type] for the tip!

Send Old-Fashioned Pager Messages With New-Fashioned Hardware

May 18, 2021 by 5 Comments

In a world of always-connected devices and 24/7 access to email and various social media and messaging platforms, it’s sometimes a good idea to take a step away from the hustle and bustle for peace of mind. But not too big of a step. After all, we sometimes need some limited contact with other humans, so that’s what [EverestX] set out to do with his modern, pocket-sized communication device based on pager technology from days of yore.

The device uses the POCSAG communications protocol, a current standard for pager communications that allows for an SMS-like experience for those still who still need (or want) to use pagers. [EverestX] was able to adapt some preexisting code and port it to an Atmel 32u4 microcontroller. With a custom PCB, small battery, an antenna, and some incredibly refined soldering skills, he was able to put together this build with an incredibly small footprint, slightly larger than a bottle cap.

Once added to a custom case, [EverestX] has an excellent platform for sending pager messages to all of his friends and can avoid any dreaded voice conversations. Pager hacks have been a favorite around these parts for years, and are still a viable option for modern communications needs despite also being a nostalgic relic of decades past. As an added bonus, the 32u4 microcontroller has some interesting non-pager features that you might want to check out as well.

Thanks to [ch0l0man] for the tip!

TrueTape64 Is A PC Interface For Your C64 Datasette

May 10, 2021 by 32 Comments

Back in the distant past of the 1980s, software was distributed on audio tape. Ones and zeroes were encoded as tones of different frequencies, and tapes were decoded by specialised hardware which could then spit out raw digital data to an attached computer. While software methods now exist to simply record audio from old tapes and turn them into data, [Francesco] wanted to do it the hardware way, and built a PC interface for his Commodore 64 Datasette.

The TrueTape64, as it has been named, is built around an Atmel ATTiny2313 microcontroller. This interfaces with the original Datasette hardware which takes care of reading the analog tape output and turning it into digital data. From there, the microcontroller communicates with an FTDI232 serial-to-USB adapter to get the data into a modern PC, where it’s compiled into a TAP image file via some Python magic.

It’s a barebones build, which goes so far as to run the Datasette’s motor off the USB power supply via a boost converter; those facing issues with the tape mechanism might do well to look there first. However, it does work, and a done job is a good job at the end of the day. We’ve seen similar hacks before, too – it’s great to see the community keeping cassette software alive!

Looks Like A Pi Zero, Is Actually An ESP32 Development Board

April 30, 2021 by 34 Comments
ATMegaZero ESP32- S2, showing optional color-coded 40-pin header (top)

The ATMegaZero ESP32-S2 is currently being funded with a campaign on GroupGets, and it’s a microcontroller board modeled after the Raspberry Pi Zero’s form factor. That means instead of the embedded Linux system most of us know and love, it’s an ESP32-based development board with the same shape and 40-pin GPIO header as the Pi Zero. As a bonus, it has some neat features like a connector for inexpensive SSD1306 and SH1106-based OLED displays.

Being able to use existing accessories can go a long way towards easing a project’s creation, and leveraging that is one of the reasons for sharing the Pi Zero form factor. Ease of use is also one of the goals, so the boards will ship with CircuitPython (derived from MicroPython), and can also be used with the Arduino IDE.

If a microcontroller board using the Pi Zero form factor looks a bit familiar, you might be remembering the original ATMegaZero which was based on the Atmel ATMega32U4, but to get wireless communications one needed to attach a separate ESP8266 module. This newer board keeps the ATMegaZero name and footprint, but now uses the Espressif ESP32-S2 to provide all the necessary functions.

CircuitPython has been a feature in a wide variety of projects and hacks we’ve seen here at Hackaday, and it’s a fine way to make a microcontroller board easy to use right out of the box.

Programming PALs In 2021

April 15, 2021 by 35 Comments

The [IMSAI Guy] has posted a follow-up video with all the details of how he programs GAL22V10 chips in the modern era. We noted that this was missing from his stepper motor project a few days ago, and before we could even ask him, he answered. And no, you won’t have to dig that old Intel 486 DX2-66 out of the closet and search eBay for working floppy drives. It turns out the answer is easier than you’d think.

Microchip now owns WinCUPL through its acquisition of Atmel in 2016, and offers WinCUPL as a free download from the Microchip website. This runs only in Windows, although some users report success running under Wine on Linux. This tool will compile the design, but you still need to program the chip. If you’ve done any EEPROM programming lately, chances are you have one of the TL866A MiniPros laying around — this programmer can handle CPLDs, PALs, and GALS as well as EEPROMS. [IMSAI Guy] walks you through the programming procedure, and if you’ve programmed EEPROMs before, the process will be familiar.

For those who prefer the Linux or Mac environment, there are some alternatives. We’ve seen GALasm used on several projects such as [Ken Yap]’s 8085 Minimax. The GitHub repository for GALasm states that commercial use is strictly prohibited, so take note if this applies to your project. As for controlling the TL866A, there is a Linux port called minipro available on GitLab. The remaining hurdle if you want to experiment with these programmable logic chips it to actually get them — many are now obsolete. But it looks like you can still buy Lattice and Microchip (Atmel) ones from various sources. Happy Programming.

Continue reading “Programming PALs In 2021” →

Free RTOS

Real-Time OS Basics: Picking The Right RTOS When You Need One

February 24, 2021 by 60 Comments

When do you need to use a real-time operating system (RTOS) for an embedded project? What does it bring to the table, and what are the costs? Fortunately there are strict technical definitions, which can also help one figure out whether an RTOS is the right choice for a project.

The “real-time” part of the name namely covers the basic premise of an RTOS: the guarantee that certain types of operations will complete within a predefined, deterministic time span. Within “real time” we find distinct categories: hard, firm, and soft real-time, with increasingly less severe penalties for missing the deadline. As an example of a hard real-time scenario, imagine a system where the embedded controller has to respond to incoming sensor data within a specific timespan. If the consequence of missing such a deadline will break downstream components of the system, figuratively or literally, the deadline is hard.

In comparison soft real-time would be the kind of operation where it would be great if the controller responded within this timespan, but if it takes a bit longer, it would be totally fine, too. Some operating systems are capable of hard real-time, whereas others are not. This is mostly a factor of their fundamental design, especially the scheduler.

In this article we’ll take a look at a variety of operating systems, to see where they fit into these definitions, and when you’d want to use them in a project. Continue reading “Real-Time OS Basics: Picking The Right RTOS When You Need One” →

Make Room For A New Arduino Competitor – With Native Brainf*ck!

January 12, 2021 by 70 Comments

With so many smaller and more capable microcontroller boards on the market it’s now fairly safe to say that the classic Arduino footprint and form factor is rather outdated. That’s not to say that there’s no fight left in the old contender though, and to prove it here’s a new platform in the familiar style set by the venerable Atmel-based board. [Eduardo Corpeño]’s Brainfuino is an Arduino competitor that runs everyone’s favourite esoteric programming language, Brainf*ck. (Keeping it SFW, folks.)

And in case you mistake it for a Brainf*ck emulator on a PCB then stand ready to be corrected, for this board runs the language natively in a Brainf*ck softcore on a Lattice MachXO2 FPGA. This is the real deal, on which only a true genius or masochist would dare to code.

The board itself is very neatly executed with a graphical style that presents more than a nod to the original Arduino. On this board is the FPGA, 256 kB ROM and 138 kB RAM, an STM32 to provide a USB serial port and an analogue input, and a level shifter to provide Arduino-style 5 V logic on the pins. We can see it’ll provide hours of fun to anyone interested in learning Brainf*ck, but besides that it has potential as an Arduino-shaped FPGA board. We like the joke, we like the graphical and engineering design, but underneath that lies quite the technical achievement.

Brainf*ck has made it to Hackaday before, not least in this jaw-dropping relay computer.