The Null Nibble

WildFly UAV project & home-built RC airplane

2011-02-11T13:00:00.009+02:00

A group of people, me included, have decided to join forces in building a quadcopter UAV. I was given a responsibility for the hardware (structure) and low-level electronics part. We're planning to meet up next week to discuss it in detail.

We're currently amassing some knowledge about other projects and whatever general wisdom has already been gathered so far about this topic by people around the world.

The plan is to first make the basics: a physical model build with necessary minimum amount of equipment on board and make it fly — in stable hover first at least. Then we hope to make gradual progress towards a small and effective payload carrier capable of autonomous flight. Our main inspiration (and probably development basis) is ArduCopter, but we're planning of using an Android smartphone as the higher-level onboard autopilot. Although I'm a bit skeptical about it, at least, it will be interesting to see, if it really works, and how well does it.

RC Airplane

There's another thing that I was thinking of building before summer this year, and it is an approximately 2-meter wingspan glider-type RC airplane, capable of carrying some photo/video equipment. The aim is the same — build an FPV/aerial photography platform, but with a different approach — making a fixed-wing aircraft instead of rotorcraft. I've been studying this topic for a while already and have gathered some insights about it with the help of a number of Internet web-sites (listed below, if you're interested). I feel like I'm ready to start designing and building my first-ever model. I'll give more details a bit later, when I get to draw some real plans.

Here's a short list of the most helpful web-sites with detailed instructions and well-explained practical and theoretical aspects of RC aircraft modelling:

RC Homepage comprehensive RC Aircraft Beginner's guide
Instructables' Beginner's Guide to Radio Control Airplanes — although repeats (and confirms) a lot of basics from the first guide, but does contain some little tips and tricks that the first omits.
Airfoil Investigation Database -- a database of airfoils (wing profiles) with all their improtant characteristics presented. Helps finding the right airfoil, when designing an aircraft from scratch and understand some details about wing physics on examples.

There's a number of challenges associated with the aircraft building, starting with budget allocation and remote control radio and other related electronics choice and ending with a whole set of design, construction and flying issues. I will try to report on my progress of solving all that.

Google AI Challenge

2010-12-04T16:09:00.072+02:00

The Google AI Challenge is finally over. I participated together with other ~4500 programmers and programming students from all over the world. My alias was 'deemoowoor'.

I've decided to follow the winner's and many other participators' example and release my source code. I believe it may be of use for educational analysis: there have certainly been genuinely nice ideas about the game strategy implemented and mistakes, that may be useful to get some insights from.

The code is released on my GitHub. It's licensed under CC-BY-SA 3.0, so feel free to do anything with it as long as you give me credit and share your derivatives alike.

Here's an example of one of the last games: http://ai-contest.com/visualizer.php?game_id=9559141.

Some notable points about the bot and my participation in the competition:

I chose Python, because it's very easy and quick to write code in. Complex things can be expressed in simple terms. On the other hand, dynamic typing creates some issues during development (you have to run all of the code to be sure it doesn't have any of common problems with types, i.e. unit tests are a must).
There was no unit testing used. Something I regret about now. Although I didn't really take the contest very seriously at first, once it took my mind over, I was too excited about the features (i.e. strategy options) of the bot, rather than common quality concerns. It was fine as long as the bot was relatively simple, but once it got more and more complex, taking more and more variables into account, it became harder and harder to make changes without creating regressions elsewhere. While extensive testing has been, of course, being done during development, it was way too time-consuming.
All of the bot's strategy was designed based solely on my own analysis of the game as I watched the games visualized as well as analyzing extensive logs produced by the bot in debug mode. Again, as the bot became more and more complex and more and more variables were being used to determine best strategies and tactics, the logs got even longer, spanning several print pages for each step, where the amount of conquered planets on both sides got big enough.
One of the problems was bot's performance. While first development iterations could be easily run on the contest servers, once I started using searches through all the planets for every kind of action for the bot to undertake, it quickly degraded to the point, where even on my 3-core 12600.01 BogoMIPS AMD Phenom computer with 3 gigs of RAM it took a whopping 0.7-1.0 seconds to compute just one step of the game. So I had to optimize, which was mostly resolved by memoizing everything I could. I know, many other participators did this, too, because it was inevitable for complex searches, which were needed to successfully compete on the Planet Wars battlefields. :) This was what I did during one of the last development iterations, where apparently a lot of bugs and functional regressions were introduced.

I would like to congratulate the winners of the contest and thank everyone else for participation. It was an educating and very entertaining experience for me!

There were lots of positive emotions for me from my small victories during the contest. I did manage to get as high as about #30-50 overall a couple of times in the middle of it. Even though it doesn't mean much for the contest itself, it played an important role for me to further understanding the things that make me go in programming. And participating in competitions with some hope of winning or at least getting an honorable position on the final ranking table is certainly one of them.

Statistics

Here are statistics based on data from Google AI Challenge: Languages Used by the Best Programmers to give you an insight into some aspects of the contest:

The above chart demonstrates the points distribution among all participants. Vertical axis is the amount of points, horizontal axis is the final ranking position. My approximate ranking position is highlighted in red.

I wonder what does that anomaly at around 3000th place mean... There is a certain trend to follow an n root plot, but then, at about 3010th position, it makes a slight but obvious dive. Is that the RageBot or starter package position?

Language-specific average point distribution chart together with standard deviations rendered as vertical lines (centered at the mean value). Groovy had a single contest entrant, so doesn't have deviation specified.

Average amount of points gained by participators in each of the programming languages used.

A glow-in-the-dark board using a PIN photodiode

2010-11-19T20:25:00.002+02:00

Here's a small board I've soldered together yesterday for Kristi's next "electronic garment" project.

The schematic was taken from an Evil Mad Scientist post here, but was converted to a photodiode basis instead of a phototransistor used there (which is in essence a photodiode connected to a small signal transistor).

It's a very simple thing doing a very simple thing: it makes LEDs glow in the darkness (or when there is little light hitting the photodiode, to be precise) and dim them out in the light.

The LED on the board is there for testing. It's not soldered in and can be removed easily. The green wires are for the LED connection. Black/red are for power, which is expected to be around 3-5 V, but can probably also get to as high as 9 V. The wires are not mandatory and are there for convenience, cut off to fit.

This also happens to be my first significant soldering project since 1995. :)

I've also tried the prototype board for the first time and it turned out to be fairly easy to handle. I used components' leads to make it easier to solder connections on the copper side. everything else was basically done solely by the soldering grease magic. :)

Blinky lights are fashionable!

2010-11-15T17:37:00.002+02:00

A friend of my friend, Kristi Kuusk, an Estonian arts student, is experimenting with some garment designs with conductive fabrics and LEDs, and I feel like sharing: Kristi Kuusk: Projects.

These are not really blinky, but they do shine. Also, the concept is there and it's only a start! Looks really good so far.

This stuff is getting crazy popular in the West — judging on the amount of stuff written in all kinds of DIY blogs about it — but was not so much here, in Estonia. And so, at last, we're getting there, too!

Well, I, for one, welcome our new LED-flashing conductive-cloth-wearing overlords! :) My best wishes to Kristi!

Flash driven photography snapshot trigger

2010-09-18T20:30:00.004+03:00

The idea to make such a device originated on the DevClub mail-list (in Russian).

This is how it looks on a breadboard:

The PIN photodiode (the little square on top right edge of the photo, left of the button) is used to detect light. It is connected to ATmega8L chip's ADC0 pin. There are also 4 LEDs connected to digital output pins and an LCD module, also connected via 6 digital pins on the chip. There is also a potentiometer (on the left of the chip) used to set the ADC reference voltage (AREF pin) for the chip, effectively regulating the light detector's sensitivity.

The LCD displays raw values returned by the 10-bit ADC: rightmost "p" and "c" values display the values continuously measured by the ADC once every second. The leftmost two values are the ones measured, when the chip first detected a sharp increase in light level, which also results in a sharp increase in voltage on the ADC0 pin.

The effective sampling rate is only about 1.8-2.2 kHz. It's not much, but it's enough.

This thing was programmed using Arduino. Publicly available on gist.github.com here.

Works perfectly with my Pentax K-m, making the second LED light up even when the stock flash goes off from more than 4 meters away (indoors). Doesn't work as well with Nikon Coolpix 7500, though -- probably the flash is not as powerful.

Using Atmel ATMega8 as a barebones minimal Arduino clone

2010-09-11T16:10:00.017+03:00

It's nothing new, that you can use Arduino software and a cheap ISP programmer (such as the USBTinyISP by Adafruit) to program AVR microcontrollers.

So, long story short, I decided to make a simple photography flash-driven trigger, used for flash synchronization etc. To start, all I really needed was an AVR chip, a photodiode and a handful of LEDs to indicate results somehow.

It wasn't very hard to figure out, although there were a couple of caveats I'd like to share about. I almost burned the chip (or programmer) out, when trying to hook them up together -- you'll see why below.

So, here is the Arduino pin mapping. Using this picture, you can figure out, which pins go where. Article called Minimal Arduino with ATmega8 describes a lot about it nicely. Moreover, it also describes, how to set up Arduino software to work with an AVR chip, which is set up to be driven by an internal oscillator.

You don't need an old Arduino board to program the chip, though, if you have a USBtinyISP programmer. This little board enables you to program any microcontroller, that supports the ICSP interface, which of course includes all AVR chips (also possibly others, like PICs, but I'm not sure yet). For that we need only 6 wires: +5V power, ground, reset, clock, MISO and MOSI. Connecting those is well-described here: Standalone Arduino, which also includes a HOWTO for setting up a crystal-based Arduino. Alternatively, you can find info here.

One important caveat, though: if you look down to section 6 of the Standalone Arduino article, about bootloading the Arduino, you will see the pinout of the ICSP interface:

Well, this is the pinout of the board header, not the cable. On the cable (when you look at it from below) it's mirrored, which is visible on the other picture:

Mixing it up together and then trying to connect it to the programmer may make your chip or programmer to become permanently damaged, so be careful. I was lucky: I've made this mistake and the chip became too hot to touch in several seconds, but it did not apparently make any permanent damage to the chip, although I'm afraid it severely degraded its future lifetime... :)

Another caveat is not to forget to connect both ground pins on the AVR chip to the ground (and not the AREF pin, which I did at first). It will appear like the chip works. In fact, in will work! But on-chip ADC won't. Luckily, it didn't burn out.

Take your time to check every connection and the fact that it goes to the right pin twice before powering the whole setup up.

What I've also learned was that it is possible, and is quite easy, to program bare AVR chips with Arduino using any of the supported programmers (USBtinyISP included!).

The key benefit is: no bootloader is needed then! It eliminates the boot-up delay and it saves 1-2 KB of flash memory on the chip (which is almost 1/4th of the whole amount on ATmega8!).

To do that, you only need a programmer and configure Arduino to use the programmer to upload the programs: more about it here.

Here's an example schematic of what it looks like (together with a couple of LEDs attached to some of the free digital pins):

Yaw control ideas

2010-08-22T11:13:00.006+03:00

That yaw control problem, I've read about yesterday, puzzled me. Then I got an idea, that it can be solved by vectoring part of thrust sideways using vertical control surfaces underneath the rotors.

By changing attitude of these control surfaces sideways in a circular pattern, the part of the thrust will be deflected sideways and a horizontal torque will be created, which will induce yaw on the whole aircraft, rotating it around its center.

Same control surfaces can be used to counteract parasitic yaw when applying pitch and roll controls to the aircraft.

Thrust vectoring surfaces can be controlled using servos in the same way they're used in model aircraft. To make these control surfaces yaw-only, just one servo (two will be better, though) and some thick rigid steel wire is needed.

Thrust, weight and other interesting numbers

2010-08-21T00:38:00.023+03:00

Unlike car motors, power has little practical sense for propellers. A helicopter's rotor can ultimately create zero work (thus generating zero power), but still be able to hover. In reality, it pushes lots of air downwards, making work there. But measuring airflow directly and precisely is hard. Measuring thrust is, on the other hand, quite easy: dynamo-meter will do.

The force of a rotor (hooked up to a motor) propelling a vehicle is called thrust and is measured in newtons (N) or kilograms (kg). 1 kg corresponds to 9.81 N, usually rounded to 10 N, which gives a hint that kilogram is a measure of weight. It's not a coincidence: a rotor with a thrust of 1 kg can really pull up anything with a weight of up to 1 kg.

Now, considering the need to make sure that the remote-controlled (or autonomous) aircraft, that I'm trying to build, will actually fly, I need to make sure that its rotors will be able to pull it up from the ground. This means that total rotors thrust should be bigger than the total weight of the whole aircraft. The difference between the rotor's thrust and aircraft's weight should give us the net thrust, which can be either positive or negative. Divided by aircraft's mass, it gives us vertical acceleration:

a_vert = (T - mg) / m

where T is total thrust, m is aircraft's mass and g is gravitational acceleration = 9.81 m/s².

The interesting numbers

Since I need 4 motors for the quad, unit price is very important, since the total price is going to be 4x of that. I have to bear in mind, that for any motor I decide to buy, I will also need to get a corresponding ESC (electronic speed control) for each of them, or a single four-channel ESC. I have a limited budget for this project, so the cheaper the stuff will be, the better (although I still want to get reasonable quality -- that means, be able to fly it more than 15 minutes).

So, looking at the choice of motors available, I've found out that the motors I want usually provide about 400-600 g of maximum thrust. The tricky issue here is to find a balance between the price of the motor and the ESC (bigger low Kv motors cost more, as well as high-current ESCs), while taking from it as much thrust as possible.

Still, I think it's pretty safe to assume, that a decent cheap low-Kv motor can make about 400-500 g of thrust under a reasonable load of 7A with a big 10x4.5 propeller, and can give max output up to 600-800 g under max load. That makes it total "normal" thrust of 400 g × 4 = 1600 g. This would be the maximum safe takeoff weight of the aircraft I'm going to build.

The total mass of the quad's frame would be about 250 g — a 1 m piece of the 10 mm square aluminium profile weighs just 200 g, I would use one piece cut in two with an aluminium plate on both sides to attach them firmly together. By cutting just half of the profile in the cross point, I will save half of the rigidity of the aluminium profile. The loss should be compensated by the aluminium plates, that will hold it together. Refer to my previous post to see the drawing illustrating this construction.

A big battery weighs about 250 g, ESCs — some tens of grams, let's take it ~25 g x 4 = ~100 g total. Motors in the chosen category weigh about 30-60 g each. Power wiring can take up to 150 g of weight (thickness of wires is proportional to current, because they provide resistance and heat up proportionally to the amount of current going through them, and we want to keep the wires cool and lose less power to heat). Controller & IMU is probably another 100 g. This gives us a total weight of 250 + 100 + 60 × 4 + 150 + 100 = 840 g.

With the total nominal thrust of rotors at 1600 grams, it should be able to fly pretty well. Maximum vertical acceleration at "nominal" thrust would be:

a_vert = (T - mg) / m = (400 × 4 - 840) / (840 / 9.81) = 8.88 m/s²

This is 0.9 g, which is to be added to the normal 1 g, which makes it almost double the normal gravitational acceleration. This also means that I can put additional weight of about 600 g, until it begins to be overloaded (require more than nominal thrust to pull it up). That's more than enough, since my Nikon Coolpix 7500 camera weighs only 210 grams with batteries (and I can easily hack it to use the aircraft's battery power supply via e.g. the flight controller, which would make it about 140 g). Special radio-transmitting "spy" cameras weigh even less. So, this means I could put a bigger (~5-6Ah) battery (~450 g) for longer flights.

These of course are only rough guesstimations. Actual performance will vary.

A side note: placement of motors

After looking around at other's designs, I've noticed, that people tend to put their motors not on the ends of the beams, but exactly at their centers. With such setup, propeller tips are protected by the rigid beam tips (usually the tips are further improved by putting some round rubbery pieces there, so that both aircraft and surroundings are safe from hard hits). To improve that further, I would also put a thick piece of paracord or something similar around the beams (i.e. effectively connecting each beam with a cord). This way the quadcopter is going to be almost completely safe from any tall vertical obstacles (the rotors won't be damaged by hits against walls, posts, people running around, and when falling to the ground in steep angles :)). Ultimately I could make a wire mesh around propellers, but that would be an overkill -- and considerable weight added to the aircraft.

I think I will do it this way, too. Although I also think that it may make controlling pitch and roll of the aircraft precisely a little harder (less difference in thrust will be needed to change its roll and pitch, which will result in less precision of control).

Another issue is yaw control (i.e. rotation over aircraft's vertical axis), as this blog post points out on the first note:

Motor spacing plays a big role on stability and yaw control. I found that when the spacing was about 800mm (shaft to shaft) the yaw was nearly impossible to control, also the Quad was impossible to control because any slight change in the motor speed will result in a large change in attitude. The solution was to move the motors in as much as possible for a spacing of 460mm. With that spacing the yaw authority was much better, however yaw became more sensitive to motor alignment so it took a few tries to get the yaw to be stable.

Yaw is controlled by spinning the counter-rotating rotors with different speeds (this applies to multi-rotor like quads, as well as coaxial and tandem helicopters). If one of the rotors rotates faster, it creates greater drag and thus creates rotational force to the aircraft. I believe that the 4 rotors on the quad should be controlled in such a way, that at least pairs of rotors, located on opposite sides of the frame would have equal speeds. Although optimal is having all 4 rotors to spin equally fast, it could be hard to achieve. Balancing two pairs of rotors is easier than balancing all 4 at once.

This has to be taken into account, when designing and calibrating pitch and roll controls, because they will have an effect on yaw as well. For example, a simple naive approach to changing pitch of the aircraft would be to simply change the speed on just one of the rotors. This would instantly create a difference in rotor torques, which will make the aircraft rotate — i.e. apply unneeded yaw (as well as pitch) to it.

My idea of a better approach is to increase rotational speed ω₁ on rotor R1, while proportionally decreasing it on R3 (ω₃), while also increasing speed on R2 and R4 pair proportionally to the difference between speeds of R1 and R3 (Δω = ω₁ - ω₃) and also creating a small difference in their speeds proportional to ω_R1 - ω₃:

ω₀ = ω₁ = ω₂ = ω₃ = ω₄

ω₁ = ω₀ + 1/2 Δω

ω₃ = ω₀ - 1/2 Δω

ω₂ = ω₀ + Δω (x - y)

ω₂ = ω₀ + Δω (x + y)

where x and y are coefficients to be determined experimentally

Increasing R2 and R4 speeds would increase the absolute values of counteracting forces, which would make the torque created by difference in R1 and R3 speeds smaller in comparison, but won't change pitch on that axis. This will lower the yaw drift, but probably won't eliminate it. This will also increase total thrust. I will need to investigate this important issue further.

Putting it all together

To be continued

First sketches of the quadcopter UAV I plan to make

2010-08-19T10:23:00.006+03:00

Here's what I've been working on lately: a to-scale sketch of the UAV's frame design. There are many viable variations, but this one fits my requirements best: it's simple, durable and provides possibilities for several layouts (e.g. putting the rotors between the frame beams, possibly in nacelles).

Here's the original SVG. I've made it with Inkscape.

PIN-diode light measurement circuit

2010-08-06T19:29:00.023+03:00

Here's what I've found on All about circuits today:

Doesn't that look very similar to the γ-detector circuit below (not the whole circuit, of course, but the detector and the first stage amplifier part of it)?

Except for the 10nF capacitor on the op-amp input and a connection to a 12 V voltage source via 1 and 10 MΩ resistors (which I still don't understand), the first-stage of the circuit is almost identical! The non-inverting input in the γ-detector circuit is simply adjustable to measure the difference not with ground, but with a voltage of 2.885V to 3.078V (this is how much adjustable it is).

There is also an interesting effect, then quickly changing the amount of light coming to the photodiode, the voltage increases and decreases slowly. I haven't yet figured out if this is intended or not and whether it has any specific meaning in the context of this circuit.

PIN diode's photovoltaic effect

Now, here's another phenomenon I've unexpectedly encountered while trying to build this simple circuit presented by "All About Circuits": looks like a PIN diode can generate electricity! And in fact, this is exactly how it can be described here: light makes the PIN diode generate voltage and thus drive the op-amp to amplify this signal.

Actually, I remember now reading about it somewhere, and quickly forgetting it, since I have instantly assumed it was too small to be even measured by my cheap multimeter. Well, it turned out I was wrong (again): it actually responds to the light quite well, with my room ambient light resulting in about 210mV of potential difference. My fairly powerful LED spotlight has been driving it to about 360mV (not as much as I had expected, but we've got to keep in mind, that it's white (blueish) LED spotlight, not IR). And this PIN photodiode (SFH203FA) is quite sensitive too: even when almost completely covered by a foil bag it produces about 5 to 10 mV of potential difference on its leads...

This sensitivity constitutes a problem, though, since 5 — 10mV it can produce in almost complete darkness, may interfere with my γ-photon detection effort! I guess, I'll have to find a way to cover it in a complete light-absorbing or reflecting layer of something...

The gamma-particle detector circuit built again

Starting from the first circuit above, I've managed to build the circuit as proposed by MAXIM's application note, but instead of using a comparator, I have used a TDA2322m amplifier to pick the sound on a speaker and driving all the amplifiers on 12V, not 5V. Despite it generating quite a lot of white noise (I wonder why, BTW: is it the circuit's intrinsic thermal noise or some kind of radio pickup?), it did let through some of the light-induced vibration, but it kept silent when left working in the dark...

The 12V "pull-up" on the photodiode obviously works as a very slow potential "equalizer" for the op-amp input -- when light is applied on the photodiode, the voltage slowly increases and vice versa. My understanding it that this helps to filter out any light-induced "interference" on the photodiode to make it more responsive to changes in photodiode voltages, as opposed to its constant levels, generated by any light hitting it.

Just for fun: photo of a bare microchip

2010-08-05T21:33:00.003+03:00

This is a microchip extracted from a toy RC car. Most likely a sound chip, since it was on a sound FX board. The plain part is probably its sound memory, all the rest is actual logic.

On the left of the chip is a salvaged TDA2822M stereo audio amplifier IC, from the same RC car.

Status update: learning to use op-amps

2010-08-05T00:48:00.010+03:00

Using op-amps is not as easy as it may seem...

I've found a nice article with very informative animations, but it doesn't seem to be exactly that way, at least not for me with my TL072CN op-amps... Here's the article: "The op-amp". It did help me understand what the hell negative feedback is and why is it used in operational amplifiers. Another great source of explanations to electronics: All about circuits: op-amps.

The latter, "All about circuits", is an excellent guide to electronics with very nice balance between detail and clarity of explanations. It has explained virtually every phenomenon I have encountered with the op-amps so far.


Альбом: Electronic stuff

Arduino, the experimentor's friend

These pictures illustrate how useful can Arduino be for such experiments... I've used 3 analog inputs to measure the voltages in several places across the circuit and it really helped me a lot: I could see how output changes in relation to the change in the input (which I varied using the good-ol' voltage divider potentiometer, actually, a pair of them -- one coarse, another for fine tuning).

When adjusting the inverting (-) input voltage to about the same as the non-inverting (+), I've discovered that there was a lot of noise coming from the output. It's definitely mostly Arduino connected to my computer via USB...

There's only one way to find out: unplug Arduino and try the experiment without it. Which is exactly what I plan to do next -- tomorrow!

Replugging Arduino to a separate power supply did not help much, by the way -- it still gives some noise, although it is smaller, than with the Arduino board working near the op-amp circuit.

Update: it turned out that indeed Arduino was the offender, but not only it. In fact, simply plugging in an unregulated power supply to it gives even more noise -- that was even pretty loud on the speaker! Giving voltage to the op-amp via a 7805 voltage regulator (or anything similar, I suppose) gave me a virtually noiseless output -- at least nothing, that I could hear from the loudspeaker anymore. This would mean that using a regulator in a circuit such as the γ-radiation detector is clearly a must.

An Arduino-based home-brew voltmeter

2010-08-01T13:16:00.045+03:00

Today in the morning I came up with a simple circuit to learn using shift registers, such as the NXP 74HC164N. I decided to try it out as a serial-to-parallel converter and it quickly worked, something I am really happy about. :)

There was some usual pain in setting up the 7-segment display wires so that they go in a standard A-B-C-D-E-F-G-dot way and the standard control codes can be used. These segments are not aligned the same way as they're usually addressed and there is no way of getting rid of that wire mess, at least not without compromising their positioning... But once it's done and verified, the result is rewarding. :)

It quickly came to me as an idea to make this output a bit more interesting than just sequential numbers (as I initially did), so I hooked up an Arduino's analog lead to a potentiometer in a voltage dividing circuit fed by 3.3V source from the Arduino board.

In order to multiplex 3 seven-segment LED displays, only 6 control wires are required: 3 for switching between individual display digits, 3 others to control the shift-register: data, master reset and clock signal -- to set the most/least significant bit to a specific value, to reset all the bits and to shift the bits respectively.

So how does the shift register work?

It's very simple, really: set the register's input to a desired bit value (either HIGH or LOW) and then simply toggle the clock signal from LOW to HIGH and back to LOW again. The trick is to make sure, that by the time clock impulse goes back to low the shift operation manages to perform.

The time it takes for a logical operation to be performed by a logical IC is called propagation time. In the case of 74HC164 it's in the order of 100-200 nanoseconds, which is roughly equivalent to 5-10 MHz clock rate. Since the code given below works, it obviously means that in Arduino, with AVR working at clock rate of 16 MHz, it takes more than 2 clock cycles to call the digitalWrite function.

Arduino source-code

I've written the comments as verbose as possible:



// This represents pins on the Arduino board. Modify these numbers to match your 
// particular setup
const int CLK = 5, MRESET = 6, DATA = 2, DIGIT1 = 3, DIGIT2 = 4, DIGIT3 = 7;

// These were taken straight out of http://en.wikipedia.org/wiki/Seven-segment_display
// If you hook up your 7-segment display lead A to lead Q1 of the shift register
// (lead 3 in case of NXP 74HC164N) and so on, will result in the corresponding 
// number showing up on the display. For example, 0x5B will give you a "2".
int ledCodes[] = {
  0x3F,
  0x06,
  0x5B,
  0x4F,
  0x66,
  0x6D,
  0x7D,
  0x07,
  0x7F,
  0x6F 
};

// To reset the current register's contents, we just need to switch off MRESET pin
// for just a couple microcontroller's cycles
void masterReset() {
  // set MRESET to LOW and then HIGH to reset the register IC
  digitalWrite(MRESET, LOW);
  digitalWrite(MRESET, HIGH); 
}

void clockPulse()
{
  // according to the 74HC164 datasheet, its response time is at most 200 ns, 
  // which is equivalent to a maximum of 5 MHz clock rate. It's > 3 times
  // slower than Arduino's clock rate, but it works, since function calls
  // do take up cycles too.
  digitalWrite(CLK, HIGH);
  digitalWrite(CLK, LOW);
}

// This procedure sets individual segments taken as bits in the "code" argument
void setShiftRegister8bit(int code)
{
   for (int i = 0; i < 8; i++)
   {
     digitalWrite(DATA, (((1 << i) & code) != 0) ? LOW : HIGH);
     clockPulse(); 
   }
}

// Flash the digit display once for delayTime milliseconds
void flashDigit(int signalOutput, int delayTime = 1)
{
  digitalWrite(signalOutput, HIGH);
  delay(delayTime);
  digitalWrite(signalOutput, LOW); 
}

// This function makes a number digitValue to be shown on a digit on Arduino digital output pin digitIndex
void showDigit(int digitValue, int dot, int digitIndex)
{
    setShiftRegister8bit(ledCodes[digitValue] | (dot != 0 ?  1 << 7 : 0) );
    flashDigit(digitIndex, 5);
}

void setup() {
  
  // If you want to enable serial to e.g. log some debugging info, keep in mind, 
  // that pins 0 and 1 are also used for serial communications and will definitely 
  // conflict with your usage of these. 
  //Serial.begin(9600); 
  
  // set all the digital pins to output
  for (int i = 2; i < 8; ++i)
  {
    pinMode(i, OUTPUT);
  }
  
  // This is not required, but does show the possible usage for it.
  // Since we're using a common-anode LED display, this will result
  // in all segments to go on (if DIGIT* controls are all on too).
  masterReset();
  
  // This is done simply as a boot-time status check sequence: first switch everything on
  digitalWrite(DIGIT1, HIGH);
  digitalWrite(DIGIT2, HIGH); 
  digitalWrite(DIGIT3, HIGH);  
  delay(1000); // wait 1000 ms
  // and switch them off
  digitalWrite(DIGIT1, LOW);
  digitalWrite(DIGIT2, LOW);  
  digitalWrite(DIGIT3, LOW);  
  
  // Now go through all the segments one at a time
  for (int i = 0; i < 8; i++)
  {
    setShiftRegister8bit(1 << i);
    flashDigit(DIGIT1, 10);
    flashDigit(DIGIT2, 10);
    flashDigit(DIGIT3, 10);
    delay(50);
  }
}


void loop() {
  
  // this is where all the voltmeter magic goes:
  // AVR's ADC is 10-bit and thus this function returns values in the range of 0 to 1024.
  // To convert this to real values, we need to compute its fraction from 1024 and then
  // multiply by a factor, which I determined empirically: it was exactly two times more, 
  // than the expected value, when I tried to multiply it by 1000 at first.
  int value = analogRead(0) / 1024.0 * 500; 
  int i = value;

  showDigit(i / 100, 1, DIGIT1);
  int b = i - i / 100 * 100;
  showDigit(b / 10, 0, DIGIT2);
  showDigit(b - b / 10 * 10, 0, DIGIT3);
 
}

Some precautions

If you decide to try this out yourself, remember one thing: be careful trying to directly measure voltages in excess of the Arduino's AVR ATmega's chip's supply voltage, which is usually at 5V, but in some cases can be 3.3V. This might fry the ADC, rendering it unusable -- but I'm not sure. Check AVR ATMegaXXX chip's datasheet and your Arduino flavor's technical data, if you're in doubt.

You can still attempt measuring such voltages indirectly, by dividing it with a fixed-value voltage divider -- just get two resistors R1 and R2, which have such resistances, that

U_measured × R1 / (R1 + R2) < V_CC

where V_CC is the Arduino power supply voltage (as I said, it's usually 5V, although Arduino Mini, for example, uses 3.3V supply) and get the relative voltage out of the divider output -- it will always be proportional to the original voltage.

My first video blogging attempt: soldering quick tutorial

2010-07-31T20:44:00.004+03:00

Once more, to remember:

1) clean the tip up with a file until it shines, before heating the iron up
2) put a bit of soldering grease (flux) onto the iron tip before heating it up
3) just after heating up the iron (when it just starts fuming the flux), heat up a drop of solder, so that the solder coats the iron tip -- this will help distribute the heat around and make soldering much easier!
4) use flux on the contacts to make the liquid-hot solder stick to the joints being soldered
5) be quick, so that you don't overheat the PCB and its components -- don't keep the iron on the joint for longer that a second or so
6) solder components from two ends at a time -- this way it keeps correct alignment (the mistake I made in the tutorial was about not doing that)

Here's another tutorial by Sparkfun: Getting X onto board Y

About the linear voltage regulator

2010-07-31T01:14:00.100+03:00

Since I'm apparently failing miserably with my attempts to build the γ-ray detector by almost blindly following the schematics, I decided to make a step aside and instead do some practical study first to better understand the inner workings of each element of the construction.

Pic. 1. Common 78xx series voltage regulator ICs

Enter linear voltage regulator, a useful addition to any fine circuit, digital or analogue alike, where precise and noise-free power supply is required. The main function of a voltage regulator is to set the output voltage to a fixed value, which almost doesn't change at all with variations in the input voltage. So, no matter if you put 15, 12, 9 or 7 volts to the regulator's input, you'll get the same voltage in the output.

If precise and noise-free power is not needed (such as simply for powering LEDs), you'll be better off with a much simpler voltage divider circuit, essentially a pair of resistors... But if you're planning to play with some integrated circuits and micro-controllers, or a sensitive detector, you'll definitely need a fitting voltage regulator.

There are many models, but the most common are the 78xx series fixed and the LM317 series adjustable voltage regulators.

It's important to know one thing: the amount of current that a regulator can pass through is very limited. Accidentally overloading a regulator without proper measure to vent the resulting heat is certain death to it, something I have learned the hard way already.

For bigger cases, such as the TO-220 (see Pic. 1), the maximum current can be in the order of 1 to 1.5A. Higher currents are possible, but require a heatsink to be installed (this is why there is the round hole on the back plane of the case). Smaller cases, TO-92, for example, typically only allow small currents in the order of 100mA.

Note, that the smaller-case low-power regulators usually have an L in their model name, e.g. 78L05, LM317LZ.

There is a fair bit of information about these circuits in Wikipedia, so I'll try to focus on the stuff that's not there.

Fixed linear voltage regulator 78xx series

These are probably the most common voltage regulators available. The last two digits of the model numbers is the voltage, that these regulators give on output, e.g. 7805 output 5 volts, 7812 give 12 volts, etc.

Using these is very straightforward: just put your power supply's positive output lead (let's say, it's +12V) to the V_IN lead of the regulator. Middle lead goes straight to ground (the negative output of the power supply). The third lead is the regulator's output -- the voltage between this lead and the ground should be very close to the regulator's rated voltage.

It looks like this on a breadboard:

There's a caveat though, and probably the most significant disadvantage of a 78xx series regulator: by design, its output current matches input current. But since input and output voltages never match (minimum difference is usually about 2V), it means that part of the electric power has to go somewhere and it's heat.

For example, connecting a 5V regulator to a 15V power supply and feeding 0.1 A of current through it (loading it with just 50 Ohm of resistance) would result in thermal dissipation power of (15V - 5V) * .1A = 7W! All this power is converted to heat and makes the small IC heat up rather quickly.

Best way to avoid it is to set the voltage to as close to the desired output as possible. Take into account, that input voltage must be higher than the output by approximately 2V. So that would make a minimum input voltage of 7V for the 5V regulator. Keeping the current low (under 100 mA), i.e. only using regulators in low-power applications (driving low-power circuitry, such as microcontrollers, few LEDs or an LCD display as opposed to high-gain sound amplification, directly driving motors etc.).

If you need to step down a big difference of voltage (let's say, 30V to 6V), you need a transformer for that.

Adjustable linear voltage regulator LM317

These are not less common and are quite useful as well. This kind of regulators is not an easy thing to use, though.

To be honest, I'm still confused about it, as it's still unclear to me, what exactly does "adjustable" mean here. After hours of experimenting,

Unless I'm terribly mistaken, it seems to me "adjustable" means that regulated voltage can be trimmed by a very small amount (about 1% of the output voltage), making this adjustment very precise. These regulators can also be used as precise current limiters, too, by placing a resistor (such that the desired current would be I = U / R) between the output and adjust leads.

But it looks like for the most common purposes, like driving digital ICs and microcontrollers, this kind of regulators is an overkill. With a fixed voltage 78xx regulator it's very much simple to build a regulated power supply -- you only need the regulator IC. For the adjustable one, you will need at least one more discrete component -- a resistor.

Here's a schematic of LM317 used as a voltage regulator:

To the right you can see a list of resistances that can be used to set a particular voltage on the output.

What should you be careful about here? The R2 resistor. It must not be lower than approximately the value of 2 * R1, otherwise it will result in a very high current going through the R2 resistor, which will burn it (if it's not meant for such currents, of course -- a 125 mW resistor will be burnt for sure!).

Update

This graphic actually contradicts what I have said earlier about the trimming of the voltage regulator.

That's why I bought several regulators: during the course of my experiments I'm bound to burn some of them! Besides, buying 10 pieces at a time gives a decent bonus in price sometimes (e.g. 0.30 EUR vs 0.43 EUR a piece).

Trying another regulator actually showed me that my 2nd regulator was dead. By the way, the 1st one was completely burnt (wouldn't even pass current, save regulating anything) after I accidentally shorted it under 12 V for half a minute, only noticing that something was wrong, when it started smelling funny. :)

So yes, I was wrong about the fine "trimming", and I'm not surprised. With a working regulator I was able to change the voltage to ~6.8 V by taking a 177 Ω resistor (rated 180 Ω ± 2%) as R1 -- I didn't have any 240 Ω ones -- and setting the R2 resistor to 511 Ω (rated as 510 &Omega ± 2%) + the LED, which gives some additional resistance. Obviously, reducing the R2 resistor even more would lower the output voltage too -- removing the orange LED from the circuit reduces the output voltage to 4.87V.

The output voltage formula, taken from the LM317LZ regulator's datasheet is as follows:

V_OUT = V_REF ( 1 + R2 / R1 ) + I_ADJ(R2)

There is so-called "reference voltage" V_REF between the output and the adjustment leads of the regulator, which is usually set to 1.25 V. With V_REF = 1.25V for this type of regulator, the actual calculation would look like:

V_OUT = 1.25 × (1 + 511 / 177 ) + I_ADJ(R2) = 3.75 + I_ADJ(R2).

The last component is obviously critical here, with I_ADJ being in my case around 2.2 mA (in case this function is linear, which I doubt).

NOTE that V_OUT doesn't depend on the V_IN directly, and it's not a mistake: this is exactly what voltage regulator is supposed to do: keep the output voltage constant, ideally, no matter what power supply you set it to.

You don't really have to calculate much to get a voltage you need, though -- just get a 1K trimmer (it's a good idea to add another fixed resistor of about 100 Ω, if the trimmer is 0-1K range, otherwise you risk shorting and burning the regulator) and plug the voltmeter to the output leads of the regulating circuit and you're good to go: by adjusting the trimmer you can set the desired voltage.

If you know the limitations of resistors, then you might say, that resistance of resistors varies with their temperature (increasing when they heat up and decreasing when they cool down). Well, using metal or thin film resistors may help -- these have very low temperature sensitivity, in the order of 5-100 ppm/K (i.e. varying their resistance by 0.005-0.1% per kelvin). I had some of my resistors heat up to ~100^oC (burning on touch), but it looked like their resistance didn't vary so much to be detected by my cheap multimeter... =)

A tutorial on solid-state radiation detection and more

2010-07-28T12:13:00.030+03:00

I've already give a link to one of the pages of this resource hosted by Carrol & Ramsey Associates, a R&D company from Berkley, CA, USA specializing in building cyclotrons for scientific and medical needs (as well as things associated with that, such as, well, radiation detectors and such), but here's another good page describing PIN diode-based radioactivity detection in very nice detail: Detection of X-ray and Gamma-ray Photons Using Silicon Diodes. Very good reading to educate oneself in this stuff.

Looking at the tutorial's pictures, it appears like MAXIM's application note 2236 was based on same ideas from or may be even directly on it (simply modified to fit the MAXIM's own components). But unlike that appnote, the tutorial has much more detail on the role that leakage currents and terminal capacitances have on the signal-to-noise ratio of the solid-state radiation detector.

Anyway, the tutorial gave me an idea that I might even use 12 V for the amplifiers and as much as 20-30 V for the diode, instead of 5 and 12 V respectively, since the opamps I used are made for voltages up to 15 V and the diode I chose (SFH203FA) can be used with up to 50 V reverse-bias voltage (although leakage current increases with voltage). This can increase sensitivity, but will also increase noise levels.

γ detector progress

BTW, I've already attempted a build of a variation of MAXIM's design (using TL074CN's instead of MAXIM's opamps), but it didn't work at all. Instead of the missing 10 nF capacitors I used 100 nF ones, hoping that it wouldn't matter so much... Well, apparently, it does matter after all. :) And without a sensitive oscilloscope, I can't really tell, what's the actual problem -- it might be everything from the wrong RC-components filtering out the signal, opamps being too slow to respond on the signal, a mere error in connections or even a problem with breadboard's own stray capacitances and high resistances...

Once the missing capacitors reach me, I'll change the wrong capacitors and see, if that will improve anything... If not, I'll go back to the whiteboard. :)

Here are some pictures of what I've made so far:

The LED shows that the circuit is on. So, ideally the piezoelectric speaker (that annoying PC beeper, seen on the bottom of the pictures) should make distinctive audible clicks. Currently it doesn't though for the reasons stated above. :) I'm going to tweak it some more and see, if it works then.

The chips are two TL074CN low-noise JFET double op-amps (seen on the left one under the other), the LM311P comparator (bottom right) and a 7805 voltage regulator (top right).

Ah, yes: the +12 V supply was straight from the cheap universal 0.5 A wall socket adapter. So it's probably very noisy. I'm going to use the LM317 adjustable voltage regulator to make it more stable.

UPDATE:

So far I had little success making this thing work, so I'll try to give some insights about the elements used in this circuit to, first of all, troubleshoot my construction and in the meantime also help you, the reader of this blog, to better understand, how does this stuff work -- resistors, opamps, comparators, capacitors, band-pass filters etc. etc.

Inventory additions

2010-07-23T01:16:00.012+03:00

Today I got my last part of components for the electronic project I'm going to make. This is what I used to have until lately.

Electronic stuff

Now I've got some 100 more resistors (1 and 10 M ones), some small signal diodes, more LEDs (this time wide-angle ultra-bright ones), comparators and 555 timer ICs. =)

These are MAX986 comparators in a tiny SMD package. Gonna need some 1337 soldering skills to put on a PCB...

This is all I should need to start building the photodiode-based Geiger counter. =)

A DIY Geiger counter for less than 30 EUR

2010-07-22T14:03:00.283+03:00

This is a somewhat improved translation of my earlier post in LiveJournal.

Intro

If you've ever wondered (by just being curious, for example...) about the prices on working Geiger counters, then you probably know that their prices range in 30 to 50 EUR (for a simple hand-held device weighing about 1.5 kg without batteries) -- even for a device with doubtable working condition. Using contemporary semiconductor technology and some easily acquired passive components, which you can buy in any well-stocked electronics (of the ELFA and Oomipood type) shop:

PIN photodiode, preferrably low-noise and low-capacitance (from 0,30 to 3,00 EUR)
2 ultra low-noise opamp ICs (used for e.g. higher-end audio equipment, < 4,00 EUR a piece)
1 comparator IC (< 4 EUR)
A bunch of capacitors and resistors with values such as 100 nF, 10 nF, 4.7 pF, 10 MOhm, 1 MOhm, 100 k, 150 k, 10 k... It's best if you take some precision devices, but for a crude proof-of-concept project, common ones should probably suffice. Total cost is about 2-4 EUR
Prototype board (<5 EUR)

Everything for a total of less than 20 EUR. You would also need a stable power supply, which can provide 5 and 12 V (you can use a set of 1.5 V batteries and a voltage regulator IC).

For comparison, cheaper Soviet and Russia-made Geiger-tubes cost about 10-15 EUR a piece, those of various Western produce -- e.g. 93.95 USD a piece.

The trick is that PIN photodiode can be used as a relatively low-quality (depends on what kind of quality you're going for) substitute for the Geiger-Müller tube. Of course, function principle is different from the bigger tube-based device, but the end result is almost the same -- when a gamma particle hits diode's PIN substrate, it activates the photosensitive part of the diode and lets a short current impulse through it (I believe, setting diode's into breakdown mode), producing a tiny voltage spike. That spike can then be filtered out and greatly amplified with low-noise op-amps to produce a discrete impulse with a comparator. That impulse can then be processed by digital circuitry, such as microcontrollers -- Arduino, too.

Using Arduino, you can then count number of gamma-particle hits per unit of time and use it to judge the amount of radiation in the given point in space. By roughly adjusting your device on your local background radiation level (which may vary a lot, depending on where you live), you can then invent numerous ways to use it -- and there are many cool ways to use it.

The project

Since this project is a work in progress, schematics and a step-by-step building process will be published in this blog as I'm progressing with my build myself. I'll try to go through all the problems I faced and the ways I have solved them here.

Refer to this page for some more information about the design of the "solid-state" Geiger counter: Project #1: γ-photon detector.

Some ideas on Geiger counter uses

1. Primitive radiation measurement

The most straightforward use for a Geiger counter is of course to measure radiation levels. Unfortunately, to be used as a precise measurement instrument, it has to be well-calibrated and made of special precision components, which cannot be done without a radioactivity sample with a known radioactivity value and a lot of shopping around... But it's possible to make a relatively crude, but nevertheless useful tool by calibrating it to the local normal background radiation level and providing a scale of 10, 100 and 1000 times relative values for comparison. By knowing your local normal radiation level, which usually doesn't change much in time, you can estimate an approximate level of your readings in SI units.

One clearly visible downside for the detector is that it can only detect gamma particles and maybe also fast neutrons, if you're lucky. Alpha and beta particles are invisible to it, which is a significant downside, since such radioactive sources, such as Uranium-238 (one of the most common radioactivity sources) and its products are alpha-emitters.

2. "Quantum" random number generator

By using a Geiger counter, it's possible to create a cryptographically secure "quantum" random number generator. While a home-brew design will unlikely be fit for encryption of state secrets, it will definitely be a cool geeky gadget for your 2048-bit PGP key generation to encrypt your ~~private videos~~ credit card numbers. =) The first that comes to my mind is counting the delays between received gamma particle strikes. These pulses though appear pretty rarely in normal circumstances: even my ДП-5А gives a click once per 1-2 seconds, which means that it will only be possible to generate just a handful of random bits per minute. I don't think that photodiode-based device will give a better result, since the number of caught particles directly depends on the size of the detector's active part, which is less than half square millimetre in a diode. But with a reasonable radiation source put in front of the detector it's possible to get a steady stream of really random bits...

Here's a couple of interesting articles about an RNG based on the same principle (but, again, on Geiger tubes instead of PIN diodes): https://www.sparkfun.com/commerce/tutorial_info.php?tutorials_id=132
http://www.fourmilab.ch/hotbits/how3.html

3. Radiation source direction finding

Although I have some doubts about this, but it seems to me that if a lead case is to be cast for the photodiode with sufficiently thick sides (1-2 cm should suffice) and with only one thin hole punctured through to the diode, which would work as an ionizing particle collimator, then it could be used as a remote Geiger-counter... It could be then used for finding various sources of radiation, natural and human-made alike. The trick is that lead is an pretty effective radiation shield (although second to depleted uranium). 1 cm of lead stops half of radiation power. Therefore, by pointing this device to a source of radiation, we should be able to notice a spike in radiation levels. If the hole is made wide, then it would increase the device's scanning area to a line, instead of a dot, which could be used to scan areas of interest to find radiation sources relatively quickly.

Just as a side idea, I think it should also be possible to make "radiation photos" of such areas by making a camera obscura out of lead and photo paper. The diaphragm should be covered with light-stopping material, so that we only picture the ionizing radiation.

All in all, the possibilities are endless. DIY Geiger-counter's plus is that you can use the same device for many tasks at once -- after all, nothing stops you from designing it in such a way, that it could be used for radiation measurement, ... =)

The problem is that such a camera would only allow through just a tiny fraction of gamma particles that fly around, which would make the Geiger counter even slower than it already is (thus probably unsuitable for quick surveying).

Appendix 1. Radioactive sources in Estonia

You might not know, but the first Soviet nuclear bomb was manufactured from uranium originated from Sillamäe, Estonia. That place is only special, because uranium ore comes almost to the surface there and is thus very easy to extract, without much digging required. Otherwise, same uranium ore can be found half around Estonia from the surface in the North-Eastern side of Estonia (where Sillamäe is located, too) to 200-300 m deep in the Central Estonia.

Here's a bit of more information about the uranium-rich sedimentary rock mineral argillite: http://www.ut.ee/BGGM/maavara/dityoneema.html

Argillite distribution map of Estonia: colour lines code the thickness, dashed line -- depth. As you can see it can even be dug up in Tallinn -- right near the surface. It appears like it becomes naked in Türisalu and on Pakri peninsula, too.

Although uranium concentration in Estonian rocks is an order of magnitude bigger (up to 200-400 ppm or 0.02-0.04%), than on average in the Earth crust (2-4 ppm, 0.0004%), Estonian argillite is a low grade ore. Even 0.1% is deemed a low-grade ore. Besides argillite, Estonian phosphate and oil shale also contain notable portions of uranium.

Because of sufficient amount of uranium in the soil, its decomposition products are also present, Radon is one such product. Radon is a dangerous thing, since it's an alpha-emitter and it's also gaseous. Alpha-particles are fast-flying helium ions (He²⁺), they are almost completely harmless to humans, when strike us outside, since aplha-particles cannot get through our skin, as opposed to harder radiation types, such as fast neutrons and gamma radiation, but when they appear due to decay of radioactive elements inside us, they can easily destroy our cells inside and are a serious source of risk for cancer.

But even regardless of radioactivity, uranium is toxic, because it's a heavy metal and has health effects similar to lead. Because of that, just for the sake of health security, I wouldn't be holding uranium or its minerals at home, at least if the containers are not sealed.