Entries by Thomas Kolb

Hello everybody,

recently, I decided to power my Raspberry Pi from my solar battery. However, before I could do that safely, I needed some deep discharge protection for the battery, which had to switch off the Pi when the battery voltage becomes too low.

Most available solutions for this problem missed one of the features I wanted: low current in “off” state, no relays (as the use too much power while active) and low price. So I designed one myself:

You might also want to get the image of the copper layer (SVG) in case you want to etch the board yourself.

In this circuit, the 7555 timer IC is “abused” as a simple monostable flipflop. When the “Power On” button is pressed, the trigger input (TR) is pulled low, which sets the Q output of the IC to 12V and consequently switches on the FET. This state is kept until the voltage at the threshold input (THR) exceeds two thirds of the supply voltage. As the supply voltage is the battery voltage, it will decrease while the battery is discharged. The voltage at THR will also decrease, as it is connected to the supply voltage. However, THR has a specific “minimum level”, which is set by the Z-diode, so at some point, the voltage at THR will be higher than the threshold of 2/3 the battery voltage and Q will be pulled to ground. This causes the load to be effectively disconnected from the battery. Even if the battery voltage rises again (which it does, because the load is disconnected), the load will stay disconnected until the button is pressed again.

In my version, the circuit itself draws about 0.5 mA when the outputs are switched off and 0.6 mA when the outputs are switched on, but without any load (so having the OKI-78SR powered without load doesn’t make a real difference).

If you want to build this board, take care to use the 7555 timer IC in the final version. For a simple test, you could also use a normal NE555 (or similar), but those are not very power efficient (idle current is about 10 mA compared to <0.5mA for the 7555).

The raw costs of the whole board are less than 10 €. The most expensive part is the OKI-78SR with about 4 €, the prices of the other parts are mostly below 0.50 €.

So this little circuit fulfills all my requirements and even has the 5V regulator built in. With this I can finally run devices with solar power without having to worry about the battery.

Hi again!

This time I’d like to show another project I’ve worked on recently. I call it “Musiclight”, as that describes quite well what it’s all about .

My goal is to visualize music using RGB LED strips, in a way that it actually enhances the listening experience (for example, impressive transitions in the music should cause impressive transitions in the light).

The idea for this existed for more than 2 years (I learnt how a DFT worked around that time ), and I tried different methods of visualization since then.

The Hardware

Most of the time, I used a simple RGB LED strip which could only have one color at a time. I tried calculating colors directly from the music (which caused extreme flickering) and extreme averaging (which turned out to be the best solution for single-color strips, as it showed the “mood” of the music over a longer time). However, I recently got my hands on a LED strip with multiple, individually setable modules (like this one), which made totally new things possible.

The RGB LEDs on each module are controlled by a WS2801 chip, which features a serial (shift-register like) interface and 3 output channels with 8-bit PWM. The modules can be daisy-chained to make longer strips which can still be controlled by a single microcontroller. The strip I’ve got consists of 20 such modules.

To be able to control the LEDs using my laptop, I wrote a driver for the Ethersex firmware, which runs on my AVR Net-IO. The driver takes commands through a binary UDP-based protocol and sets or fades the module’s colors accordingly. The LEDs are updated in fixed intervals of 40 milliseconds, which is enough to remove any visible steps in fading.

Here are some pictures of the hardware setup:

The Software

On the laptop, I wrote a program that takes audio samples as input, does it’s calculations to generate some nice visualization and sends the result to the Net-IO.

Currently, the algorithm works roughly as follows:

1. Calculate the FFT of the incoming samples
2. Divide the FFT into three frequency bands: 0 - 400 Hz, 400 Hz - 4 kHz, 4 - 20 kHz. For each band, calculate the “total energy” and convert that into a brightness value. This brightness value is then mapped to the red, green or blue channel.
3. Move each module’s color value to the next module and insert the new color at the first module.

You can get the code from my git server. Or clone it directly:

git clone git://git.tkolb.de/musiclight2.git

Please note that the program is not really portable in it’s current state.

Demo video

I hope you’re still with me, as here comes the interesting part: A demo video!

There is also a high-quality version with better sound quality and full 720p resolution (all my DSLR could give me at 30 fps ). And yes, the music is edited in, but there was no significant delay between music and visualization in the real world, too (and you wouldn’t want to hear the original recording from the DSLR anyway, would you?).

The song in the video is taken from Professor Kliq’s album “Curriculum Vitae” and is available under the terms of the CC BY-NC-SA 3.0 license.

Future plans

Despite the current visualization looks really good (in my opinion), there are still some things that I’d like to improve.

• The first and most important missing feature is some kind of scripting support, which makes it easier to change the visualization algorithm and the configuration (now one has to recompile the program every time anything has to be changed).
• Ultimately, a real hardware implementation would be nice, so you have a device you can plug between your CD/MP3/whatever player and the amplifier and get a nice visualization. However, that goal is currently far out of my reach.

Hi there!

Such a long time after my last post, here is an update about the Quadrocopter project.
The short version: It’s working!

And it works quite well, although it took a lot of tuning and testing to get it stable (and there’s still room for improvement).

However, before it worked, there were some problems to solve.

The first and most serious problem were the propellers, which were very badly balanced. This caused vibrations which the Software couldn’t compensate and made the Quadrocopter very unstable in flight. It took almost 2 months before I determined the propellers as the cause of the stability problems, as I always looked for a problem in my Paparazzi config and tried to solve it in Software, because I thought the vibrations were normal (they didn’t feel that serious when holding the Quad in my hand). However, when I balanced the props using small strips of tape, the stability problems were mostly gone.

Next I had to tune the control loops, which I mostly did by trial-and-error, trying to find the most stable settings. They still are not perfect, but they work in most cases.

I also managed to get the altitude controller working, which measures air pressure to determine the current altitude and then tries to hold the Quad at the same level. This works very well as long as there is not too much wind. However, with wind, the pressure levels vary too much so the Quad won’t stay at the current altitude level. But as flying with strong wind is not really much fun anyway, this isn’t a real problem at this time.

All in all, I’m very happy with the current performance of the whole system, even though it’s not perfectly tuned. I'm currently having a lot of fun flying this great aircraft .

At this point, I’d like to express my thanks to the Paparazzi project and all it’s contributors, who did (and are doing) a great job in creating all the hardware and software as an open-source project.

Finally, here are some pictures of the Quad in flight:

Here’s a gadget I finished some time ago: A 10 watts LED hand lamp with dimmer.

About a year ago, I bought a 10W LED from china, more or less just for fun. It turned out that these things are incredibly bright and so I used it sporadically as room lighting for some time. Then I got those lipo-batteries for my quadrocopter and thought: “Why not build a hand lamp from this?”. So here it is!

(yeah, I know it could be done better, but hey, it works!)

This case contains:

• The LED including heat sink
• The battery
• The LED driver (which I also bought when I bought the LED)
• The “controller board”, which converts the voltage from a potentiometer to a PWM signal, which is fed into the driver. Additionally, it measures the battery voltage and turns on a warning LED and a beeper (which sounds like a smoke alarm, just a little less loud ) if the voltage drops below 9.3V.

One battery charge will last for about 2 hours at full power. In reality, it will last much longer, as full power is much too bright for normal use at night (20% is mostly enough, so you get 10 hours of light). By the way: The photo on the left was shot at the lowest possible output power. If it wasn’t the whole picture would be black .

Another great thing is that this LED has a very homogeneous light distribution over it’s 120° aperture angle. So, if you carry this thing pointing straight forward, everything you see is brightly illuminated .