Printable Fix For Time Card Clock Has Owner Seeing Red Again

May 14, 2022 by 8 Comments

When [Morley Kert] laid eyes on a working time card-punching clock, he knew he had to have it for a still-secret upcoming project. The clock seemed to work fine, except that after a dozen or so test punches, the ink was rapidly fading away into illegibility. After a brief teardown and inspection, [Morley] determined that the ribbon simply wasn’t advancing as it should.

This clock uses a ribbon cassette akin to a modern typewriter, except that instead of a feed spool and a take-up spool, it has a short length of ribbon that goes around and around, getting re-inked once per revolution.

When a card is inserted, a number of things happen: a new hole is punched on the left side, and an arm pushes the card against the ribbon, which is in turn pushed against the mechanical digit dials of the clock to stamp the card.

Finally, the ribbon gets advanced. Or it’s supposed to, anyway. [Morley] could easily see the shadow of a piece that was no longer there, a round piece with teeth with a protrusion on both faces for engaging both the time clock itself and the ribbon cassette. A simple little gear.

After emailing the company, it turns out they want $95 + tax to replace the part. [Morley] just laughed and fired up Fusion 360, having only caliper measurements and three seconds of a teardown video showing the missing part to go on. But he pulled it off, and pretty quickly, too. Version one had its problems, but 2.0 was a perfect fit, and the clock is punching evenly again. Be sure to check it out after the break.

Okay, so maybe you don’t have a time card clock to fix. But surely you’ve had to throw out an otherwise perfectly good coat because the zipper broke?

Continue reading “Printable Fix For Time Card Clock Has Owner Seeing Red Again” →

APPLE2IDIOT Expansion Card Lets Your Apple II (Sort Of) Access The Internet

May 7, 2022 by 26 Comments

[Nathanial Hendler]’s Apple2Idiot expansion card for the Apple II family of computers is a nifty mix of modern and vintage, and provides a clever means of allowing the host computer to (indirectly) access the internet over WiFi while keeping things simple from the host computer’s perspective.

The PCB has plenty of space on which to silkscreen reference data. Click to enlarge.

It does this by embedding an ESP32 module and a dual-port RAM chip onto an expansion card. The Apple2Idiot, when installed into a host machine, presents as a memory location which the host machine can access. The ESP32 then takes care of all the WiFi communications and tasks requiring internet access, and the host computer directs these tasks (and reads their output) via PEEK and POKE commands.

This means that there are two pieces of software for any given task: one running on the ESP32 doing the actual work, and one running on the Apple II that communicates with the ESP32 on the card by reading and writing to memory. It’s a simple system, and one that [Nathanial] thinks works quite well for specific tasks.

Example programs include things like scanning and selecting a WiFi network, fetching weather data, and sending a message to Slack. Making new applications does mean having to write software on two ends, but the simplicity of the system also means flexibility, because anything the ESP32 does can have its complexity abstracted away by the time its data is presented to the host machine. Not that the Apple II is incapable of dealing with the modern internet more directly; we’ve seen a basic Apple II web server written in BASIC.

Linux Fu: Simple Pipes

March 16, 2022 by 15 Comments

In the old days, you had a computer and it did one thing at a time. Literally. You would load your cards or punch tape or whatever and push a button. The computer would read your program, execute it, and spit out the results. Then it would go back to sleep until you fed it some more input.

The problem is computers — especially then — were expensive. And for a typical program, the computer is spending a lot of time waiting for things like the next punched card to show up or the magnetic tape to get to the right position. In those cases, the computer was figuratively tapping its foot waiting for the next event.

Someone smart realized that the computer could be working on something else while it was waiting, so you should feed more than one program in at a time. When program A is waiting for some I/O operation, program B could make some progress. Of course, if program A didn’t do any I/O then program B starved, so we invented preemptive multitasking. In that scheme, program A runs until it can’t run anymore or until a preset time limit occurs, whichever comes first. If time expires, the program is forced to sleep a bit so program B (and other programs) get their turn. This is how virtually all modern computers outside of tiny embedded systems work.

But there is a difference. Most computers now have multiple CPUs and special ways to quickly switch tasks. The desktop I’m writing this on has 12 CPUs and each one can act like two CPUs. So the computer can run up to 12 programs at one time and have 12 more that can replace any of the active 12 very quickly. Of course, the operating system can also flip programs on and off that stack of 24, so you can run a lot more than that, but the switch between the main 12 and the backup 12 is extremely fast.

So the case is stronger than ever for writing your solution using more than one program. There are a lot of benefits. For example, I once took over a program that did a lot of calculations and then spent hours printing out results. I spun off the printing to separate jobs on different printers and cut like 80% of the run time — which was nearly a day when I got started. But even outside of performance, process isolation is like the ultimate encapsulation. Things you do in program A shouldn’t be able to affect program B. Just like we isolate code in modules and objects, we can go further and isolate them in processes.

Doubled-Edged Sword

But that’s also a problem. Presumably, if you want to have two programs cooperate, they need to affect each other in some way. You could just use a file to talk between them but that’s notoriously inefficient. So operating systems like Linux provide IPC — interprocess communications. Just like you make some parts of an object public, you can expose certain things in your program to other programs.

Continue reading “Linux Fu: Simple Pipes” →

Raspberry Pi And The Story Of SD Card Corruption

March 9, 2022 by 107 Comments

Tales of Raspberry Pi SD card corruption are available online by the fistful, and are definitely a constant in Pi-adjacent communities. It’s apparent that some kind of problems tend to arise when a Raspberry Pi meets an SD card – which sounds quite ironic, since an SD card is the official and recommended way of booting a Pi. What is up with all of that?

I can start with a history lesson. Back when Raspberry Pi launched in 2012 – which is now 10 years ago – there were SD card controller driver problems, which makes sense given the wide variety of SD cards available out there. They were verifiably fixed one by one at some point in time, as debugging goes, their impact decreased and bugs with individual cards got smoothed over. This is how the “Pi SD card corruption” meme was originally born; however, if the problems were to end there, so would the meme. Yet, tales of broken SD cards plague us to this day – way less severe than they were in the beginning, but pronounced enough that you’ll see people encounter them every now and then.

Over the years, a devoted base of Pi SD card haters has grown. Their demand has been simple – Raspberry Pi has to get an ability to boot from something else, in large part because of corruption reasons, but also undeniably because of speed and capacity/cost limitations of SD cards. Thanks to their demands and work, we’ve seen a series of projects grow from unofficial efforts and hacks into officially supported Raspberry Pi abilities – USB boot being initially more of a workaround but now something you can enable out of the box, SSD-equipped Pi enclosures becoming more of a norm, and now, NVMe boot appearing on the horizon. Every few years, we get a new way to boot a Pi. Continue reading “Raspberry Pi And The Story Of SD Card Corruption” →

PS2 Memory Card ISO Loader Offers Classic Gaming Bliss

February 15, 2022 by 30 Comments

It used to be that to play a console game, you just had to plug in a cartridge or put a CD/DVD in the optical drive. But these days, with modern titles ballooning up to as much as 100 GB, you’ve got no choice but to store them on the system’s internal hard disk drive. While that can lead to some uncomfortable data management decisions, at least it means you don’t have to get up off the couch to switch games anymore.

Which is precisely why the MC2SIO project for the PlayStation 2 is so exciting. As [Tito] explains in his latest
Macho Nacho Productions video, this simple adapter lets you connect an SD card up to the console’s Memory Card slots and use that to hold ISOs of your favorite games. With the appropriate homebrew software loaded up, your PS2 becomes a veritable jukebox of classic games.

Continue reading “PS2 Memory Card ISO Loader Offers Classic Gaming Bliss” →

This Week In Security: NPM Vandalism, Simulating Reboots, And More

January 14, 2022 by 33 Comments

We’ve covered quite a few stories about malware sneaking into NPM and other JavaScript repositories. This is a bit different. This time, a JS programmer vandalized his own packages. It’s not even malware, perhaps we should call it protestware? The two packages, colors and faker are both popular, with a combined weekly download of nearly 23 million. Their author, [Marak] added a breaking update to each of them. These libraries now print a header of LIBERTY LIBERTY LIBERTY, and then either random characters, or very poor ASCII art. It’s been confirmed that this wasn’t an outside attacker, but [Marak] breaking his own projects on purpose. Why?

It seems like this story starts back in late 2020, when [Marak] lost quite a bit in a fire, and had to ask for money on Twitter. Edit: Thanks to commenter [Jack Dansen] for pointing out an important detail that was missing. Marak was charged for reckless endangerment, and was suspected for possible terrorism aspirations, as bomb-making materials were found in his burned-out apartment. Two weeks later, he tweeted that billions were being made off open source devs’ work, citing a FAANG leak. FAANG is a reference to the big five American tech companies: Facebook, Apple, Amazon, Netflix, and Google. The same day, he opened an issue on Github for faker.js, throwing down an ultimatum: “Take this as an opportunity to send me a six figure yearly contract or fork the project and have someone else work on it.”
Continue reading “This Week In Security: NPM Vandalism, Simulating Reboots, And More” →

Pulp-Molding: A Use For Cardboard Confetti

November 5, 2021 by 21 Comments

We’re pretty sure that we don’t have to tell you how great cardboard is. You probably sing the praises yourself and use it for everything from a work surface protective layer to a prototype of your next amazing build. But if you still find yourself flush with cardboard even after all that, here’s one thing you can do with all those pieces that are too small to use for anything else– chuck them in an old blender, whip up some cardboard pulp, and press that gunk into some 3D-printed molds.

In addition to a step-by-step of the process, [flowalistik] offers a mold set of STL files for various useful items like a pencil holder, a box with a lid, a tray, and a coaster, as well as the Fusion 360 files in case you want to change them around. You might want to seal the coaster with something protective so that it doesn’t mold/disintegrate/bloom from condensation.

Each part consists of the walls, the wall clip that keeps them closed, but allows for de-molding and reuse, the bottom lid, and the top lid. All these prints need to be pretty high-res so that they can withstand the pressure of the clamp holding it all together. [flowalistik] recommends a layer height no larger than .03mm and a 20% infill.

The process of making the pulp itself is fairly simple, and the recipe only calls for water and some kind of binder. To start, remove all tape, coatings, staples, and anything else non-soluble from the cardboard. Cut it into bite-sized pieces your blender will enjoy, and add water and PVA glue or rice paste. Mix it up, remove the excess water by squeezing your pulp inside of a piece of cloth, and then use it to fill up your mold. You’ll want to press out the water as you go and fill it further, then finally apply the clamp. You can start de-molding parts on a schedule, starting with the clamp after about six hours. Once it’s fully dried in about two days, you can treat it like MDF and sand, cut, or even drill it. We think some of these would look pretty good with a coat of paint.

Need your objects to be more sturdy? Keep that printer warmed up — you can use prints to cast concrete, too.