Truck-Sized Star Destroyer Takes Flight

While some of you may have been to see the new Star Wars movie, you might be sad that everything happened a long time ago in a galaxy far away. But there’s a group of RC enthusiasts called [Flite Test] who are trying to bring at least a little bit of that fantasy into real life. They’ve created a truck-sized Star Destroyer that actually flies. It looks kind of terrifying, too.

While it’s not as big as a “real” Star Destroyer, it’s certainly one of the biggest we’ve ever seen in real life. Built out of foam, this monstrosity is 15 feet long and powered by two huge electric motors and a large lithium polymer battery. Of course they didn’t start out by building this huge flying spaceship; they created a smaller model as proof-of-concept and flew that one around for a while to make sure everything was shipshape. While it’s exciting to see the small model in flight, it’s another thing to see the 15-foot version swooping around.

We’re sad to report that the Star Destroyer did meet a similar fate as the one that Rey was scavenging at the beginning of the movie (spoilers: it crashed), we hope that the RC team rebuilds it so it’s space worthy again. Maybe they can even add a real-life ion drive or a few lasers to make it even more real.

Continue reading “Truck-Sized Star Destroyer Takes Flight”

Art for Planespotters

We don’t know art, but we know what we like. And this gizmo by [Johan Kanflo] is right up our alley.

First, [Johan] gutted an old Macintosh Classic computer and stuffed a Raspberry Pi inside. Now this is not really a new idea, but [Johan] did a very nice job with the monitor and his attention to detail shows in the rebuilt floppy-drive eject mechanism. He gives it back that characteristic “schlurp” noise.

Then he outfitted the Raspberry Pi with an RTL dongle running dump1090 software to listen to the ADS-B radio signals. The data extracted from the SDR is piped off to an MQTT server with all sorts of data about the airplanes overhead. Another script subscribes to the MQTT topic and figures out which is the closest and runs an image search for the plane type in question, publishing the results back to another MQTT topic. One final script subscribes to this last topic and displays the relevant images on the screen. Pshwew!

The end result is a Macintosh Classic that’s continually updated with whatever planes are closest to being overhead. We’re not at all sure if this is fine art, or part of the useful arts, or maybe even none of the above. But we really like the nice case job and think that using MQTT as a back-end for coordinating multiple concurrent Python scripts (on the same computer) is pretty cool.

Portable, DIY Radiography

[Matt] has a background in radiation, electronics, and physics, which means building a device to generate X-rays was only a matter of time. It’s something not everyone should attempt, and [Matt] discourages anyone from attempting anything like this, but if you’re looking for a project with a ‘because it’s there’ flair to it, building your own X-ray machine can be a fun and rewarding project.

Despite being scary and mysterious, X-rays are a rather old technology that date back to some of the first purposeful experiments in electronics. Most X-ray devices today are built around the same parts they were 100 years ago, namely, a Coolidge tube. Apply a high enough voltage to the Coolidge tube and electrons whizz from cathode to anode, and slam into a heavy metal target. This produces Bremsstrahlung radiation – breakingbraking X-rays – that can be directed to film or an X-ray intensifier screen that fluoresces in visible light when being struck by X-rays.

Aside from a cheap Coolidge tube, [Matt] constructed the rest of his X-ray generator with a voltage multiplier made out of sufficiently derated Chinese caps, a flyback transformer, and a transformer driver originally made for induction heating applications. The electronics were installed in a Tupperware container and insulated with mineral oil.

Being able to generate X-rays is one thing, viewing them is another matter entirely. For this, [Matt] is using an old X-ray intensifier screen from the 60s or 70s. This screen fluoresces blue, not the easiest color to photograph in low-light settings, but enough to capture images of the inside of tools sitting around his workbench. Following in the footsteps of [Roentgen], [Matt] also took an X-ray image of his hand. This is something he doesn’t recommend, and something he won’t do again, but it is a very cool example of what you can do with sufficient knowledge and respect for what can kill you.

32C3: So You Want to Build a Satellite?

[INCO] gave this extremely informative talk on building a CubeSat. CubeSats are small satellites that piggyback on the launches of larger satellites, and although getting a 10 cm3 brick into orbit is cheap, making it functional takes an amazing attention to detail and redundant design.

[INCO] somehow talks through the entire hour-long presentation at a tremendous speed, all the while remaining intelligible. At the end of the talk, you’ve got a good appreciation for the myriad pitfalls that go along with designing a satellite, and a lot of this material is relevant, although often in a simpler form, for high altitude balloon experiments.

satellite_2-shot0002CubeSats must be powered down during launch, with no radio emissions or anything else that might interfere with the rocket that’s carrying them. The satellites are then packed into a box with a spring, and you never see or hear from them again until the hatch is opened and they’re pushed out into space.

[INCO] said that 50% of CubeSats fail on deployment, and to avoid being one of the statistics, you need to thoroughly test your deployment mechanisms. Test after shaking, being heated and cooled, subject to low battery levels, and in a vacuum. Communication with the satellite is of course crucial, and [INCO] suggests sending out a beacon shortly after launch to help you locate the satellite at all.

satellite_2-shot0003Because your satellite is floating out in space, even tiny little forces can throw it off course. Examples include radiation pressure from the sun, and anything magnetic in your satellite that will create a torque with respect to the Earth’s magnetic field. And of course, the deployment itself may leave your satellite tumbling slightly, so you’re going to need to control your satellite’s attitude.

Power is of course crucial, and in space that means solar cells. Managing solar cells, charging lithium batteries, and smoothing out the power cycles as the satellite enters the earth’s shadow or tumbles around out of control in space. Frequent charging and discharging of the battery is tough on it, so you’ll want to keep your charge/discharge cycles under 20% of the battery’s nominal capacity.

mpv-shot0001In outer space, your satellite will be bombarded by heavy ions that can short-circuit the transistors inside any IC. Sometimes, these transistors get stuck shorted, and the only way to fix the latch-up condition is to kill power for a little bit. For that reason, you’ll want to include latch-up detectors in the power supply to reset the satellite automatically when this happens. But this means that your code needs to expect occasional unscheduled resets, which in turn means that you need to think about how to save state and re-synchronize your timing, etc.

In short, there are a ridiculous amount of details that you have to attend to and think through before building your own CubeSat. We’ve just scratched the surface of [INCO]’s advice, but if we had to put the talk in a Tweet, we’d write “test everything, and have a plan B whenever possible”. This is, after all, rocket science.

Code Craft-Embedding C++: Hacking the Arduino Software Environment

The Arduino software environment, including the IDE, libraries, and general approach, are geared toward education. It’s meant as a way to introduce embedded development to newbies. This is a great concept but it falls short when more serious development or more advanced education is required. I keep wrestling with how to address this. One way is by using Eclipse with the Arduino Plug-in. That provides a professional development environment, at least.

The code base for the Arduino is another frustration. Bluntly, the use of setup() and loop() with main() being hidden really bugs me. The mixture of C and C++ in libraries and examples is another irritation. There is enough C++ being used that it makes sense it should be the standard. Plus a good portion of the library code could be a lot better. At this point fixing this would be a monumental task requiring many dedicated developers to do the rewrite. But there are a some things that can be done so let’s see a couple possibilities and how they would be used.

Continue reading “Code Craft-Embedding C++: Hacking the Arduino Software Environment”

32C3: Running Linux On The PS4

At the 2010 Chaos Communication Congress, fail0verflow (that’s a zero, not the letter O) demonstrated their jailbreak of the PS3. At the 2013 CCC, fail0verflow demonstrated console hacking on the Wii U. In the last two years, this has led to an active homebrew scene on the Wii U, and the world is a better place. A few weeks ago, fail0verflow teased something concerning the Playstation 4. While this year’s announcement is just a demonstration of running Linux on the PS4, fail0verflow can again claim their title as the best console hackers on the planet.

Despite being able to run Linux, there are still a few things the PS4 can’t do yet. The current hack does not have 3D acceleration enabled; you won’t be playing video games under Linux with a PS4 any time soon. USB doesn’t work yet, and that means the HDD on the PS4 doesn’t work either. That said, everything to turn the PS4 into a basic computer running Linux – serial port, framebuffer, HDMI encoder, Ethernet, WiFi, Bluetooth, and the PS4 blinkenlights – is working.

Although the five-minute lightning talk didn’t go into much detail, there is enough information on their slides to show what a monumental task this was. fail0verflow changed 7443 lines in the kernel, and discovered the engineers responsible for the southbridge in the PS4 were ‘smoking some real good stuff’.

This is only fail0verflow’s announcement that Linux on the PS4 works, and the patches and bootstrap code are ‘coming soon’. Once this information is released, you’ll need to ‘Bring Your Own Exploit™’ to actually install Linux.

Video of the demo below.

Continue reading “32C3: Running Linux On The PS4”

2015: As the Hardware World Turns

A few hours from now, the ball will drop in Times Square. 2015 is over, and the good news is you can easily turn a handwritten ‘5’ into a ‘6’. Keep that in mind for the next few weeks. It’s time for a retrospective of everything that happened in 2015. That’s rather boring, though, and it’s usually better to put the most outrageous items in the lede. Therefore, it’s time for predictions of what will happen over the next 366 days. They are, in order:

  • 2016 will be the year of the Linux desktop
  • Self-driving cars will be demonstrated
  • Graphene! Something to do with graphene!
  • Your company will receive a resume with ‘Bitcoin’ listed as a skill
  • Fusion power is only nine years away

With that said, a lot happened this year. Tiny Linux single board computers became incredibly cheap, Radio Shack died, and Arduino went crazy.

Continue reading “2015: As the Hardware World Turns”