Syndicate content Hackaday
Fresh hacks every day
ถูกปรับปรุง 1 ชั่วโมง 10 min ก่อน

Crazy Good Odds to win the Hackaday Prize

ศุกร์, 08/14/2015 - 23:01

I entered the Hackaday Prize in 2014. I entered because Hackaday editor [Brian Benchoff] persuaded me to. I ran into Brian at the HOPE conference in NYC and he told me that there were about only 800 entries to compete against.

I didn’t enter until a day or two before the deadline, which is where we are today. The deadline for this year’s 2015 Hackaday Prize is on Monday. Again there are around 800 entries to compete against.

When I entered the competition last year I never dreamed that I’d be managing the same contest this year. I didn’t know much about contests, and I certainly never thought that the odds of winning anything were very good. It is very easy to talk yourself into thinking that everyone else’s project has a better chance of winning.

So now that I’m working in it, I see all of the entries every day, I talk to all of you daily about your projects (which is an awesome part of my life, thank you!) and I can tell you that everyone else’s project does not have a better chance of winning than yours.

Best Product Has Crazy Good Odds

New to the 2015 Hackaday Prize we added a Best Product category. The Best Product is meant to encourage that small window of opportunity between project prototype and product. We ask that products entered into this category get 3 copies of that product to us before we close entries on Monday. Three copies means that you can duplicate your product, but you still may not yet be in a place where you can turn that into a company.

The crazy thing is that we haven’t received so many entries for this, and the prize for Best Product, besides keeping you in the running for the main Hackaday Prize, is $100,000 and 6 months free rent in the Supplyframe Design Lab. This is a recipe for a successful business start.

The odds are insanely good this time around. For Best Product so far, we’ve got under 100 entries. This means you have a 1 in under 100 chance of winning $100,000. For the main Hackaday Prize, we’ve got under 1000 entries and 5 prizes, so you have a 5 in 1000 chance of winning some portion of $500,000 in cash or prizes.

How do you make sure you’re actually in the running?  You complete the requirements! Make your project logs, your cell phone video and your system diagram. You can do this in under a day, so make it happen!

Read the Official Rules Here

Why Enter?

Last year’s Hackaday Prize theme was to “design a connected device” so we upped the bar a little this year. Actually, we upped the bar a lot with a theme of “design a solution to an important problem”. We want you to come up with ideas that have the potential to help a lot of people. We want you to not only think about winning money and trips to space, but to think about others. We gave away stuff — lots of stuff — during the contest to encourage those ideas. I think we all won with that.

We started Hack Chats weekly for the past couple of months and I’ve seen people get job offers, collaborate and start new projects from those chats. So, come to the Hack Chats, get your Prize entries in and use your smarts to effect change!

Filed under: The Hackaday Prize

Octopart and Altium Join Forces

ศุกร์, 08/14/2015 - 22:01

Octopart, the search engine for electronic parts, is now a wholly owned subsidiary of Altium.

This acquisition is neither Altium’s first parts database purchase, nor is it Octopart’s first interaction with Altium. Ciiva, a parts and datasheet search engine was acquired by Altium a few years ago, and Altium Circuit Maker features an interface to the Octopart database.

Under the deal, Octopart will remain remain independent of Altium and operate out of their NYC office, and plans are for the part search engine to remain free and open.

Disclosure: Hackaday’s parent company, Supplyframe, also runs FindChips.com and Parts.io, component search tools.

Filed under: news

Where Are They Now: Terrible Kickstarters

ศุกร์, 08/14/2015 - 21:01

Kickstarter started out as a platform for group buys, low-volume manufacturing, and a place to fund projects that would otherwise go unfinished. It would be naive of anyone to think this would last forever, and since these humble beginnings, we’re well into Peak Kickstarter. Now, Kickstarter, Indiegogo, and every other crowdfunding platform is just another mouthpiece for product launches, and just another strategy for anyone who needs or wants money, but has never heard of a business loan.

Of course there will be some shady businesses trying to cash in on the Kickstarter craze, and over the last few years we’ve done our best to point out the bad ones. Finding every terrible Kickstarter is several full-time jobs, but we’ve done our best to weed out these shining examples of the worst. Following up on these failed projects is something we have been neglecting, but no longer.

Below are some of the most outrageous Kickstarters and crowdfunding campaigns we’ve run across, and the current status of these failed entrepreneurial endeavors.


A comparison between the first design images for SOAP (left) and [Bunnie]’s Novena laptop (right)It’s not just the springboard for [Billy Crystal]’s career; the Soap Home Automation Router promised to be one of the most capable WiFi routers in existence. With a touchscreen display, every radio imaginable, and a very powerful iMX6 CPU, this is the router that could do everything. Shortly after the launch of the Kickstarter, things started to fall apart. The first design illustrations for the Soap router were actually not of a new device, but lifted directly from the drawings of [bunnie]’s Novena laptop project. Furthermore, it turned out the iMX6 CPU couldn’t do Gigabit Ethernet. It was a mess, a project that launched about six months too early, and a project that was doomed to failure.

Shortly after the Soap router was exposed, I managed to get an interview with the creators, and things actually looked positive for a while. They hired an engineering team, refined their project goals, moved from a completely custom PCB to a System on Module, and generally made the campaign sane. It got worse from there.

SOAP collected $142,112 from their Kickstarter campaign and another $260,079 from an Indiegogo campaign. They made it out to CES early this year after one of the founders picked up a very nice ride. After that, SOAP put out a press release via a Kickstarter update with a tale of prescription drug addiction, skipping the country, and then finally creating one of the most advanced home routers in existence.

SOAP is dead, it’s not going to be released, and backers on Kickstarter and Indiegogo are requesting a refund.

The Batteriser Discharge curves, courtesy of Dave Jones’ debunking

Ahh, the Batteriser. This tiny metal clip fits over AA, AAA, C, and D cells to extend the battery life of your electronic devices by up to 800%. How does it work? There’s a small boost converter tucked into this metal clip that draws all the power out of a battery. It’s complete hogwash, as [Dave Jones] demonstrates most electronic devices already suck all the electrons out of a battery. Oh and, one of the failure modes for the Batteriser is fire, which is great if your design goal is to make a terrible product.

Since its launch, the folks behind the Batteriser have suffered the slings and arrows of people who know their stuff, forcing them to take to social media to defend themselves: “Batteriser proves to be effective on new devices! Here is a test we did with a new apple blue tooth keyboard“, says one post, demonstrating that just like their batteries, the Batteriser people only use 10% of their brains.

[Dave Jones] has since jumped on the Batteriser with the tenacity shown in his Solar Roadways teardown and has already posted a lot on the subject. Unfortunately, the Batteriser campaign is still ongoing, and this campaign will succeed. At least we got some great videos about testing battery discharge for our trouble.

Lix, The USB Powered 3D Printing Pen Lix, the 3D printing pen that defies the laws of thermodynamics

There have been a number of 3D printing pens that have come on the market in the last few years, and for the most part they’re interesting tools. They’re not quite as cool as putting plastic filament in a Dremel and performing friction stir welding on your 3D printed parts, but these devices can be useful.

By far the sleekest 3D printer pen we’ve ever seen is the Lix. It’s barely larger than a normal 2D pen, and it’s conveniently powered by a USB port. When we called this pen out as being a scam, the reasoning was simple: you need a lot of power to melt filament at a reasonable rate, and Lix had a maximum power consumption that was about a third of what a 3D printer hot end sucks down.

The Lix Kickstarter had an initial delivery date of October, 2014. Now, in August 2015 the backers are going wild. Since then, a number of similar products have come on the market, including this little guy for $19. This is the challenge of backing unproven technology from someone who doesn’t know the relation between heat and power.

A Phone That Charges Itself A ptototype of the Nikola Labs cell phone case

A cell phone case that can recharge a cell phone using energy from a cell phone. Wait, what? It’s the Nikola Labs phone case, and it doesn’t make any sense at all.

The best analogy for this cell phone case is a solar-recharging flashlight, with the solar panel right in front of the bulb. Yes, it will recharge itself, but as any 12-year-old with two electric motors will tell you, perpetual motion is impossible and there’s no such thing as a free lunch. The Kickstarter campaign failed despite an incredible early PR push. In fact, this is one of the true failures of all the Kickstarters we’ve covered and debunked: it’s the only one featured in this post that did not meet its funding goal.

Why didn’t the Nikola Labs campaign not meet its goal? If you look at the comments for the campaign, it’s because the Nikola Labs team wasn’t responsive enough. Midway through the campaign, communication from the team stopped. Would it have succeeded if the team kept going? That’s anyone’s guess, but the low number of pledges through the middle to the end of the campaign could have picked up if the team produced any proof that the device worked.

Let that be a lesson: if you’re going to scam people on crowdfunding sites, you need to follow through with the campaign. If you’re playing a confidence game, you first have to believe in yourself.

Filed under: Crowd Funding, Featured, slider

Panel-Mounted Breadboard Accessories

ศุกร์, 08/14/2015 - 18:01

[Chuck Stephens] grew up with Radio Shack 100-in-1 electronic kits. The ones with lots of components and spring terminals that could be wired to be a radio, a burglar alarm, or whatever.[Chuck] graduated to solderless breadboard, but did miss having panel mounted components like pots and switches easily available. So he has been building his own accessory boxes.

Of course, it is easy enough to just connect breadboard wires to component, but [Chuck] went further than that. Using boxes of different types (including a cigar box), he mounted the components properly and also wired them to a breadboard for easy connection.

If you’ve ever tried to solder to breadboard springs (we have), you’ve found it is hard to get adhesion to the shiny metal. [Chuck] solved the problem by crimping little wire hooks to the springs. The result is a good looking and functional prototyping aid.

They do make tiny breadboard style contacts (called tie point blocks; good luck finding them) for this kind of application, but the crimp technique works on common breadboards. These are cheap and much easier to find.

Of course, these days, we are as likely to want to mount SMDs than panel mounted controls. Now if we could only figure out where to put the components. If you want something less involved, take a look at the video below.

Filed under: tool hacks

3D Printed Vice Holds Dev Boards Beside Breadboard

ศุกร์, 08/14/2015 - 15:01

The Stickvise has been a staple of the Hackaday community for a while now. If you need something held for soldering there’s no better low-cost helping hand. But if you’re just using a breadboard and a dev board of some sort, there’s another vice on the horizon that uses similar spring clamping to hold everything in place while you build something awesome.

While [Pat]’s inspiration came from the aforementioned Stickvise, the new 3d-printed vice is just what you’ll need before you’re ready to do the soldering. The vice is spring-loaded using rubber bands. The base is sized to fit a standard breadboard in the center with clamping arms on either side to hold dev boards such as an Arduino. This innovative yet simple de”vice” grips boards well enough that you won’t be chasing them around your desk, knocking wires out of place, anymore.

There are some nuances to this board, so be sure to check out the video below to see it in action. As we mentioned, it uses rubber bands instead of springs to keep it simple, and it has some shapes that are easily 3d printed such as the triangular rails. If you want to 3d print your own, the files you’ll need are available on the project’s site. If you want to get even simpler, we’ve seen a few other vices around here as well.

The Stickvise is available for sale in the Hackaday Store.

Filed under: tool hacks

Hackaday Prize Entry: A Sixth Sense

ศุกร์, 08/14/2015 - 12:00

There’s far more going on in the environment that humans have the senses to detect. Birds migrate with the help of the Earth’s magnetic field, and certain species of fish can detect electrical fields. For his Hackaday Prize entry, [Sebastian] is giving us a sixth sense. He’s building a device that allows anyone to detect the Earth’s magnetic field and find their way north for the summer.

The initial idea for [Sebastian]’s project came after his father’s inner ear was damaged. The doctor told him his brain needed to be trained to work with only one inner ear. If it works for balance, [Sebastian] wondered, why couldn’t the brain be trained to listen to an extra sensory input?

[Sebastian]’s device is an accelerometer and magnetometer, connected to a microcontroller that drives a few vibration motors. By mounting these motors around an ankle strap, [Sebastian] hopes to train his brain to listen to the magnetic fields.

So far, [Sebastian] has a device that can sense the Earth’s magnetic field and buzzes the motor closest to magnetic north. There’s still a lot of work to do, including filtering the magnetometer inputs, adding a ‘sleep’ mode, and putting Bluetooth functionality on board, but it’s already a very well-designed project.


The 2015 Hackaday Prize is sponsored by:
Filed under: The Hackaday Prize

Junked Inspection Camera Given 15-Year Face-lift with Raspberry Pi

ศุกร์, 08/14/2015 - 09:01

The nice thing with having a hacker cred is that family and friends are always on the lookout for stuff they think might be useful to you. [Craig Hollabaugh]’s son-in-law found an inspection camera and thought it would be handy for his hobby work. The MagniSight Explorer was first introduced in 2001. It is good for surface mount board work and inspection, except that its analog 480p video is quite dated by today’s standards. So [Craig] upgraded it for crystal clear 1080P/30 video and 5 megapixel images using a $35 Raspberry Pi 2 and a $26 Raspberry Pi Camera Module. After the upgrade, the unit is now a great tool for SMT rework.

There’s not a lot to the upgrade, but [Craig] gives a nice rundown in the 15 minute video of the MagniSight’s internals. He shows us the original analog camera module and its video card, which is able to do some additional processing like black and white output and reverse video (negative). As he mentions, it would be easy for him to do the same via software on the Raspberry Pi. A video camera lens takes care of magnification and two shafts coupled to it via flat belts (rubber bands?) take care of zoom and focus. A front coated mirror angled 45 degrees in front of the lens turns the optical path 90 degrees to allow the lens/camera to “look down”. After experimenting a bit to find the correct focal spot behind the lens unit for the Raspberry Pi camera, he covered the camera module with insulation tape and then just glued it to the old camera mount. After hooking it up to an HDMI monitor, the results are quite nice and he reckons he can easily work with components down to 0402 in size.

He’s got a couple of more upgrades in mind to make the system even better. He plans to replace the existing compact fluorescent lamps with a string of LED’s which will provide more uniform illumination. Plus, he can control their brightness, and selectively turn them on or off to get the optimum lighting. The other interesting upgrade would be to add stepper motors to the X-Y translation stage and automate their movement. After looking up a board file and its BoM, he may even be able to search for a part designator and move the stage to bring the part into focus.

Filed under: Raspberry Pi

Tricking a Car Stereo to Think Your Cellphone is a Tapedeck

ศุกร์, 08/14/2015 - 06:00

When you have an older vehicle there’s not a lot of options in the stock stereo department, often a CD player and tape deck is what you get. When you want to play your tunes from your mobile what do you do? Buying an adapter, or a new head unit for that matter, isn’t any fun. So why not hack it? This isn’t just a mechanical marriage of a Bluetooth dongle and an elderly stereo. Some real work went into convincing the stereo that the BT receiver was the stock tape deck.

Attacking the outdated Cassette deck [kolonelkadat] knew that inside the maze of gears and leavers, most of it is moving around actuating switches to let the radio know that there is a tape inside and that it can switch to that input and play. Tricking the radio into thinking there is a tape inserted is handled by an Arduino. Using a logic analyzer [kolonelkadat] figured out what logic signals the original unit put out and replicating that in his Arduino code.

Audio is handled by the guts of a bluetooth speaker with the output redirected into the radio where the signal coming off the tape head normally would have been directed. Join us after the break for a couple of videos with all of the details.

Filed under: Arduino Hacks, musical hacks, radio hacks

Crack Open a USB Car Charger to make it a Variable DC-DC Converter

ศุกร์, 08/14/2015 - 03:01

[Boolean90] hacked a cheap USB car charger into a variable power supply. His proof of concept is to use this as a variable-speed motor controller. The best part is that nothing is being abused, the regulator inside is still running within manufacturer’s spec.

While we’ve seen similar hacks before, [Boolean90]s video is pretty cool and provides a nice insight into the components used in these cheap devices. Rather than a linear regulator, which would dissipate too much heat the device uses a common jelybean MC34063A (PDF) switching DC-DC converter which costs about 10 cents on eBay (about two dollars for twenty, shipped). Here it’s used to step the car batteries 12 volts down to 5, but can also be used in step-up and inverting configurations.

Like all switching buck converters the MC34063A uses a PWM (pulse width modulated) signal to drive an inductor and capacitor, which effectively form an LC filter. By controlling the pulse width, the output voltage can be regulated. [Afrotechmods] has a great tutorial on the basic principle. The regulation is controlled by feedback resistors. [Boolean90] simply added a variable resistor to allow the output voltage to be controlled.

Neat hack [Boolean90]!

Filed under: classic hacks

Becoming a State Machine Design Mastermind

ศุกร์, 08/14/2015 - 00:01

Imagine a robot with an all-around bump sensor. The response to the bump sensor activating depends on the previous state of the robot. If it had been going forward, a bump will send it backwards and vice versa. This robot exhibits behavior that is easy to model as a state machine. That is, the outputs of the machine (motor drive) depend not only on the inputs (the bump sensor) but also on the current state of the machine (going forward or backward).

As state machines go, that’s not an especially complicated one. Many state machines have lots of states with complex conditions. For example, consider a phone switchboard. The reaction to a phone going off hook depends on the state of the line. If the state is ringing, picking up the phone makes a connection. If the state is idle, the phone gets a dial tone. The switchboard also has to have states for timeouts, connection failures, three way calling, and more.

If you master state machines your design and debug cycles will both move along faster. Part of this is understanding and part is knowing about the tools you can choose to use. I’ll cover both below.


You can implement a state machine in software or hardware. A software version of the robot state machine might look like this:

state = FORWARD; while (true) // do forever { if (bump) if (state==FORWARD) state=REVERSE; else state=FORWARD; if (state==FORWARD) move_forward(); else move_backward(); }

Another way to get the same effect is to write a program that reads the data from a table that matches input and current state to find the next state. For example:

table[0].current_state=FORWARD; table[0].bump_input=TRUE; table[0].next_state=REVERSE; table[1].current_state=REVERSE; table[1].bump_input=TRUE; table[1].next_state=FORWARD; Flip Flop Hardware

Hardware implementations use flip flops and there are at least two different ways to construct a state machine. Let’s make our robot a little smarter. Suppose you want the robot to go slowly each time it changes direction, but if it makes it through three loops (or clock cycles, if you prefer) without hitting something, the robot should speed up. There are several ways you could do this. It makes sense to use a counter, but that’s not the only way to set it up. Consider the following states:

  • Forward Slow (1)
  • Forward Slow (2)
  • Forward Slow (3)
  • Reverse Slow (1)
  • Reverse Slow (2)
  • Reverse Slow (3)
  • Forward
  • Reverse

The state diagram above is the customary way to think about and document state machines. I’ll tell you about the tool I used to create it shortly. Every state machine has a starting state (the one with the double ring). The circles are states and the arrows represent things that make a state transition to another state.

State Representation

In software, it makes sense to represent each state with a number (perhaps with a #define to make it easier to read) or an enumerated value. For a hardware design, you need to select a way to represent each state. The most obvious choice is to simply use a number stored in registers or flip flops. This is compact, but requires decoding each state using combinatorial logic (AND, OR, and INVERTER gates). If you aren’t careful, you may also trigger spurious states when multiple bits in the state representation change at one time. There’s no reason, of course, the states have to use sequential numbers, so you might select a gray code (where only one bit changes per state transition).

Even more extreme–but very common–is the one hot encoding method (PDF). Here, you use one flip flop per state so that only one flip flop is set at any given time. This requires an initialization to set the first state or special logic to allow state zero to be the starting state. However, it is fast and reduces decoding logic, so it is often used.

Moore vs Mealy

There are two common strategies for implementing hardware state machines: Moore machines and Mealy machines. A Moore machine creates outputs using only the state information. That means any unique set of outputs requires a separate state. For a one hot machine, our hypothetical robot needs 8 flip flops: two sets of 3 for the slow states and two more for the normal states.

In a Moore machine, the outputs (let’s say forward, reverse, and slow) will originate from some logic gates connected to the state machine output (an OR gate, for example, would generate the forward signal from any of the forward states).

The alternative is a Mealy machine. With a Mealy machine, the outputs can also depend on the inputs. This requires careful design because it can create output glitches as thing change. However, it does usually require fewer states since similar outputs are grouped.

In the case of our robot, imagine the drive system provides you with a number of steps taken at a given speed and direction. You receive 8 bits of input. The bits start at zero each time you change the motor direction or speed and counts up until it reaches the maximum count. You decide to stay in slow mode until the count reaches 100 in slow mode. Further, assume you have two outputs for each direction: forward slow, forward, reverse slow, and reverse.

A Moore machine would require hundreds of states if you did a naive implementation. With a Mealy machine, the outputs depend not only on the state, but the value of the drive counter. Of course, if the counter was part of the state machine, that would make it a Moore machine. In fact, you can always convert a Moore machine to a Mealy machine and vice versa.

The choice is usually pretty clear. If you are concerned about speed and the size of state representation, you want a Mealy machine. If you want no chance of output glitches, use a Moore machine.


In addition to selecting an encoding and a machine style, there are opportunities to minimize state machines by combining equivalent states, for example. This sounds easy, but it can get complicated rather quickly.

Luckily, there are automated tools (including the ones you use for FPGA development) that will minimize state machines. There are cases, though, where the smallest possible state machine leads to unwanted complexity in output decoding or other related logic.

A Practical Example

Consider a synchronous serial data stream (that is, a serial data stream with a clock). The data should have odd parity, meaning that if the data stream has an odd number of 1 bits, the parity bit is 0, otherwise the parity bit is 1. The count of 1 bits in the data stream along with the parity bit will always add up to an odd number. From a state machine perspective, this is fairly simple as shown in this diagram.

The reset state (thick blue line) assumes there are no one bits, or an even number, so the output is a 1 (so that there is an odd number). As long as zero bits arrive, the state remains unchanged. When a 1 bit appears, the state changes to odd and the output goes to zero. The machine stays in that state until it receives another 1 bit.

How would you implement something like this? Consider this state table:

Current State Input Next State 0 0 0 0 1 1 1 0 1 1 1 0

Does that look familiar? It should. This is exactly the truth table for an XOR gate. The output bits make it clear we can use one state variable (0=odd, 1=even). So here’s a simple implementation in logic:

Or if you prefer Verilog:

module parity(input reset, input clk, input data, output par); reg state; always @(posedge clk) begin if (reset) state<=1'b1; else state<=state^data; end endmodule;

Note the ^ character is Verilog (and C) for XOR.

Automating State Machine Development

There’s nothing to stop you from creating your own state machines in Verilog or VHDL, just like the parity bit example. However, there are some automation tools (ranging from free open source to very expensive) that let you describe the state machine as a table or state diagram and many will even generate the code for you.

One tool is Fizzim, which is open source and easy to use. It makes good looking diagrams (like the one above), so even if you don’t want to generate code, you may still want to check it out. Fizzim uses Java for the GUI, so it will run almost anywhere. It uses Perl as a backend code generator and, again, that’s pretty portable.

You don’t actually have to use the GUI, if you want to stick with manipulating text, but the GUI is handy. There are three object types: the state machine, states, and transitions. Each element can have attributes that describe different things for the back end Perl program.

The Fizzim tutorial is well worth reading even if you may not want to use Fizzim. In the course of showing the tool, they also cover practical nuances of state encoding, output generation, and coding state machines in Verilog. The latest version can also output VHDL.

Software Libraries

If you prefer to sling your state machines in software, there are a lot of options (if you don’t want to roll your own). The Boost libraries that are popular for C++ programmers are one option. There are even options for the Arduino. Java programmers have options, too.

There’s lots of other possibilities. If you like Web development, there’s a framework in JavaScript. There’s even a W3C draft for an XML standard to specify and execute state machines. Another tool of interest in the Ragel compiler, which can generate target code in a variety of languages.


Once you get used to thinking about state machines, you’ll see them everywhere. Robots, traffic lights, burglar alarms, and thermostats could use a state machine implementation. You can go overboard, of course. (The light switch has two states: on and off.) However, for moderately to very complex systems, state machines can be the way to go.

For simple machines, you may want to hack out your own custom implementation. However, if you can use existing software or hardware implementation tools, you’ll probably have a better experience.

Filed under: misc hacks

Your Homework for this Weekend

พฤ, 08/13/2015 - 22:31

Your homework for this weekend: Build me something and enter it in The Hackaday Prize. I’m not joking.

It’s very rare for me to come out with a big “ask”, but this is it. I need you now. The Hackaday Prize is our STEAM initiative. It very publicly shows that you can have a lot of fun with engineering in your free time. This is a lesson we need to broadcast and to do so, I want to see dozens of entries come together this weekend.

Here’s the gist of it: Choose a problem that is faced by a large number of people. Build something that helps fix it, and document what you did. You need to start a project, publish 4 project logs, a system design diagram, and a video of less than 2 minutes in length. That’s it, and you can easily be done with all of this if you choose to make this weekend a hackathon.

You may win, you may not. But everyone who posts a project is helping to inspire the next generation of great engineers. The next [Forrest Mims] is out there, lets make sure he or she knows how amazing the world of engineering is! Get to work.

The 2015 Hackaday Prize is sponsored by:


Filed under: The Hackaday Prize

Raspberry Pi and Windows 10 IoT Core: A Huge Letdown

พฤ, 08/13/2015 - 21:01

Last Spring, Microsoft unveiled their plan for Windows and the Internet of Things. It starts with the Raspberry Pi and Windows 10 IoT Core – a stripped down system with Windows API calls running on an ARM architecture. Yes, Microsoft is finally moving away from the desktop, building a platform for a billion Internet of Things things, or filling the gap left by tens of thousands of POS terminals and ATMs running XP being taken offline. Either one is accurate.

Earlier this week, Microsoft announced the first public release of Windows 10 IoT Core. This is the review, but here’s the takeaway: run. Run as fast as you can away from Windows IoT. It’s not worth your time unless you have a burning desire to write apps for Windows, and even then you could do a better job with less effort with any Linux distro.

When Windows 10 IoT was first announced, there was great hope for a Windows RT-like experience. Being able to run real Windows applications on a Raspberry Pi would be a killer feature, and putting Skype on a Pi would mean real Jetsons-style video phones appearing in short order.

Windows 10 IoT core isn’t so much an operating system, as it is a device that will run apps written with Windows APIs: there is no shell. If you want to control dozens or hundreds of devices, each running a program written in Visual Basic, JavaScript, C#, or Python, this is for you.

The majority of interaction with Windows 10 IoT Core is over the web. After booting and pointing a browser to the Pi, you’re presented with a rather complete web-based interface. Here, you can check out what devices are connected to the Pi, look at the running processes, and run new apps. Think of this feature as a web-based Windows control panel.

While Windows 10 IoT uses the HDMI output on the Pi, this is merely informational, the video output capabilities of the Pi reserved for application-specific displays – digital signage, POS terminals and ATMs are where Windows 10 IoT Core excels. For general-purpose computing, you’re better off looking elsewhere.


Officially, the only way to install Windows 10 IoT Core is with a computer running Windows 10. There are a few ways around this is with the ffu2img project on GitHub. This Python script takes the special Microsoft .FFU image file format and turns it into an .IMG file that can be used with dd under *nix and Win32DiskImager on Windows.

Yes, Windows 10 is free for everyone with a relatively modern Windows box, but since the only requirement for running Windows 10 IoT core is putting an image on an SD card and monitoring a swarm of IoT Core devices, there is no reason why this OS can’t be supplied in an .IMG file.

After putting the image on an SD card, installing Windows 10 IoT Core is as simple as any other Raspi distro: shove the card in the Pi, connect an Ethernet cable, and give it some power. No, you don’t need a keyboard or mouse; there’s very little you can actually do with the Pi. In fact, the only thing that is displayed through the Pi’s HDMI port is a screen giving you the IP address and what USB devices are attached.

The totality of the Windows 10 IoT Core experience

You do get a few options for language and network settings, and there are a few tutorials and examples – connecting to Visual Studio and blinking an LED – but that’s it. The base user experience of Windows 10 IoT Core is just network information, a device name, and a picture of a Raspberry Pi.

There are a few shortcomings of the Windows 10 IoT core for the Raspberry Pi. Officially, the only supported WiFi module is the official Raspberry Pi WiFi module with a BCM43143 chipset. By far, the most popular WiFi module used for the Raspberry Pi (and something you should always carry around in your go-bag) is the Edimax EW-7811Un, a tiny WiFi module that uses a Realtek chipset. Odds are, if you have a Raspberry Pi 2, that WiFi module you picked up won’t work. Common sense would dictate that you could install the Windows driver for the Realtek chipset, but this is not the case; no Windows driver will ever work with Windows 10 IoT core. Even devices from the Raspberry Pi foundation, like the Raspberry Pi camera, are not supported by IoT core

If you’ve ever wanted clearer evidence the Windows 10 IoT core is not meant to be an extensible system like every other Linux-based single board computer, you need only look a little deeper. Digital audio is completely ignored, and pins 8 and 10 – normally reserved for a 3.3V UART on every other Raspberry Pi distribution – are reserved pins. Microsoft managed to make a single board computer without a hardware UART.

Fortunately, some of these problems are temporary. A representative from the Windows On Devices team told us more WiFi dongles will be supported in the future; the only driver they were able to bring up in time is the official dongle from the Raspberry Pi foundation. A similar situation of engineering tradeoffs is the reason for the lack of UART support.

Who is this for, exactly?

The idea that Microsoft would put out a non-operating system without support for the de facto standard WiFi adapter, a hardware UART, or drivers for the majority of peripherals is one thing. Selling this to the ‘maker movement’ strains credulity. There is another explanation.

The Windows 10 IoT Core Watcher, the remote admin app for multitudes of Pis.

Let’s go over once again what Windows 10 IoT Core actually is. By design, you can write programs in Visual Studio and upload them to one or many devices running IoT core. These programs can have a familiar-looking GUI, and are actually pretty easy to build given 20+ years of Windows framework development. This is not a device for makers, this is a device for point of sale terminals and ATMs. Windows XP – the operating system that is still deployed on a frighting number of ATMs – is going away soon, and this is Microsoft’s attempt to save their share of that market. IoT Core isn’t for you, it isn’t for me, and it isn’t for the 9-year-old that wants to blink an LED. This is an OS for companies that need to replace thousands of systems still running XP Embedded and need Windows APIs in kiosks and terminals.

Save your SD card

For anyone with a Raspberry Pi 2 and an SD card, the only investment you’ll make in trying out Windows 10 IoT Core is your time. It’s not worth it.

While Windows 10 IoT Core is great for any company that has a lot of Visual Basic and other engineering debt, it’s not meant for hackers, makers, or anyone building something new. For that, there are dozens of choices if you want an Internet-connected box that can be programmed and updated remotely. The Cloud9 IDE for the Pi and BeagleBone allow you to write code on single board computers without forcing you to install Visual Studio, and Linux is king for managing dozens or hundreds of boxes over the Internet.

This is not an OS that replaces everything out there. A Linux system will almost always have better hardware support, and this is especially true on embedded devices. Windows 10 IoT Core is a beginning, and should be viewed as such. It’s there for those who want it, but for everyone else any one of a dozen Linux distributions will be better.

Filed under: Featured, Raspberry Pi

Arduino Powered Rubber Band Sentry Turret Is Not a Lie

พฤ, 08/13/2015 - 18:00

You know that guy in the next cube is sneaking in when you are away and swiping packs of astronaut ice cream out of your desk. Thanks to [Kevin Thomas], if you have an Arduino and a 3D printer, you can build a rubber band sentry gun to protect your geeky comestibles. You’ll also need some metric hardware, an Arduino Uno, and a handful of servo motors.

The video shows [Kevin] manually aiming the gun, but the software can operate the gun autonomously, if you add some sensors to the hardware.  The build details are a bit sparse, but there is a bill of material and that, combined with the 3D printing files and the videos, should allow you to figure it out.

We couldn’t help but wish for a first person view (FPV) camera and control via a cell phone, so you could snipe at those ice cream thieves while hiding in the broom closet. On the other hand, if you got the gun working, adding the remote wouldn’t be hard at all. You probably have a WiFi FPV camera on your quadcopter that finally came out of that tree and there’s lots of ways to do the controls via Bluetooth or WiFi.

Not that you don’t have options. But here at Hackaday HQ, we have lots of rubber bands and not so many green pigs. If you’d rather shoot paintballs, be careful you don’t accidentally repaint the insides of your cube.

Filed under: 3d Printer hacks, Arduino Hacks, weapons hacks

Raspberry Pi Field Unit (RPFU)

พฤ, 08/13/2015 - 15:01

Raspberry Pis are great for tons of projects, but if you want to use them outside, you’re going to need a waterproof enclosure. Not happy with what was available, [Jay Doscher] went all out and created the Raspberry Pi Field Unit — a piece of tech that looks straight out of the Call of Duty franchise.

Wanting it to be extra durable, [Jay] started with a Pelican Case 1300 — the standard in electronics protection. These come with a Pelican panel mount, so he had some plastic laser cut specifically to fit the panel mount, and attach all of his components. Speaking of components, he got only the best — inside is:

  • A Raspberry Pi 2 with a few PIHATs (permanent prototyping shield)
  • A 10.1″ IPS display
  • A high power wireless USB dongle
  • Weather proof USB and LAN connectors
  • An RTC for when it’s off the network
  • A 12V power supply for running off solar panels
  • DC-to-DC adapters to bring it down to 5V
  • A whole bunch of hardware from McMaster-Carr

He has a great write-up over on his blog, and a fantastic section on lesson’s learned during the build. If you’re looking to do anything even remotely similar, it’s worth a read.

For a smaller outdoor case idea, SnoTunes is the perfect way to use a Raspberry Pi for an outdoor snowboarding music setup!

Filed under: Raspberry Pi

Hackaday Prize Entry: Homebrew Smartwatches

พฤ, 08/13/2015 - 12:00

The Pebble Smartwatch has been around for years, and the introduction of the Apple Watch has everyone looking at wrist-mounted computing as the newest gadget consumers can glom onto. There was never any doubt the 2015 Hackaday Prize would have more than a few smartwatches.

[Ramon]’s Zerowatch gets its name from the Arduino Zero, as this watch is based off of and completely compatible with the Arduino Zero. With a 48 MHz ARM Cortex M0+, a three-axis accelrometer, a microSD card slot, and a bright OLED display, this is an extremely capable wrist-mounted computer. As with all wearable electronics, the enclosure makes or breaks the entire device, and [Ramon] has a very slick 3D printed case for this watch.

Connectivity is important for smartwatches, and that’s something [Montassar]’s Open Source Smart Watch doesn’t skimp out on. He’s using an STM32F4 as the main controller and a 1.44″ TFT, and adding the standard Bluetooth module — an HC-05 — to the mix. [Montasar]’s project is also tackling connectivity by working on a few Android apps that connect directly to this phone. He’s using the MIT App Inventor to speed up development for these phone apps, and makes custom smartwatch apps a breeze.

Both are great projects, and thanks to free, open source, and easy to use tool chains, both projects are excellent examples of open hardware development and a great entry to The Hackaday Prize.

The 2015 Hackaday Prize is sponsored by:
Filed under: The Hackaday Prize

Jellyfish Inspired LED Skirt for Burning Man

พฤ, 08/13/2015 - 09:01

[Lumilectric] is getting ready for Burning Man and made herself this fantastic fiber optic LED skirt.

She’s always been fascinated by fiber optics and the effect they create, so she wanted to try using them in a project, and this was just the ticket. The tricky part was figuring out how best to couple cheap fiber optic strands off eBay with a strip of RGB LEDs.

In the end she figured out a way to make rudimentary fiber optic coupling joints using vinyl tubing. She managed to fit 17 strands of 0.5mm diameter fiber into a 6mm diameter vinyl tube. To improve light transfer when it’s all together, you can gently melt the ends of the fiber optics together to glaze the plastic into a single clear surface — don’t melt the vinyl though!

In total she created 42 sets of fiber optic bundles which she glued to an RGB light strip that she turned into a belt. One battery pack and microcontroller later and she had a fully functioning, glowing, Jellyfish skirt.

Will LEDs become a staple in future clothing design? Who knows, but until then, they’re pretty cool! Glow sticks at a concert? Nah, glow yourself at the concert!

Filed under: led hacks, wearable hacks

It’s Time to Roll Your Own Smartwatch

พฤ, 08/13/2015 - 06:01

Giant wristwatches are so hot right now. This is a good thing, because it means they’re available at many price points. Aim just low enough on the scale and you can have a pre-constructed chassis for building your own smartwatch. That’s exactly what [benhur] did, combining a GY-87 10-DOF module, an I²C OLED display, and an Arduino Pro Mini.

The watch uses one button to cycle through its different modes. Date and time are up first, naturally. The next screen shows the current temperature, altitude, and barometric pressure. Compass mode is after that, and then a readout showing your step count and kilocalories burned.

In previous iterations, the watch communicated over Bluetooth to Windows Phone, but it drew too much power. With each new hardware rev, [benhur] made significant strides in battery life, going from one hour to fourteen to a full twenty-fours.

Take the full tour of [benhur]’s smartwatch after the break. He’s open to ideas for the next generation, so share your insight with him in the comments. We’d like to see some kind of feedback system that tells us when we’ve been pounding away at the Model M for too long. 

[via Embedded Lab]

Filed under: Arduino Hacks, wearable hacks

I2C Bus Splitting with a more Professional Touch

พฤ, 08/13/2015 - 03:00

Last week, I covered some of the bitter details of an interesting hack that lets us split up the I²C clock line into multiple outputs with a demultiplexer, effectively giving us “Chip Selects” for devices with the same address.

This week, I figured it’d be best to layout a slightly more practical method for solving the same problem of talking to I²C devices that each have the same address.

I actually had a great collection of comments mention the same family of chips I’m using to tackle this issue, and I’m glad that we’re jumping off the same lead as we explore the design space.

Recalling the Work of Our Predecessors

Before figuring out a clever way of hacking together our own solution, it’s best to see if someone before us has already gone through all of the trouble to solve that problem. In this case–we’re in luck–so much that the exact bus-splitting behavior we want is embedded into a discrete IC, known as the PCA9547.

It’s worth remembering that our predecessors have labored tirelessly to create such a commodity piece of silicon.

The PCA9547 (PDF) is an octal, I²C bus multiplexer, and I daresay, it’s probably the most practical solution for this scenario. Not only does the chip provide 8 separate buses, up to seven more additional PCA9547s can be connected to enable communication with up to 64 identical devices! What’s more, the PCA9547 comes with the additional benefit of being compatible with both 3.3V and 5V logic-level devices on separate buses. Finally, as opposed to last week’s “hack,” each bus is bidirectional, which means the PCA9547 is fully compliant with the I²C spec.

Selecting one of the eight I²C buses is done via a transfer on the I²C bus itself. It’s worth mentioning that this method does introduce a small amount of latency compared to the previous clock-splitter solution from last week. Nevertheless, if you’re planning to read multiple devices sequentially from a single bus anyway, then getting as close-as-possible to a simultaneous read/write from each device isn’t likely a constraint on your system.


With a breakout board to expose the pads, I mocked up a quick-n-dirty Arduino Library to get the conversation started and duplicated last week’s demo.

Happily enough, with a single function to change the bus address, the PCA9547 is pretty much a drop-in solution that “just works.” It’s definitely reassuring that we can stand on the shoulders of our chip designers to get the job done quickly. (They’ve also likely done quite a bit more testing to ensure their device performs as promised.) Just like last week, feel free to check out the demo source code up on Github.

Until next time–cheers!

Filed under: Hackaday Columns, parts

Amazon Dash: Hack It to Run Your Own Code

พฤ, 08/13/2015 - 00:00

The Amazon Dash is a $5 push-to-buy-cat-litter button which has excellent potential for repurposing, but you need to know what is going on inside first. [Tony Dicola] has the details in this excellent bare metal guide to the Dash. In this, he covers how to get inside the Dash and reprogram it to do something more interesting than buying cat litter.

He first cracks the device open, connecting a programmer, then building a toolchain to compile programs to run on. This isn’t for the faint-hearted because you are programming directly for a device that wasn’t really built for it, but [Tony] has posted examples and there are few tools to hold your hand on the way. There is a safety net, [Tony] provided details on how to reset the Amazon Dash Button if you manage to brick it.

We have seen some interesting hacks that repurpose the Dash to capture your child’s bowel movements by intercepting the device connecting to WiFi, but this guide takes it a step further. It allows you to run your own code, which turns this into a really low-cost and well-engineered all-in-one WiFi device. The missing piece is proof-of-concept code to run the WiFi module inside. If you’re working on that we’d love to hear about it!

Filed under: internet hacks

Tonight is Hacker Chat with the Hackaday Writing Crew

พุธ, 08/12/2015 - 22:31

Tonight at 6pm PDT (UTC-7) is that last Hacker Chat before the entry deadline for the 2015 Hackaday Prize. Join us to talk about all things hardware. Those who need last-minute advice, or are looking for team members for an epic weekend hackathon to bootstrap your winning entry, this is the place to find it. It’s worth entering something… we’re giving everyone with an entry a limited-edition shirt.. and a well executed idea just might get you to the next round!

Joining [Brian Benchoff], [Adam Fabio], and me for tonight’s festivities are [Richard Baguley], [Kevin Dady] (aka [Osgeld]), [Bil Herd], [Kristina Panos], and [Al Williams]. We run these things a bit like the wild-west. There is just a bit of structure, but mostly anything goes. As far as the structure, add your project to this sheet if you want it to be one of the discussion topics. Other than that, share your knowledge and opinions while being excellent to each other. See you this evening!

The 2015 Hackaday Prize is sponsored by:
Filed under: Hackaday Columns, The Hackaday Prize