Driving A Big RC Car On The Ceiling

July 30, 2019 by 6 Comments

RC cars are a great way to have fun hooning around. There’s plenty of laughs to be had racing your friends in the local grocery store carpark, ideally after hours. [Ivan Miranda] wanted to go in a different direction, however – and that direction was up. (Video embedded after the break.)

There are existing toys that can pull off a wall-riding feat, but they’re normally on a fairly small scale. [Ivan] wanted to go big, and so outfitted some seriously powerful brushless fans on to his 1/8th Rattler buggy from Hobbyking. After initial failure, a smaller scale model was successfully built and tested, before it was realised the full-sized build had the propellers on backwards.

With this oversight fixed, the car was able to drive on the ceiling, albeit in the limited space between the roof beams. It was somewhat less viable on the wall, struggling to stay stuck and having issues with suspension flex.

Overall, it’s a great application of mass brushless power to fight gravity – the same principle behind the multirotors we all love so much. [Ivan]’s put the same trick to use for getting around on a skateboard, too. Video after the break.

Continue reading “Driving A Big RC Car On The Ceiling” →

C++20 Is Feature Complete; Here’s What Changes Are Coming

July 30, 2019 by 104 Comments

If you have an opinion about C++, chances are you either love it for its extensiveness and versatility, or you hate it for its bloated complexity and would rather stick to alternative languages on both sides of the spectrum. Either way, here’s your chance to form a new opinion about the language. The C++ standard committee has recently gathered to work on finalizing the language standard’s newest revision, C++20, deciding on all the new features that will come to C++’s next major release.

After C++17, this will be the sixth revision of the C++ standard, and the language has come a long way from its “being a superset of C” times. Frankly, when it comes to loving or hating the language, I haven’t fully made up my own mind about it yet. My biggest issue with it is that “programming in C++” can just mean so many different things nowadays, from a trivial “C with classes” style to writing code that will make Perl look like prose. C++ has become such a feature-rich and downright overwhelming language over all these years, and with all the additions coming with C++20, things won’t get easier. Although, they also won’t get harder. Well, at least not necessarily. I guess? Well, it’s complex, but that’s simply the nature of the language.

Anyway, the list of new features is long, combining all the specification proposals is even longer, and each and every one of these additions could fill its own, full-blown article. But to get a rough idea about what’s going to come to C++ next year, let’s have a condensed look at some of these major new features, changes, and additions that will await us in C++20. From better type checking and compiler errors messages to Python-like string handling and plans to replace the #include system, there’s a lot at play here!

Continue reading “C++20 Is Feature Complete; Here’s What Changes Are Coming” →

Etch-A-Selfie

July 30, 2019 by 5 Comments

Taking a selfie before the modern smartphone era was a true endeavor. Flip phones didn’t have forward-facing cameras, and if you want to go really far back to the days of film cameras, you needed to set a timer on your camera and hope, or get a physical remote shutter. You could also try and create a self portrait on an Etch a Sketch, too, but this would take a lot of time and artistic skill. Luckily in the modern world, we can bring some of this old technology into the future and add a robot to create interesting retro selfies – without needing to be an artist.

The device from [im-pro] attaches two servos to the Etch a Sketch knobs. This isn’t really a new idea in itself, but the device also includes a front-facing camera, taking advantage of particularly inexpensive ESP32 Camera modules. Combining the camera features with [Bart Dring]’s ESP32 Grbl port is a winner. Check the code in [im-pro]’s GitHub.

Once the picture is taken, the ESP32 at the heart of the build handles the image processing and then drawing the image on the Etch a Sketch. The robot needs a black and white image to draw, and an algorithm for doing it without “lifting” the drawing tool, and these tasks stretch the capabilities of such a small processor. It takes some time to work, but in the end the results speak for themselves.

The final project is definitely worth looking for, if not for the interesting ESP32-controlled robot than for the image processing algorithim implementation. The ESP32 is a truly versatile platform, though, and is useful for building almost anything.

Continue reading “Etch-A-Selfie” →

Apple Lightning Video Adaptors Run IOS, Dynamically Loaded

July 30, 2019 by 28 Comments

Apple has for a very long time been a company that ploughs its own furrow when it comes to peripherals, with expensive proprietary hardware being the order of the day over successive generations of its products. One of its current line of proprietary interfaces is the Lightning connector, best thought of as an Apple-only take on the same ideas that the rest of the world knows as USB-C. There are a whole host of white dangly peripherals that can be hung from your iDevice’s Lightning port, including a pair of display adaptors that allow them to drive an HDMI or VGA monitor.  [Lisa Braun] has subjected one that had failed to a teardown, and her analysis gives some insight into the way Apple creates its peripherals.

Where you might expect these to contain mostly the equivalent of a graphics card, in fact they have a fully-fledged SoC of their own that runs its own OS with the same Darwin kernel as its host. Unexpectedly this is not held upon the adapter itself, instead it is shipped with iOS and loaded dynamically. Thus the file containing it can be retrieved from iOS and unpacked, leading to some interesting analysis. In a fascinating twist for those of us unused to Lightning’s internals, it’s revealed that the device can be driven from a USB port with the appropriate cobbled-together adapter, allowing a full-size MacOS device to interrogate it. This many not be news to readers with a long memory though, we’ve told you in the past about reverse engineering the Lightning connector.

Dreamcast Gets A Plug-n-Play Hard Drive Mod

July 29, 2019 by 22 Comments

The Dreamcast was a proud moment for Sega, at least initially, being the first console to launch of a new generation. Unfortunately this didn’t translate into massive sales, and the plug was pulled far earlier than expected. The console retains a dedicated fanbase to this day however, who continue to tinker with the hardware. [DreamcastChannel] is one of them, and put together a nifty plug-and-play hard drive mod.

The mod is based on earlier work, which consisted of manually soldering the 44 lines of an IDE cable on to the main Dreamcast motherboard. This allowed an IDE hard drive to be neatly mounted inside the shell, but [DreamcastChannel] knew it was possible to do better.

Starting from scratch, the GDROM optical drive assembly is gutted, leaving just its metal case and PCB. The IDE cable for the hard disk is then soldered to the pads on the PCB. A 3D printed mount is used to fix the hard drive to the metal case. This allows the entire assembly to slot neatly into the Dreamcast, using the GDROM’s original connector.

It’s a hack that makes putting a hard drive into the Dreamcast neat and tidy. Combined with a hacked BIOS and Dreamshell, it makes playing backup games a breeze. We’ve seen plenty of Dreamcast hacks before, too – the VMU is often a key candidate for attention. Video after the break.

Continue reading “Dreamcast Gets A Plug-n-Play Hard Drive Mod” →

Where The Work Is Really Done – Casual Profiling

July 29, 2019 by 13 Comments

Once a program has been debugged and works properly, it might be time to start optimizing it. A common way of doing this is a method called profiling – watching a program execute and counting the amount of computing time each step in the program takes. This is all well and good for most programs, but gets complicated when processes execute on more than one core. A profiler may count time spent waiting in a program for a process in another core to finish, giving meaningless results. To solve this problem, a method called casual profiling was developed.

In casual profiling, markers are placed in the code and the profiler can measure how fast the program gets to these markers. Since multiple cores are involved, and the profiler can’t speed up the rest of the program, it actually slows everything else down and measures the markers in order to simulate an increase in speed. [Daniel Morsig] took this idea and implemented it in Go, with an example used to demonstrate its effectiveness speeding up a single process by 95%, resulting in a 22% increase in the entire program. Using a regular profiler only counted a 3% increase, which was not as informative as the casual profiler’s 22% measurement.

We got this tip from [Greg Kennedy] who notes that he hasn’t seen much use of casual profiling outside of the academic world, but we agree that there is likely some usefulness to this method of keeping track of a multi-threaded program’s efficiency. If you know of any other ways of solving this problem, or have seen causal profiling in use in the wild, let us know in the comments below.

Header image: Alan Lorenzo [CC BY-SA 3.0].

A Simple Way To Analyze Guitar Pickups

July 29, 2019 by 21 Comments

To the uninitiated an electric guitar seems fairly simple: you pluck a string and the electronics send the corresponding audio signal on the 6.3 mm jack output, all ready for for the amplifier to work its magic. Much of what makes a guitar like that sound good depends on the pickups, however. These are the devices which are placed between the guitar body and the strings. Depending on the guitar there can be one, two, or more of them, of varying types and configurations.

As a Gibson fan who upon getting introduced to a Fender Telecaster just had to replace its pickups with humbucking types, [Ken Willmott] found himself thrown into the wonderful world of pickup design and characterization. After two years of working through a number of designs and approaches, he eventually settled on a preamplifier design featuring a JFET opamp (LT1058) on a custom PCB which amplifies the pickup response from a test signal, acting as a front end signal conditioner.

Continue reading “A Simple Way To Analyze Guitar Pickups” →