LittleFS: The Emphasis Is On Little

October 4, 2023 by 15 Comments

It used to be that developing for microcontrollers was relatively relaxing. These days, even a cheap micro like the Raspberry Pi Pico has multiple cores, networking (for the W, at least), and file systems. Just like desktop computers. Sort of. I found out about the “sort of” part a few weeks ago when I decided to embark on a little historical project. I wanted a file system with a large file that emulates a disk drive. The Pico supports LittleFS, and I figured that would be the easy thing to do. Turns out the Little in LittleFS might be more literal than you think. On the plus side, I did manage to get things working, but it took a… well — dare I say hack? — to make it all work.

History

I’m an unabashed fan of the RCA 1802 CPU, which is, of course, distinctly retro. The problem is, I keep losing my old computers to moves, natural disasters, and whatnot. I’ve had several machines over the years, but they seem to be a favorite target of Murphy’s law for me. I do currently have a small piece of hardware called an Elf Membership Card (by [Lee Hart]), but it lacks fancy features like disk drives, and while it could be expanded, there’s something charming about its current small size. So that led me to repurpose a 6502 emulator for the KIM-1 to act like an 1802 instead. This is even less capable than the membership card, so it was sort of a toy. But I always thought I should upgrade the Arduino inside the emulator to a processor with more memory, and that’s what I did.

I started out with a Blackpill STM32F board and called the project 1802Black. The code is a little messy since it started out as [Oscar’s] KimUNO code, and then my updates layered with new updates. Also, for now, I shut off the hardware parts so it won’t use the KimUNO hardware — you only need a Blackpill (or a Pico, see below) and nothing else, although I may reenable the hardware integration later.

It wasn’t that hard to get it running with just more memory. Still, I wanted to run [Mike Riley’s] Elf/OS operating system and I also had a pair of Raspberry Pi Picos mocking me for not using them in a project yet. The chip has excellent Arduino board support. But what sealed the deal was noticing that you can partition the Pico’s flash drive to use some of it for your program and the rest for a file system. You can get other RP2040 dev boards with 16 MB of flash, which would let me have a nearly 15 MB “hard drive,” which would have been huge in the 1802’s day. Sounds simple. If it were, though, we wouldn’t be talking.

Continue reading “LittleFS: The Emphasis Is On Little” →

Cyanodore 6 Is A Rad Commodore 64 Synthesizer

September 29, 2023 by 3 Comments

The Commodore 64 is celebrated to this day for its capable SID sound chip, which provided the soundtrack for some of the best video games of its era. Even today, it’s still in demand as a chiptune synth. [gavinlyons] decided to take a breadbox-style C64 and mod it to be a more dedicated synth platform, creating what he calls the Cyanodore 6.

The build starts by equipping the C64 with MIDI via a C-LAB interface cartridge. Software is loaded on to the C64 via a readily-available SD2ISEC converter, which lets the retro computer run off SD cards. The original SID was removed and replaced with an ARMSID emulator instead, giving the rig stereo output with some custom wiring. Four potentiometers were also added to control various synth parameters by wiring them into the C64’s two joystick ports. There are a variety of synth programs that can run on the C64, with [gavinlyons] noting CynthCart, STATION64, and MicroRhythm as popular choices. Other nifty mods include the keyboard illumination, tube preamp, and integrated 7″ LCD screen.

If you’re looking to start using your C64 as a performance instrument, this build is an excellent starting point. We’ve seen other neat builds in this area before, too. It’s got just about everything you’ll need on stage. Video after the break.

Continue reading “Cyanodore 6 Is A Rad Commodore 64 Synthesizer” →

This Week In Security: Magic Packets, GPU.zip, And Enter The Sandman

September 29, 2023 by 4 Comments

Leading out the news this week is a report of “BlackTech”, an Advanced Persistent Threat (APT) group that appears to be based out of China, that has been installing malicious firmware on routers around the world. This firmware has been found primarily on Cisco devices, and Cisco has released a statement clarifying their complete innocence and lack of liability in the matter.

It seems that this attack only works on older Cisco routers, and the pattern is to log in with stolen or guessed credentials, revert the firmware to a yet older version, and then replace it with a malicious boot image. But the real fun here is the “magic packets”, a TCP or UDP packet filled with random data that triggers an action, like enabling that SSH backdoor service. That idea sounds remarkable similar to Fwknop, a project I worked on many years ago. It would be sort of surreal to find some of my code show up in an APT.

Don’t Look Now, But Is Your GPU Leaking Pixels

There’s a bit debate on who’s fault this one is, as well as how practical of an attack it is, but the idea is certainly interesting. Compression has some interesting system side effects, and it’s possible for a program with access to some system analytics to work out the state of that compression. The first quirk being leveraged here is that GPU accelerated applications like a web browser use compression to stream the screen view from the CPU to the GPU. But normally, that’s way too many pixels and colors to try to sort out just by watching the CPU and ram power usage.

And that brings us to the second quirk, that in Chrome, one web page can load a second in an iframe, and then render CSS filters on top of the iframe. This filter ability is then used to convert the page to black and white tiles, and then transform the white tiles into a hard-to-compress pattern, while leaving the black ones alone. With that in place, it’s possible for the outer web page to slowly recreate the graphical view of the iframe, leaking information that is displayed on the page.

And this explains why this isn’t the most practical of attacks, as it not only requires opening a malicious page to host the attack, it also makes some very obvious graphical changes to the screen. Not to mention taking at least 30 minutes of data leaking to recreate a username displayed on the Wikipedia page. What it lacks in practicality, this approach makes up for in cleverness and creativity, though. The attack goes by the GPU.zip moniker, and the full PDF is available. Continue reading “This Week In Security: Magic Packets, GPU.zip, And Enter The Sandman” →

Decker Is The Cozy Retro Creative Engine You Didn’t Know You Needed

September 22, 2023 by 9 Comments

[John Earnest]’s passion project Decker is creative software with a classic MacOS look (it’s not limited to running on Macs, however) for easily making and sharing interactive documents with sound, images, hypertext, scripted behavior, and more to allow making just about anything in a WYSIWYG manner.

Decker creates decks, which can be thought of as a stack of digital cards that link to one another. Each card in a deck can contain cozy 1-bit art, sound, interactive elements, scripted behavior, and a surprisingly large amount of other features.

Curious? Check out the Decker guided tour to get a peek at just what Decker is capable of. Then download it and prototype an idea, create a presentation, make a game, or just doodle some 1-bit art with nice tools. Continue reading “Decker Is The Cozy Retro Creative Engine You Didn’t Know You Needed” →

Hackaday Podcast 237: Dancing Raisins, Coding On Apples, And A Salad Spinner Mouse

September 22, 2023 by 7 Comments

This week, Editor-in-Chief Elliot Williams and Kristina Panos gathered over the Internet and a couple cups of coffee to bring you the best hacks of the previous week. Well, the ones we liked best, anyhow.

First up in the news, we’ve got a brand-spankin’ new Halloween Hackfest contest running now until 9AM PDT on October 31st! Arduino are joining the fun this year and are offering some spooky treats in addition to the $150 DigiKey gift cards for the top three entrants.

It’s a What’s That Sound Results Show this week, and although Kristina actually got into the neighborhood of this one, she alas did not figure out that it was an MRI machine (even though she spent a week in an MRI one day).

Then it’s on to the hacks, which had a bit of a gastronomical bent this week. We wondered why normies don’t want to code on their Macs, both now and historically. We also examined the majesty of dancing raisins, and appreciated the intuitiveness of a salad spinner-based game controller.

From there we take a look at nitinol and its fun properties, admire some large, beautiful Nixie tubes, and contemplate a paper punching machine that spits out nonsensical binary. Finally we talk about rocker bogie suspensions and the ponder the death of cursive.

Check out the links below if you want to follow along, and as always, tell us what you think about this episode in the comments!

Download and savor at your leisure.

Where to Follow Hackaday Podcast

Places to follow Hackaday podcasts:

Continue reading “Hackaday Podcast 237: Dancing Raisins, Coding On Apples, And A Salad Spinner Mouse” →

Bringing Da Vinci’s Saw Mill To Life

September 11, 2023 by 30 Comments

DaVinci’s notebook — the real one, not the band — was full of wonderous inventions, though many were not actually built and probably weren’t even practical with the materials available at the time (or even now). [How To Make Everything] took one of the Master’s drawings from 1478 of a sawmill and tried to replicate it. How did he do? You can see for yourself in the video below.

There are five different pieces involved. A support structure holds a water wheel and a saw. There’s a crank mechanism to drive the saw and a sled to move the wood through the machine. It sounds simple enough, although we were impressed and amused that he made his own nails to be authentic. No Home Depot back in the 1470s, after all.

Watching him produce, for example, castle joints, makes us think, “Hey, we could do that!” But, of course, we probably can’t, at least not by hand. We must admit we are pretty dependent on CNC tools and 3D printing, but we admire the woodwork, nevertheless. There’s some pretty cool metal working, too.

We thought the waterwheel would be the easy part, but it turned out to be a bit of a problem. Things worked, but it was slower than you would think. We’ve seen sawmills put together before. Da Vinci worked for money, and there was always money in weapons so he did design a lot of them, too.

Continue reading “Bringing Da Vinci’s Saw Mill To Life” →

Building Up Unicode Characters One Bit At A Time

September 7, 2023 by 33 Comments

The range of characters that can be represented by Unicode is truly bewildering. If there’s a symbol that was ever used to represent a sound or a concept anywhere in the world, chances are pretty good that you can find it somewhere in Unicode. But can many of us recall the proper keyboard calisthenics needed to call forth a particular character at will? Probably not, which is where this Unicode binary input terminal may offer some relief.

“Surely they can’t be suggesting that entering Unicode characters as a sequence of bytes using toggle switches is somehow easier than looking up the numpad shortcut?” we hear you cry. No, but we suspect that’s hardly [Stephen Holdaway]’s intention with this build. Rather, it seems geared specifically at making the process of keying in Unicode harder, but cooler; after all, it was originally his intention to enter this in last year’s Odd Inputs and Peculiar Peripherals contest. [Stephen] didn’t feel it was quite ready at the time, but now we’ve got a chance to give this project a once-over.

The idea is simple: a bank of eight toggle switches (with LEDs, of course) is used to compose the desired UTF-8 character, which is made up of one to four bytes. Each byte is added to a buffer with a separate “shift/clear” momentary toggle, and eventually sent out over USB with a flick of the “send” toggle. [Stephen] thoughtfully included a tiny LCD screen to keep track of the character being composed, so you know what you’re sending down the line. Behind the handsome brushed aluminum panel, a Pi Pico runs the show, drawing glyphs from an SD card containing 200 MB of True Type Font files.

At the end of the day, it’s tempting to look at this as an attractive but essentially useless project. We beg to differ, though — there’s a lot to learn about Unicode, and [Stephen] certainly knocked that off his bucket list with this build. There’s also something wonderfully tactile about this interface, and we’d imagine that composing each codepoint is pretty illustrative of how UTF-8 is organized. Sounds like an all-around win to us.