Publish Or Perish: Data Storage And Civilization

Who do you think of when you think of ancient civilizations? Romans? Greeks? Chinese? India? Egyptians?  What about the Scythians, the Muisca, Gana, or the Kerma? You might not recognize that second group as readily because they all didn’t have writing systems. The same goes, to a lesser extent, for the Etruscans, the Minoans, or the inhabitants of Easter Island where they wrote, but no one remembers how to read their writing. Even the Egyptians were mysterious until the discovery of the Rosetta stone. We imagine that an author writing in Etruscan didn’t think that no one would be able to read the writing in the future–they probably thought they were recording their thoughts for all eternity. Hubris? Maybe, but what about our documents that are increasingly stored as bits somewhere?

Continue reading “Publish Or Perish: Data Storage And Civilization”

Tiny Thin Client Is Small But Compatible

We were impressed with [moononournation’s] tiny thin client project. It claims to use an Arduino, but as you might guess it is using the Arduino software along with a network-enabled microcontroller like an ESP32. The impressive part is that it is standards-compliant and implements VNC’s RFB protocol.

The original coding for RFB on Arduino is from [Links2004] and armed with that, the thin client is probably easier to create than you would guess. However, this project wanted to use a larger screen and found that it led to certain problems. In particular, the original code had a 320×240 display. This project was to use an 800×480 display, but with the limits on the ESP32, the frame rate possible would be under 7 frames per second. The answer was to combine a 16-bit parallel interface with better compression back to the VNC server.

The little keyboard is probably not very practical, but it is compact. That would be another easy thing to modify. Currently, the keyboard uses I2C, but it would be straightforward to change things up. This would be a worthy base to build a bigger project on top. A 3D printed enclosure would be nice, too.

We’ve seen a number of projects built around commercial thin clients. Some from defunct businesses are good sources for obscure parts, too.

Continue reading “Tiny Thin Client Is Small But Compatible”

Watermelon CNC Uses Lazy Susan

It is the time of year when a lot of people in certain parts of the world carve pumpkins. [Gonkee] is carving a watermelon, which we assume is similar. He decided to make a CNC machine to do the carving for him. The unusual part is the use of two lazy Susans to make a rotary carving machine. You can see the result in the video below.

The hardware is clever and there is software that lets you do drawings, although we were hoping for something that would process gcode or slice STL. That would be a worthy add-on project. There were a few iterations required before the Melon Carver 3000 worked satisfactorily. Seeing a carving tool operating on two circles gives us a lot of ideas. We aren’t sure how sturdy the mounts are, so don’t plan on carving aluminum without some changes, but we suspect it is possible.

Then again, a laser head mounted on the frame would have probably made short work of the melon, and wouldn’t require much mechanical stiffness. It would, however, take a little effort to keep it in focus. So many ideas to try!

Watermelon is a popular hacking medium, apparently. There’s even one that holds a GameBoy.

ARM Programming By Example

The ARM processor is popping up everywhere. From Raspberry Pis, to phones, to Blue Pill Arduino-like boards, you don’t have to go far to find an ARM processor these days. If you program in C, you probably don’t care much or even think about it. But do you know ARM assembly language? Well, if you look at it one way, it can’t be too hard. The CPU only has about 30 distinct operations — that’s why it is called RISC. Of course, sometimes fewer instructions actually make things more difficult. But you can get a great starting tutorial with the 21 programs on the ARM Assembly by Example website.

You need a 32-bit ARMv6 or better — so Raspberry Pi will work here. The compiler, of course, is gcc and all the associated tools. if you have the right hardware, there are sections on using the floating point unit and the NEON co-processor, too.

Continue reading “ARM Programming By Example”

Hacking Google With Plasma

Google recently made some videos to highlight cybersecurity. The video below is episode three, and it tells an interesting story about the first crash test dummy. However, the really interesting part is the story about a USB plasma globe built to hack into computers. One of the people who built that globe tells the story of its insides in a recent blog post that has a bit more technical detail.

The attack in question was in 2012, when people were starting to get the idea that inserting random USB drives into their computers wasn’t a great idea. However, what harm could there be in a cute little plasma globe that just draws power from the port?

Continue reading “Hacking Google With Plasma”

Power Loss Recovery Might Make 3D-Printed Blobs

[Geek Detour] had a mystery to solve. A round part he was printing had a distinct pattern of blobs. If you’ve been 3D printing for any length of time, you know that pauses in printing can cause blobs like this. He also showed a perfectly-printed version of the same part and claimed it was from the same printer with the same material and even slicer settings. So what was causing the blobs? You can find the answer in the video below.

As you might guess from the title, however, the issue was the power loss recovery feature built into the printer. While there’s a lot going on in the video, you can break it down to a few items, all of which you can fix in one way or another including the simple fix: turn off power loss recovery.

Continue reading “Power Loss Recovery Might Make 3D-Printed Blobs”

Simple CNC Gear Production With Arduino

We’ve seen plenty of people 3D printing custom gears over the years, but [Mr Innovative] decided against an additive process for his bespoke component. He ended up using a simple CNC machine that makes use of several components that were either salvaged from a 3D printer or produced on one. Using a small saw blade, the machine cuts gear teeth into some plastic material and — presumably — could cut gears into anything the saw blade was able to slice into, especially if you added a little lubrication, cooling, and dust removal.

If you’ve built a 3D printer, you’ll see a lot of familiar parts. Stepper motors, aluminum extrusion, straight rods, bearing blocks, and rod holders are all used in the build. There’s also a lead screw and the associated components you usually see in a printer’s Z-axis. Naturally, an Arduino drives the whole affair.

The saw blade was custom-made from a washer, grinding an edge and using a 3D printed template to cut teeth in it. We might have been more inclined to use a cut-off wheel from a rotary tool, but this certainly did the trick. An LCD accepts the gear diameter and number of teeth. The stepper rotates the correct number of degrees and another stepper lowers the cutting head which is spinning with a common DC motor.

As impressive as this machine is, the fact remains that a 3D printer can produce more complex designs. For example, a herringbone pattern can help with alignment issues. It has been done many times. You can even use a resin printer, although you might prefer to stick with FDM.

Continue reading “Simple CNC Gear Production With Arduino”