Cart Cruises Abandoned California Rail

February 25, 2023 by Bryan Cockfield 20 Comments

Southern California is known for its nearly perfect year-round climate, excellent surf, and extremely high cost of living, but once you get away from the coast things are radically different. Rural California has huge tracts of land run by the Bureau of Land Management (BLM), which is publicly accessible to anyone willing to venture into the deserts. There’s not much in the way of infrastructure out there, but [Ryan] does have a unique way of traveling through it using abandoned railroad lines and this custom rail cart.

The frame of this cart is simple enough, it’s little more than 2×3 framing with a plywood deck. Some extra support is added for the motor mount and for the seating location. It uses slightly longer go-kart axles to accommodate the width of the railroad, and a small six horsepower gas engine with a single gear to power the rear axle. There are no brakes other than the riders’ shoes, and while this all seems straightforward enough the real hack here is [Ryan]’s custom wheels. He found that steel or cast wheels were not particularly comfortable on long journeys so after a few attempts he has come up with a home-built polyurethane wheel which is cast in a mold around a steel go-cart wheel and then trimmed on a lathe.

For pure exploration, there’s almost no better place to go than the American west thanks to all the public BLM land available. In this cart, you can explore long distances using an extremely low-cost method of transportation. We’ve added another video of [Ryan] exploring this area below the break to show the cart being used, too, but if you’d like a more multipurpose vehicle to use on abandoned rail near you, take a look at this bicycle which is converted to operate on the railroad.

Continue reading “Cart Cruises Abandoned California Rail” →

How To Roll Your Own Custom Object Detection Neural Network

February 13, 2023 by Donald Papp 2 Comments

Real-time object detection, which uses neural networks and deep learning to rapidly identify and tag objects of interest in a video feed, is a handy feature with great hacker potential. Happily, it’s also possible to make customized CNNs (convolutional neural networks) tailored for one’s own needs, and that process just got easier thanks to some new documentation for the Vizy “AI camera” by Charmed Labs.

Charmed Labs has been making hacker-friendly machine vision devices for a long time, and the Vizy camera impressed us mightily when we checked it out last year. Out of the box, Vizy has a perfectly functional object detector application that runs locally on the device, and can detect and tag many common everyday objects in real time. But what if that default application doesn’t quite meet one’s project needs? Good news, because it’s possible to create a custom-trained CNN, and that process got a lot more accessible thanks to step-by-step examples of training a model to recognize hands doing rock-paper-scissors.

Person and cat with machine-generated tags identifying them — Default object detection works well, but sometimes one needs custom results.

The basic process is this: Start with a variety of images that show the item of interest. Then identify and label the item of interest in each photo. These photos (a “training set”) are then sent to Google Colab, which will be used to generate a neural network. The resulting CNN model can then be downloaded and used, to see how well it performs.

Of course things rarely work perfectly the first time around, so at this point it’s pretty common for some refinement to be needed to increase accuracy. Luckily there are a number of tools to help do this without creating a new model from scratch, so it’s just a matter of tweaking until things perform acceptably.

Google Colab is free and the resulting CNNs are implemented in the TensorFlow Lite framework, meaning it’s possible to use them elsewhere. So if custom object detection has been holding up a project idea of yours, this might be what gets you over that hump.

High-Speed Sled Adds Bicycle Suspension

January 19, 2023 by Bryan Cockfield 3 Comments

While you might have bought the best pair of skis in the 90s or 00s, as parts on boots and bindings start to fail and safety standards for ski equipment improve, even the highest-quality skis more than 15 or 20 years old will eventually become unsafe or otherwise obsolete. There are plenty of things that can be done with a pair of old skis, but if you already have a shot ski and an Adirondack chair made of old skis, you can put another pair to use building one of the fastest sleds we’ve ever seen.

[Josh Charles], the creator of this project, took inspiration from his father, who screwed an old pair of skis to the bottom of an traditional runner sled when he was a kid. This dramatically increased the speed of the sled, but eliminated its ability to steer. For this build [Josh] built a completely custom frame rather than re-use an existing sled, which allowed him to not only build a more effective steering mechanism for the skis, but also to use bicycle suspension components to give this sled better control at high speeds.

This build is part of a series that [Josh] did a few years ago, and you can find additional videos about it documenting his design process and his initial prototypes and testing. The amount of work he put into this build is evident when it’s seen finally traversing some roads that had been closed for winter; he easily gets the sled up in the 30 mph range several times. If you’re looking to go uphill in the snow, though, take a look at this powered snowboard instead.

Continue reading “High-Speed Sled Adds Bicycle Suspension” →

Make Your Own Pot And Encoder Knobs, Without Reinventing Them

January 14, 2023 by Donald Papp 10 Comments

Rotary potentiometers, switches, and encoders all share a basic design: adjustment is done via a shaft onto which a knob is attached, and knobs are sold separately. That doesn’t mean one knob fits all; there are actually a few different standards. But just because knobs are inexpensive and easily obtained doesn’t mean it’s not worth making your own.

A simple and effective indicator can be easily printed in a contrasting color.

Why bother 3D printing your own knobs instead of buying them? For one thing, making them means one can rest assured that every knob matches aesthetically. The ability to add custom or nonstandard markings are another bonus. Finally, there’s no need to re-invent the wheel, because [Tommy]’s guide to making your own knobs has it all figured out, with the OpenSCAD script to match.

By default, [Tommy]’s script will generate a knob with three shims (for interfacing to a splined shaft) when pot_knob(); is called. The number of shims can be adjusted by modifying potKnobDefaultShimCount. To give the knob a flat side (to interface with D-shafts), change flatted = false to flatted = true. And for adding a screw insert suitable for a set screw? Change tightenerDiameter = 0 from zero to the diameter desired.

The script is quite comprehensive and has sensible defaults, but it does require a bit of knowledge about OpenSCAD itself to use effectively. We have covered the basics of OpenSCAD in the past, and if you’re ready for a resource that will help you truly master it, here’s where to look.

Home-Built CPU Runs With Home-Built Toolchain

November 22, 2022 by Dave Rowntree 14 Comments

A few years ago [Takaya Saeki] and fellow students of the University of Tokyo, were given a very limited instruction during their ‘CPU exercise’ class, along the lines of:

Take this ray-tracing program written in OCaml and run it on your CPU implemented on an FPGA

Splitting into groups to cover the CPU, FPU, simulator tool, and compiler toolchain, the students started with designing a RISC ISA, then designed a CPU around that. You can follow along with the retrospective writeup of the class, then dive into the GitHub pages for each of the components of the system, although the commentary is mainly in Japanese. Hey, you can google translate right? Continue reading “Home-Built CPU Runs With Home-Built Toolchain” →

Tiny Arcade Uses Tiny CRT

July 27, 2022 by Bryan Cockfield 16 Comments

Restoring vintage electronics is a difficult hobby to tackle. Even the most practical builds often have to use some form of modern technology to work properly, or many different versions of the machine need to be disassembled to get a single working version. Either way, in the end someone will be deeply hurt by the destruction of anything antique, except perhaps with [Marco]’s recent tiny arcade with a unique CRT display.

The CRT is a now-obsolete technology, but Arcade and MAME purists often seek them out because of the rounded screen and vintage feel these devices have when compared to modern LCD or LED displays. For a build this small, though, [Marco] couldn’t just use parts from an old TV set as there wouldn’t be clearance in the back of the cabinet. An outdated video conferencing system turned out to have just the part he needed, though. It has a CRT mounted perpendicularly to a curved screen in order to reduce the depth needed dramatically.

The final build uses a tiny Namco system meant to plug into the RCA jack on a standard TV, but put in a custom case that makes it look like an antique video game cabinet. It’s an interesting build that doesn’t destroy any valuable antique electronics, while still maintaining a classic arcade feel. If you’re building a larger arcade cabinet which will still satisfy the purists out there, make sure you’re using a CRT with the right kind of control system.

Continue reading “Tiny Arcade Uses Tiny CRT” →

Building Faster Rsync From Scratch In Go

June 1, 2022 by Bryan Cockfield 53 Comments

For a quick file transfer between two computers, SCP is a fine program to use. For more complex, large, or regular backups, however, the go-to tool is rsync. It’s faster, more efficient, and usable in a wider range of circumstances. For all its perks, [Michael Stapelberg] felt that it had one major weakness: it is a tool written in C. [Michael] is philosophically opposed to programs written in C, so he set out to implement rsync from scratch in Go instead.

[Michael]’s path to deciding to tackle this project is a complicated one. His ISP upgraded his internet connection to 25 Gbit/s recently, which means that his custom router was the bottleneck in his network. To solve that problem he migrated his router to a PC with several 25 Gbit/s network cards. To take full advantage of the speed now theoretically available, he began using a tool called gokrazy, which turns applications written in Go into their own appliance. That means that instead of installing a full Linux distribution to handle specific tasks (like a router, for example), the only thing loaded on the computer is essentially the Linux kernel, the Go compiler and libraries, and then the Go application itself.

With a new router with hardware capable of supporting these fast speeds and only running software written in Go, the last step was finally to build rsync to support his tasks on his network. This meant that rsync itself needed to be built from scratch in Go. Once [Michael] completed this final task, he found that his implementation of rsync is actually much faster than the version built in C, thanks to the modernization found in the Go language and the fact that his router isn’t running all of the cruft associated with a standard Linux distribution.

For a software project of this scope, we find [Michael]’s step-by-step process worth taking note of for any problem any of us attempt to tackle. Not only that, refactoring a foundational tool like rsync is an involved task on its own, let alone its creation simply to increase network speeds beyond what most of us would already consider blazingly fast. We’re leaving out a ton of details on this build so we definitely recommend checking out his talk in the video below.

Thanks to [sarinkhan] for the tip!

Continue reading “Building Faster Rsync From Scratch In Go” →