Eternal free-swinging pendulum part 3 – physics and uC pins

without comments

This is the third post in the series about our first kit project. See the page about the project for the whole story.

With the schematics ready, with some kind of a prototype board assembled, the next step is to check if it would be possible to detect the magnet at all with my setup. After all, the currents and voltages involved would be really small – you have to have a lot of wire in a coil and huge powerful magnets almost touching it to get something easy to detect, and that’s out of the question here. So, I took some coils that I had around – scavenged from old hard drives, some toys, broken electronic devices, etc. Some of them had a core that strongly attracted to the magnet, so that refused to swing. A few had no core at all (so called air-core), so I tried them. Most of them were mounted in some plastic case with pins that go into holes in a PCB – and, surprisingly enough, often these pins were made from something magnetic – not an honest copper wire! Well, I guess, economics dictates cutting costs where it’s possible…

That left me with only a few coils that were not magnetic on their own. I put them on a table, attached their ends to a multimeter (measuring voltage), and swung a small strong magnet over them. Wow – there is some signal! A small one, a few millivolts at best, but it’s there. Let’s see: the ADC in the microcontroller has internal voltage reference of 2.56V, its theoretical best resolution is 10 bits (so, 1024 levels), 2.56/1024=0.0025V. In theory I could detect a signal from the coil as small as 0.25mV. In reality it would probably be impossible or very difficult: too much noise, extra filtering would be required everywhere.

Fortunately, I don’t need this kind of precision. I could even set up the ADC with 8 bits, so each step would be about 1mV. My coils would give me only a few millivolts, but that’s definitely a non-zero signal. By the way, the more turns the coil has – the higher would be the resulting current and voltage, so selecting a coil with more turns definitely helps. There are cheap and easily available microcontrollers with built-in amplifiers, so if I need to I could always amplify the signal 10, or maybe even 200 times – but, once again, that’s an option that could save the project if it won’t work with initial setup – not something that I really have to do from the start.

The top graph in this picture shows what happens when the magnet flies across the coil. First some voltage appears in one direction, then it falls to zero and reverses, finally falling back to zero as the magnet flies away.

Next – assuming I could detect the magnet in time – I’ll have to push it (after some small delay as shown on the second graph). For that the coil has to have certain properties. I’m going to switch the microcontroller pin attached to one side to +5V, and to have the current flow I’ll also switch the opposite side to ground (0V). If the coil would conduct “too well” (after all, it’s simply a piece of wire) I’ll have a short circuit here and there is a danger of burning out the pins. They could provide about 25mA, at most – for short periods of time – about 40mA.

The coil as an inductor has a nice property – it resists the changes in current, so even if we put some voltage across it, the current would not jump to its final value instantly. It will climb relatively slowly (depending on the coil inductance), while the magnetic field absorbs the energy and grows (and pushes the magnet away!), as shown on the third graph above. So, once again, in theory, if I use only very short voltage pulses, any coil is sort of safe, but in practice its inductance is small enough, and I would probably want to hold the current long enough to push the magnet strongly, so this effect won’t help much. I’ll need to protect the pins in some other way then.

The easiest way to limit the current is to add a series resistor. The power supply provides 5V, and we could go as high as 40mA, so 5/0.04=125 Ohm. That’s the absolute minimal total resistance of the coil and our additional resistor. I had a few coils wound with different wire gauges, a few of them had high enough resistance as is (about 200-300 Ohm), but others, with thicker wire and fewer turns, needed about 100 Ohm resistor in series. Obviously, the more turns of wire there is in a coil – the better would be its inductance given the same current flowing through it, so ideal coil here should have a lot of turns – and to keep it small it will have to be wound with very thin wire, so its resistance will be high (generally a bad thing, of course – any resistance produces heat losses, but in this case it will be gentle to the microcontroller pins). Still, some of the coils that required external resistor worked well enough.

Wait a minute, as I’ve already noted above, the physics says that moving a magnet near a coil would induce some current in it. But the direction of that current depends on the direction and polarity of the magnet! When the pendulum would approach the center point I’ll have the resulting voltage in one direction, and when it will pass the center and start to go away I’ll have negative voltage on the pins, and that’s a big no-no, the datasheet says that about -0.3V is still survivable, but anything more is dangerous! Well, in theory it could be a major problem, and usually leads to a burnt out microcontroller, but in practice – in this particular case – it’s totally fine.

First of all, the best we could hope for is a few millivolts – not a problem at all (much less than -0.3V mentioned in the datasheet). And secondly, the pins of most microcontrollers are, in fact, protected – check the schematic of a typical microcontroller pin above taken from ATmega8′s datasheet. There are two diodes connected in such a way that any excess voltage (higher than Vcc or lower than GND) would flow through them to the power rails instead of damaging the pin. The diodes are small enough, of course, so they could burn out if asked to conduct too much current, but our tiny coil with a magnet won’t give us anything even remotely dangerous.

Another potential source of trouble is the moment when we disconnect the coil. The current in the coil cannot stop instantly – there is energy stored in the magnetic field around it, so even if we remove 5V on one side and connect both sides to GND, there would still be some current flowing for some time as shown on the third graph (it will rapidly decay due to coil resistance, of course). It would be much worse if we simply break the connection – that current would have nowhere to flow, so it will generate a huge voltage spike (you can read about this effect by searching for phrases like “inductor voltage spike”, “flyback diode”, etc). Fortunately, the pins of the microcontroller (the diodes on them) are quite strong enough to survive even this kind of overload, so, while it would be nice to give the current some time to dissipate, there is no real need to do that.

In the next post we’ll get to do some programming!

Written by Pavel

February 11th, 2012 at 1:53 am

Eternal free-swinging pendulum part 2 – basic plan

without comments

This is the second post in the series about our first kit project. See the page about the project for the whole story.

So, let’s start designing a microcontroller-based eternal free-swinging pendulum.

What needs to be done? Well, the pendulum itself should be a small but powerful magnet, of course. The only reasonable way to push it without touching it is to use an electromagnet – a simple coil of wire. To sense its movement I’ll also need a coil and some way to sense the current that would appear in it when the magnet moves nearby. That’s not a problem – almost any microcontroller these days contains an ADC (analog-to-digital converter), I’ll use that. When it would detect the pendulum, I’ll need to push the magnet somehow.

Another coil? Well, let’s reuse the one I already have – I could change the functions of the microcontroller pins on the fly. First I’ll sense the magnet, and then, as soon as I have it where I want it, I’ll disconnect the ADC module in the software and put some current into the coil. The resulting magnetic field would push the magnet as shown in the image above – and it will happily fly away to oscillate eternally!

Well, there are some potential problems with magnet going in slowly tightening circles (it will not cross too many field lines – and won’t generate enough voltage in the coil) and finally stopping, with someone deliberately stopping it manually or with power losses. No worries, though – we have a microcontroller here, so it would be easy to program some emergency startup procedure.

The physics seems to be sound, so let’s draw the schematic. A simple microcontroller (say, an ATmega 8 or something similar – all we need is an ADC). A small coil. The datasheet recommends some small capacitors as close as possible to the power pins of the microcontroller, so it gets stable enough power. Surprisingly enough, I can stop here; just give this ultra-simple design some power from a nearby USB – and it will work! I tried this version exactly as shown below (see the last image in this post) – and it worked.

What else is needed for a proper device? Power source – well, it depends. For some purposes plugging the board straight into USB socket would be just fine, but in some places there is no USB power, so maybe I should include a voltage stabilizer.

I’ll need to be able to program the microcontroller, so a programming socket would be nice, but even that won’t be strictly necessary if the controller would be in a DIP version, and removable.

Some more things to add – maybe a button to play with, a LED to blink some diagnostic information with or a beeper, and still there would only be a handful of components and the board would be very small. Fine, let’s do it!

Looks quite simple – and using this back in 2008 I’ve started with a board shown on the next image. The connector is the biggest component, some SMD components are on the other side. It has both a button to play a simple game with and a LED to blink when the magnet is detected or a button is pressed. This one needs external power supply, though – it’s located far enough from any computers, so it uses a wall wart from some Chinese device.

I also made a few ultra-simple ones, shown next. Just a controller, one capacitor and a few pads, nothing else. The board itself can be plugged into a standard USB socket (just like some flash drives) to get power, and the coil is soldered directly to a couple of pads. One capacitor to improve the power quality (and it did work even without it!). To program this board I’ve put five pads on the free end of the board, they are easy enough to solder or clip wires to. After all, to be given as a gift this board only needs to be programmed once, with the same firmware as the bigger board above.

The next post would go deeper into physics and microcontroller internals.

Written by Pavel

February 5th, 2012 at 4:52 pm

Eternal free-swinging pendulum part 1 – the best toy ever!

without comments

Note that this is a first part of a long story. We’ve made a dedicated page about this project – make sure you visit it and read all of it.

Some things are best when you build them from scratch, but for some it’s much more fun – especially for the beginners – to skip the tedious parts (designing a case or making a PCB) and get right to the moment where your new toy starts working and you get to change it to your heart’s content. So, with this project we want to try and develop a simple kit for you. If it works out – we’ll have some food on the table and some money to put into our next projects, so make sure to buy one for yourself and a few for your friends, OK? Of course, if you don’t have the money to spare and just want to build something similar yourself – just follow the project along, we’ll publish everything: code, board design, a lot of explanations for our design decisions.

Meanwhile let’s start the kit business :-) First of all, we’ve already developed the initial prototype of the eternal pendulum toy described below, made a few copies of it and asked our friends to assemble it. They liked it (no major problems encountered) – and keep it swinging to show everyone their proficiency in electronics. So, the next step would be ordering a bunch of boards, components and mailing bags – but we don’t know what you, readers and, hopefully, customers, want yet. It’s a new kind of thing for us, so we cannot estimate the demand, cannot decide how many kits should be pre-assembled and how many sold as “pure kits”. So, please, if you want to buy one – tell us about it by filling the form at the project page. It would be helpful if you mention whether you’d like to assemble the board (soldering iron required), whether you need a pre-programmed microcontroller or could program it yourself, do you need a nice stand or plan to install the pendulum in some furniture.

Don’t send the money or credit card information right now – there are no kits ready to be sold yet. We’ll inform you by e-mail as soon as we’ll be ready for pre-orders and determine the final price, and then you’ll be able to make the final decision about buying the kit. Right now we believe it would be possible to make the price about 30 dollars for the whole thing (intricate stand, board, magnet, components) if we get about a hundred people interested in buying.

Well, let’s get to the project itself. Most people start their adventures with microcontrollers with blinking LEDs, a kind of “hello, world!” project that contains a couple of lines of code and a couple of components in addition to the microcontroller itself. When this first hurdle is behind them there is a certain gap – you, as a programmer and electronics engineer are not yet ready to build something complex, such as a robot, but most “purely learning” projects are boring. They don’t give immediate satisfaction of seeing something actually working – blinking, moving, beeping. Besides, most microcontroller projects are very “digital” by their nature; press a button, a LED will always light. The real world is not like that – all the signals in it are analog, and it’s a lot of fun to play with them, to fiddle with parameters within your code and make the result better.

So, you need a project that’s simple, with minimal number of components, small amount of code, that’s fun to play and tinker with. A few years ago I’ve encountered an article in an electronics magazine that described a nice toy – eternal free-swinging pendulum. Mind it, eternal pendulums are very easy to do – every quartz watch contains one. Even a mechanical watch or clock has one! You just put a sensor (an optical, magnetic or even mechanical one) in the pendulum’s path, position it just right, and as soon as the pendulum reaches that point you add some energy to it. Simple and straightforward, works until you have the energy, so could be called eternal. The catch is in the “free-swinging” part: what if your pendulum is not going in a straight line, as it does in a granddaddy clock, and consists simply of a weight on a rope? Where would you put a sensor, how would you push your weight, etc?

The article offered an “old-school” solution, purely analog schematic, with two manually wound big coils (one to sense a magnet in the weight, one to push it magnetically), some complex tuning was required, and yet the authors had to note that it’s a semi-eternal solution: if the weight stops for some reason or even starts to go in circles, it will eventually stop and won’t start until you push it.  So, I decided to do something better. After all, microcontrollers are supposed to be smarter, right?

So, I designed a simple schematic, wrote a few lines of code – and it worked (and keeps on swinging three years later – about one hundred million full swings already!). I sent an offer to write an article to the Elektor magazine – and is was published in December 2008 issue. You can check it at their website (the source code and schematics are available there as well as here, and that old article text could be downloaded for 10 Elektor credits which you can get as a free bonus if you register). Now I want to expand that article quite a bit and make the device into a kit. It’s very simple and offers enough room for tinkering, so it’s probably one of the best beginner’s projects in existence. Let me revisit the original path that I followed while designing the pendulum. I’ll go much deeper into details this time – after all, on this site there is no limit to the page count, and any extra details would be helpful for beginners. I feel this project should be a perfect “second one” – right after blinking LEDs – so I won’t presume my readers know too much about anything, really. The next post would be a general plan for the device.

Written by Pavel

January 25th, 2012 at 8:56 pm

Electronics: Example project

without comments

My first project was exactly what I described before: a simple and straightforward reproduction of someone else’s hardware design (a few simple components) with a complete program that I didn’t even modify. It was a hardware keylogger. I have to admit, though, that today I wouldn’t have started with 8051-based design, with PICs and ATMegas being much more popular, but at the time is was a good enough choice. I’ll explain the differences between various microcontrollers in a future article.

To program the microcontroller I needed a programmer – another simple circuit attached to the parallel port of my old computer (just in case – if I’ll make some terrible mistake I’ll only damage the port in the old machine). The schematic and the software were taken from Dincer Aydin’s site and worked on the first try. Note that this chip needs high (above 12V) voltage for programming, so I had to use a wall wart to provide it. I had no sockets at the moment, so a couple of simple wires worked for me – I added clips to the wall wart’s wire so it’s easy enough to attach.

First I tested the programmer by making a simple schematic on my breadboard and uploading the simplest possible program that blinked some LEDs using the AT89C2051 microcontroller. I found it in the found on the page mentioned above, it’s called ledblink.asm (there is a precompiled version in the ledblink.hex file, and the schematic is in ledCount.jpg). It was easy and fun and it actually worked without me understanding it much.

I used the spring-based (also called solderless) breadboard for testing the programmer first, and as soon as it worked, I soldered it on a breadboard with regular matrix of unconnected pads. Took quite a few wires, so it came out looking like worms’ nest, but worked on the very first try. I still use this programmer occasionally (even though AT89C2051 is quite old and weak chip – I just bought a few extras and haven’t used them up yet for simple projects).

The most complex thing was making it all small enough to be put into the plastic bottle from some pills. I ended up not using it after testing, not even a single time, so the joy of making it was rather short-lived, but as the first project it was rather nice – small enough and yet tricky enough on the hardware side to be somewhat challenging.

Look for some simple circuit or a kit that you could solder together in an hour (or make it on a breadboard) and play with it for a while. We’ll offer a few such kits soon (eternal free-swinging pendulum anyone?), so stay tuned.

Written by Pavel

December 18th, 2011 at 11:20 pm

What kind of schematic to select for your first project?

without comments

Well, now you’ve spent some hard-earned cash and have a bunch of cool toys to show for that. What to do with them? First of all – try and repeat something easy but useful. Don’t try to improve much yet – you don’t quite understand what’s going on within those wires, and reading all the books is going to take weeks or months. Still, you are doing this for fun, so try to get some results as fast as possible – you need positive feedback to keep going.

To select a project you should know that electronics had quite a few revolutions as it grew and evolved. First, there were tubes. Even though nixie clocks are all the rage these days, trust me, you don’t want to make one as your first project. It’s just way too complex.

Then the revolution came: solid-state electronics based on semiconducting materials. You will use these components quite often, but choosing some old-fashioned schematics based on these discrete components could lead to frustration and may even make you quit altogether if your first project just won’t work and you can’t find a way to fix it. Typical schematics using discrete transistors and other semiconductors look like a spider’s web and to really understand how they work you will have to spend some time reading books.

Fortunately, at some point another revolution helped a lot: heaps of those discrete components were placed inside very small boxes called integrated circuits. All those DIP, SOP, TQFP and other forms of multi-legged “bugs” are ICs that you will definitely use a lot. Each IC does some well-defined thing and does it very reliably and with minimal setup, so you can do some pretty complex things just by connecting some wires properly. But wait a moment, there are some revolutions still in store for you!

The next one was digital. People learned to represent “1″ as high voltage and “0″ as low voltage, and started to build ICs that made all those analog problems effectively disappear inside them. What you see from the ouside (and what you design for) is almost completely digital, at any point you have a known and definite value that’s very easy to envision, check and debug. You can do very, very complex stuff with just a few such ICs, and even understand what’s going on using only common sense and a few basic mathematical ideas.

Yet another revolution moved all the complexity even deeper – the latest ICs became programmable. Typical example would be microcontrollers: you construct a very simple, cookbook-like schematics, easily finished in half an hour, and everything else is done in your favorite text editor: you program the logic that the IC will follow. What’s most important for us right now is the fact that a lot of people did the programming already and are willing to share. You can take their code and put it into your microcontroller – and that schematics you have finished in half an hour will be working immediately doing some impressive stuff.

There is one more “half-revolution” going on right now that some people find important – microcontrollers that got simplified, such as Basic Stamp or Arduino. Basically, they have a normal microcontroller and some components around it, and someone wrote a bunch of code that hides the internal stuff from you and makes it slightly easier to start. Not a bad thing, but you have to pay about ten times as much as you would for that microcontroller alone and in return you get much slower execution speed and limited understanding. You may want to try, but please, please remember that “raw” microcontrollers are much more powerful, much faster and give much more freedom – and they are not that complex, really.

So, when you are a novice, and you do not really know what kind of a project to attempt, you have two major ways to start. If you are a “book learner” – go in a chronological order. Take a few resistors, diodes, transistors, look for a simple LED blinker or an audio amplifier, and try to understand what’s going on in it. When you have a handful of components and a few smart books, it’s more of a conceptual jump, not too big and not too complex. In this way you will really understand what you are doing at every step along the way, but your first major project will come a little bit later.

On the other hand, if you are a programmer and want to use your existing skills, or if you want to skip all the complex stuff for now (and return to it later – don’t hope to avoid it indefinitely) and play with simple and well-behaving bricks, go straight to microcontrollers. Make a LED blinker – and be surprised how simple that is. Then change a couple of lines in your programs – and make LEDs react to button presses or temperature. Use existing libraries that do all the hard stuff for you, connect the pieces of code in a new way – and add your own two cents, so someone else will use your code some day. Build a robot or a new toy, publish its design and code, take part in open hardware movement – the possibilities are endless.

Written by Pavel

December 12th, 2011 at 8:41 pm

Electronics: What you should know?

without comments

While you work on your first project – take some time to read a few books. The one definitive book that everyone says you have to have is “The Art Of Electronics” by Horowitz and Hill. It’s a bit on the complex side of things, though, so I would read it after a couple of projects, when you already have some hands-on experience. And for the beginner everything written by Forrest M. Mims, III would be just perfect. He wrote quite a few brochures for RadioShack and his thicker books are a pleasure to read. Easy, with good examples – just what a beginner needs. “Getting Started In Electronics” is one of them and I just love it. You’ll outgrow it soon but it will still be a pleasant memory.

I don’t really think I should remind you about all the great resources available on the Internet. Whatever question you have – just google for it and you’ll get your answer. Still, a few general ideas would be helpful.

First of all – read the datasheets. If you use some component, even a simple diode or something like that – find and read its datasheet. There are very many sites that collect datasheets. I prefer, but any other will do just fine.

Second – surprisingly enough – the site that is often on the first page of google results,, even though it looks like some kind of spamming robot-generated heap of text, is a well-sorted and even slightly structured treasure trove of useful links and information. Don’t close it as soon as you see it, read a page or two first.

And third – whatever you do, there ought to be a FAQ on the subject – google for “<your topic> FAQ”, and there ought to be some definitive site with a forum that discusses your question. Visit it, read and search the forum first (your answer is most probably in its archives), and if you can’t find it – ask your question and someone will help you. Don’t ask before searching, though –  people don’t like this and may refuse to help.

Written by Pavel

December 6th, 2011 at 11:18 pm


without comments

Medieval weapons of war – the best way to celebrate a birthday! Get a few friends, some power tools (nothing fancy: a couple of drills, some saws, wrenches and screwdrivers), visit your local lumber mill or a store that sells lumber, bring back some thick boards (we used mostly 4×1, but didn’t bother with precise plans). A bunch of fasteners (as thick and as long as you could handle with your tools), some strong ropes, and two strong steel pipes, so that one fits within another. If you don’t have anything heavy enough to serve as a counterweight – buy some bags of sand, cement or something else – cheap and heavy.

Of course, you could use bags of dirt, some scrap metal, but you need quite a lot of it – the recommended ratio for perfect throws is about 70/1 to 100/1. Basically, if you want to throw 1 kilogram (a couple of pounds) of something – you’ll need 100 kilograms (200 pounds) of counterweight, and it should be small enough to fit in your trebuchet. We used concrete mix and rigged a small platform to put a few bags on to, and we found there is just not enough space to go to 100kg and be able to swing it without touching ground, so 75kg was our final counterweight.

We studied a few examples of other people building their trebuchets – such as

- and decided to build as big as our lumber allows, and not do it by any precise plans. After all, the beauty of the trebuchet is its simplicity: two very strong triangles, some support on the sides, so it won’t fall down, and the axle at the top.

The initial part went pretty smooth – cut a few pieces, align them, give the strongest guys a chance to power in some very long and strong screws. In an hour or two we had the triangles and some supports up. This thing was actually starting to look impressive – it was HUGE!
Next – the axle. We didn’t use any bearings – there is simply no need. Just a couple of steel pipes. First we put the thicker one on the thinner one, then drilled some holes and fixed the thinner one to our triangles as securely as possible. To make them rotate easier some car lubricant was deposited between them – and it worked perfectly.
Our lumber was not strong enough to make an arm in one piece, so the solution was to take a single 2×1 (about 3 meters – 10 feet – long), make a semi-circle in it to fit the axle, then take another, shorter, piece of 2×1, make another semi-circle in it – and join them over the axle. The rate of long side of the arm to its short side should be about 3:1 – once again, there is no need to be too careful about it, just do the best with your materials.

At the end of the arm we screwed in an opened eye bolt – almost, but not quite, straightened. The angle of this “hook” will determine the moment of release, and therefore, the angle of flight. You can adjust it after a few shots to improve the height or distance. By the way, we had a big enough bolt and small enough weight to throw, so we went against the conventional wisdom and simply drilled a hole along the wood grain and screwed the bolt in. It held without any problems.

The final part was the most difficult one. How to build the counterweight? It’s heavy and it has to swing in a very small space. First, we though about some water or sand, but realized we didn’t have anything useful to put them in – something of the proper size and shape. OK, next idea – simply take a bit of a plywood (strong one, of couse), drill four holes and thread some very strong rope. Instant platform to put a heavy load on!

Not so fast, though – first the ropes started to stretch under load, and our platform got stuck on the ground. Remove the weight, shorten the ropes, reassemble, put weight back. Nice, but the platform wants to rotate – and our triangles are close enough, so it hits them as it swings while rotating. Some brainstorming led us to a simple solution: guards on both triangles, made from any thin plywood, let the platform slide on them smoothly without hitting anything.
Below, on the ground, we had two boards angled to each other to form a trough, so our harness with its projectile will slide in it smoothly before getting into the air and flying away.

By this time it was getting a bit dark, so we went for the kill: the only things to be done were the harness for our ammo (toy balloons full of water) and the release mechanism. The former was easy enough: just take a bit of plastic fabric, tie a few knots, make a few holes – and here it is. The length of the ropes could be anything reasonable, start with something similar to the trebuchet’s arm length, then customize as needed. Note that this harness is designed to fly with your projectile, the loop on its end slides off the hook – and the whole harness flies away. We had to re-tie our fabric, as our first balloon scraped on the boards and burst right there. It still flew, though, as a mass of water – but we wanted more distance, so keeping it intact was more fun.

The release mechanism was a thing of beauty. Most people who took part in the construction were skeptical about it – too simple, they said, shouldn’t work – but it worked perfectly on the first try. Basically, we took two eye bolts, inserted a link of a chain through one, and inserted another bolt into the same link. The other end of the chain went to the arm and held it down. As soon as you pull out the bolt, the chain gets released – and the trebuchet fires! Since the release mechanism is under heavy load you do have to yank on the rope quite hard, but it’s simple and effective.

Oh, by the way – it’s all fun and games before someone loses an eye, so make sure no one stays even close to the plane of swing, in any direction.

After multiple successful shots our trebuchet failed – the rope holding the counterweight broke – and the missile went in a random direction. Besides, there are all those strong and heavy bits of wood and metal swinging around with terrifying speed, so don’t be close to the machine when (not if, when) it finally breaks down!
Still, for a few short hours of construction, with simple enough tools and materials, we had more fun than ever celebrating someone’s birthday. Highly recommended for a bunch of guys and gals not afraid of some engineering!

Written by Pavel

November 30th, 2011 at 11:13 pm

Posted in One-day builds

Tagged with , ,

Electronics – what you should have?

without comments

Welcome to the world of electronics. It’s a great hobby that allows you to understand what’s going on in all those gadgets that blink their LEDs in our pockets and houses, it lets you design and build smart things that free you from mundane tasks and fill your friends with awe. Well, and it keeps your mind working…

What you will need

As with most hobbies you can start with almost nothing, but it really helps to have a few basic things that you will have to buy anyway. Here’s the list in no particular order:

Spring-based breadboard, like this. As you can see I’ve added a few things to it – voltmeter, ampermeter, a panel from an old computer with some LEDs and switches… All this is not essential, of course, and there are very simple boards that cost almost nothing. Buy whatever you like. A board such as this really helps to make temporary circuits and debug them. If your board doesn’t come with a set of jumper wires – buy one separately, it’s more convenient than cutting and stripping them yourself.

Power source. In my case it was a simple wall wart and a few components in the corner of my breadboard (LM7805 and a few capacitors) but some people feel that having a fancy lab power source with voltage and current settings helps them. I don’t think it’s worth it to buy a fancy power supply at early stages, you can always get it when you need it (in a few months or even later). You can also make your own later – and it’s fun.

Digital multimeter. Forget about analog models (you’ll know if you need one, and it will not happen during your first year), get any cheap digital one, and make sure it can measure as many different things as possible. Some good things to have (besides the obvious volts, amperes, ohms) are capacitance (C), inductance (L), frequency and duty cycle, semiconductor tests (diodes, transistors). Don’t worry if yours would not measure something, such as inductance or frequency – you can easily make a simple device that will do it for you. Try to get a multimeter that determines the ranges automatically, it’s a nice thing to have. Don’t go for the costly ones just yet – buy one or two cheap ones first. It’s always nice to have more than one, to compare or to use at the same time.

Some components. There are a few things that you really should get early: resistors (some big set of various values), small ceramic capacitors (most used values are 22pF and 100nF – get about a hundred each), electrolytic capacitors (values from 1uF to 47uF deserve about 10 each, 100uF – about 20 or 30, and a few high-valued ones, say, about 2200uF). Note the voltage rating for electrolytes – something between 25 and 100 volts would be just fine, they are still small enough and yet you can use them for most purposes without any worries about them blowing up.

Some connectors (D-SUB with 9 and 25 pins, IDC 2×5) to connect your projects to COM and LPT ports (you should select proper combination of male/female connectors, of course). Pick up a few cables for that purpose as well, including a COM-to-USB converter. Some more or less stiff wire (solid UTP – Unshielded Twisted Pair, used for Ethernet – works very well). Some thin wire, preferably in heat-resistant insulation, so you can solder without burning it.

Solder – I recommend 0.5mm with rosin core (lead-based, if you can still get it – it’s perfectly safe if you don’t eat it, and it solders way better). The powers that be are busy removing lead from electronics so it won’t collect in the landfills in huge amounts and get into drinking water, but the lead-free replacements are noticeably more difficult to solder and they produce less robust connections. Buy a small bottle or syringe of flux (non-acid one, so you don’t have to wash it off after soldering); even though there is a rosin core in your solder, extra flux is almost always needed for a perfect solder joint.

Soldering iron – trust me, you want to have a temperature stabilized one. It could be very cheap (I’ve bought a chinese one for 5 or 6 dollars), but it should have real temperature sensor and not just power regulator. If you have a bit of extra money – buy some famous brand, but, once again, temperature stabilized one. I bought three regular irons, each one more expensive than the previous one, before I finally realized what I really need. Don’t repeat my mistake. It would be nice to buy a soldering station, some Chinese knock-off should be cheap enough to be bought instead of a simple soldering iron.

Tools: a sharp knife, precise tweezers, small, but strong flush cutters (with flat “bottom” part, so they can cut as close to something as you need), maybe forceps (also called hemostats – those frightening-looking locking clamps that grip and hold anything), and that’s it. Sure, there are many other components that you will need, but you can buy them for a particular project, as needed, and the things above are too commonly used to buy every time.

A box with many small drawers to hold all the components that you will accumulate. Trust me, it’s not fun to dig among hundreds of tiny packets with unlabeled tiny components.

Oscilloscope. It is really one of the most valuable tools for debugging, so buy or make it as soon as possible. A couple of years back my advice would be to buy a super-cheap old analog one on e-bay for $50 or $100, but today there are some pretty cheap digital ones – both “normal” standalone models and USB-based ones. Rigol, Owon, Tekway – there are many cheap and nice scopes available way below 400 dollars. Sure, it’s a lot of money, and you can do without a scope for a while, but it’s very frustrating to look for a source of a problem for days when you could find and solve it in minutes with a scope.

Some Dremel-like rotary tool comes very handy for making boxes, cutting holes, shaping PCBs, etc. Obviously not necessary, but nice to have. Note that PCB dust contains microscopic glass particles and is fairly dangerous to inhale, so take some sensible precautions – use proper vacuum with HEPA filter (without it the tiny dust particles would pass through and contaminate the air), work outside, etc.

Written by Pavel

November 25th, 2011 at 11:17 pm

Mini Vortex Gun

without comments

Don’t have space to build a huge vortex gun? Don’t want to spend hours to build the big box? No problem – we’ll also teach you how to build a smaller version. Its rings won’t be huge (and, probably, won’t be visible – there is no easy solution to smoke generation in a handheld vortex gun), but they will fly across the room, blow out candles, surprise the cat and bring a lot of fun to everybody.

We are trying to save some time here, so we won’t build any boxes. Visit some store and buy a plastic can, as big as you could manage to find. Make sure you could still hold it in your hands for a few moments – after all, it’s going to be a handheld gun. It doesn’t have to be closed and airtight – one with a lid will do. Even better – we won’t have to cut away the top side, so try to find something with a removable lid. Form, thickness, anything else are not important, just a big plastic cylinder.

Remove the lid (or cut away the top side). Buy some cloth (preferably airtight – vinyl or something similar) and a small ball or stone – it will serve as a handle. You’ll need some kind of elastic band, but it’s also possible to try without it. And, finally, a rope or wire to attach the cloth to the open top of the can. Of course, some duct tape always helps :-)

Assembly is fast and easy. Make a (reasonably) round hole in the bottom of the can, about 1/3 to 1/2 of its diameter. Take the cloth and tie off the ball or stone in its center to form a handle (use some thread or rope). Now the difficult part – take a few lengths of the elastic band and attach them where you tied off the ball (you dont’ even have to sew them along their length, but it will, of course, help).

And the final step – put the cloth over the top (fully open) side of the can, leave enough slack, so the ball moves for a foot or so, and fasten the cloth to the edge of the can. Use rope, wire, duct tape – whatever you like. Try to make this side more or less airtight.
That’s it. Time for shooting. Position the can horizontally, pull the ball back and then either push it forward (it will produce slower but stronger ring) or snap the elastic – the ring will fly faster but have less force. It’s absolutely safe, if you shoot someone with a ring – it feels just like a wind gust. If you can produce some smoke that you are willing to live with – go on, simply blow it inside, then shoot a ring. Have fun!

Written by Pavel

November 18th, 2011 at 1:21 pm

Posted in One-day builds

Tagged with ,

Juice case

without comments

Written by shakespit

November 11th, 2011 at 2:00 am

Posted in General

Tagged with