Skills

356 Articles

Drawbacks Of Laser Cut Delrin–and How To Slip Around Them

September 22, 2015 by 34 Comments

Welcome back to part II in this ensemble of techniques with laser-cut Delrin. Thanks for many of the great insights along the way in the comments. In this guide, I’d like to go over some of the more immediate kinks that come to mind when getting started with this material.

Sourcing Delrin Sheets

When it comes to shopping, there are a variety of suppliers to choose from, but there are a few key words and thoughts to keep in mind.

Names

First, Delrin, is the “brand name” that refers to the Acetal homopolymer. Variants may also be labeled, acetal or acetal homopolymer. Delrin’s natural color is a soft white, but dyes can take it into a range of other colors. Black and white are, by far, the most common, though.

Tolerances

In the previous guide, all of the examples were cut from a small range of sheet thicknesses (0.0625[in], 0.09375[in], and .125[in]) sourced from OnlineMetals. As the thickness of the sheet increases, the tolerances on the thickness rating will also become more loose. You might buy a .125[in] plate and find it to be .124[in] in some places and .126[in] in others. If you purchase a .250[in] sheet, however, you’ll find that it may vary as much as .126[in] oversize though!

Buy it Flat

Despite McMaster-Carr being my go-to solution for one-off prototypes where rapid build iterations trump BOM cost, I don’t recommend purchasing Delrin from them as their sheets don’t have a flatness rating and often gets shipped bent in (oddly sized) boxes. (Seriously, has anyone else gotten a few oddly-sized parts in a gigantic McMaster-box before?)

Internal Stresses

Extruded Delrin has internal stresses built up inside of the sheet. There are a variety of reasons why this could be the case, but my biggest hunch is that the extrusion process at the factory results in different parts of the sheets solidifying at different times as the sheet cools, possibly causing some parts of the sheet to tighten from the cooling before other gooier sections have yet to finish cooling. What this means for you is that as your part gets lased out of the sheet, you’re, in a sense, relieving that stress. As a result, the part that you cut–especially for thin sheets–may come out of the laser cutter slightly warped.

Continue reading “Drawbacks Of Laser Cut Delrin–and How To Slip Around Them” →

Embed With Elliot: Interrupts, The Good…

September 18, 2015 by 32 Comments

What’s the biggest difference between writing code for your big computer and a microcontroller? OK, the memory and limited resources, sure. But we were thinking more about the need to directly interface with hardware. And for that purpose, one of the most useful, and naturally also dangerous, tools in your embedded toolchest is the interrupt.

Interrupts do exactly what it sounds like they do — they interrupt the normal flow of your program’s operation when something happens — and run another chunk of code (an interrupt service routine, or ISR) instead. When the ISR is done, the microcontroller picks up exactly where it left off in your main flow.

Say you’ve tied your microcontroller to an accelerometer, and that accelerometer has a “data ready” pin that is set high when it has a new sample ready to read. You can wire that pin to an input on the microcontroller that’s interrupt-capable, write an ISR to handle the accelerometer data, and configure the microcontroller’s interrupt system to run that code when the accelerometer has new data ready. And from then on everything accelerometer-related happens automagically! (In theory.)

This is the first part of a three-part series: Interrupts, the Good, the Bad, and the Ugly. In this column, we’ll focus on how interrupts work and how to get the most out of them: The Good. The second column will deal with the hazards of heavyweight interrupt routines, priority mismatches, and main loop starvation: the Bad side of interrupts. Finally, we’ll cover some of the downright tricky bugs that can crop up when using interrupts, mainly due to a failure of atomicity, that can result in logical failures and corrupted data; that’s certainly Ugly.

Continue reading “Embed With Elliot: Interrupts, The Good…” →

Learn And Build A High Side Switch

September 16, 2015 by 75 Comments

As electronics engineer I have a mental collection of circuits that I’ve gathered over the years, much like a mechanic collects specialized tools as they work. All engineers do this and the tools in their tool boxes usually represent their project history and breadth.

A useful circuit to have in designer’s toolbox is the “high side switch”. Like it sounds, this is a circuit that switches the “high side” or positive voltage to a load.

We usually tend to switch things to ground as seen by outputs such as an Open Collector output, the reason being that ground usually is a known entity and is usually low impedance and is at a known voltage. But there are advantages to using a high-side switch in your circuits.

Continue reading “Learn And Build A High Side Switch” →

How To Build A Pocket-Sized MBed Signal Generator

September 15, 2015 by 13 Comments

Last month, I talked about how to get started with mBed and ARM processors using a very inexpensive development board. I wanted to revisit mBed, though, and show something with a little more substance. In particular, I often have a need for a simple and portable waveform generator. It doesn’t have to be too fancy or meet the same specs as some of the lab gear I have, but it should be easy to carry, power off USB, and work by itself when required.

My requirements mean I needed a slightly more capable board. In particular, I picked up a K64F board. This is very similar to the KL25Z board but has a bit more of everything–speed, memory, etc. What I really wanted, though, was the SD card slot. I did, however, do my early testing on a KL25Z, so if you have one, you can still work through the code, although standalone operation won’t be possible. The price jumps from $13 to $35, but you get a lot more capability for the price.

Continue reading “How To Build A Pocket-Sized MBed Signal Generator” →

Logic Noise: Playing In Tune With An Exponential VCO

September 11, 2015 by 19 Comments

Last session, we use the cheap and cheerful 4046 Phase-locked Loop chip as a simple voltage-controlled oscillator (VCO). It was dead simple, in fact, because the chip has a VCO already built in. There’s one big drawback of the 4046’s VCO; the pitch changes linearly with the control voltage. Ideally, as we’ll discuss in the next sections, we’d like the frequency to be an exponential function of the control voltage (CV), and that’s going to mean a little bit of analog circuitry.

René Schmitz has a fantastic exponential VCO design that’s almost a perfect fit for the Logic Noise series — it’s built with a minimum of parts, it’s a little bit rough around the edges, and at its core is a 4000-series CMOS chip that’s normally used for digital logic applications. The only drawback, from our perspective, is that it uses a dual (positive and negative) power supply. We’ll hack our way around that, and ignore some of René’s otherwise worthwhile refinements in the name of doing something truly quick and dirty. We’ll get 95% of the results with 70% of the work, although it’s easy enough to add on the rest if it strikes your fancy.

Continue reading “Logic Noise: Playing In Tune With An Exponential VCO” →

Want A Low-cost ARM Platform? Grab A Prepaid Android Phone!

September 10, 2015 by 113 Comments

What would you pay for a 1.2Ghz dual-core ARM computer with 1GB RAM, 4GB onboard flash, 800×600 display, and 5 megapixel camera? Did we mention it also has WiFi, Bluetooth, and is a low power design, including a lithium battery which will run it for hours? Does $15 sound low enough? That’s what you can pay these days for an Android cell phone. The relentless march of economies of scale has finally given us cheap phones with great specs. These are prepaid “burner” phones, sold by carriers as a loss leader. Costs are recouped in the cellular plan, but that only happens if the buyer activates said plan. Unlike regular cell phones, you aren’t bound by a contract to activate the phone. That means you get all those features for $15-$20, depending on where you buy it.

android-logo-transparent-backgroundThe specs I’m quoting come from the LG Optimus Exceed 2, which is currently available from Amazon in the USA for $20. The same package has been available for as little as $10 from retail stores in recent weeks. The Exceed 2 is just one of several low-cost Android prepaid phones on the market now, and undoubtedly the list will change. How to keep up with the current deals? We found an unlikely place. Perk farmers. Perk is one of those “We pay you to watch advertisements” companies. We’re sure some people actually watch the ads, but most set up “farms” of drone phones which churn through the videos. The drones earn the farmer points which can be converted to cash. How does this all help us? In order to handle streaming video, Perk farmers want the most powerful phones they can get for the lowest investment. Subreddits like /r/perktv have weekly “best deals” posts covering prepaid phones. There are also tutorials on rooting and debloating current popular phones like the Whirl 2 and the Exceed 2.

Continue reading “Want A Low-cost ARM Platform? Grab A Prepaid Android Phone!” →

Embed With Elliot: Practical State Machines

September 4, 2015 by 41 Comments

Raindrops on roses, and whiskers on kittens. They’re ok, but state machines are absolutely on our short list of favorite things.

There are probably as many ways to implement a state machine as there are programmers. These range from the terribly complex, one-size-fits-all frameworks down to simply writing a single switch...case block. The frameworks end up being a little bit of a black box, especially if you’re just starting out, while the switch...case versions are very easy to grok, but they don’t really help you write clear, structured code.

In this extra-long edition of Embed with Elliot, we’ll try to bridge the middle ground, demonstrating a couple of state machines with an emphasis on practical coding. We’ll work through a couple of examples of the different ways that they can be implemented in code. Along the way, we’ll Goldilocks solution for a particular application I had, controlling a popcorn popper that had been hacked into a coffee roaster. Hope you enjoy.

Continue reading “Embed With Elliot: Practical State Machines” →