July 25th, 2009

Silent Ceiling POV Display

Silent Ceiling POV Display

A persistence of vision (POV) display is a device that creates an apparently still image using rotating LEDs with great speed. The human eye is not able to distinguish every image individually, so the picture formed appears as a solid image. The POV phenomenon is not a new discovery and a lot of POV display projects have been made. However, this one right here has two different attributes that differentiate it from other POV displays: it is located on a fan placed on a ceiling and it’s silent.

This project uses a fan with 5 propeller blades and every blade has 32 LEDs mounted on it (that means a total of 160). These LEDs are connected to an Atmel microcontroller on an Arduino board. The POV display also uses 74HC595 8-bit serial-in, parallel-out shift registers that convert serial-in data into parallel-out data. The microcontroller generates the sequence in which the LEDs are lit, thus creating the image.

The location of the display makes it pretty cool and the fact that it’s attached to this kind of fan makes the whole device completely silent, which is quite different from most POV displays out there that are rather noisy. Having a thing like this blinking in your living room might seem like a good idea if you want to impress a guest audience, but other than that I can’t find a reason for actually using it.

Silent Ceiling POV Display: [Link]

July 18th, 2009

New TV-B-Gone Case Style

TV Disabler

Have you ever found yourself in a situation where you wanted to talk about something important or just simply wanted some peace and quiet while enjoying your drink and a damn TV wouldn’t shut up? Chances are you have. But from now on, you can use this little gadget to silence those TV sets that bother you with loud, uninteresting stuff. You can carry it in your pocket and you can surely have a laugh using it.

Humorously named TV-B-Gone, this TV Disabler can make some annoying situations quite entertaining. The TV-B-Gone can turn off most of the TV sets available, while having about the same size as a universal remote control. It is a nifty little kit made by Adafruit and it is available for purchase for $19.50. It possesses an Atmel ATTINY85V-10-PU programmed microcontroller, 4 IR LEDs used as emitters and a double AAA battery holder (you can find a complete parts list in the link).

The TV Disabler must be pointed at the TV you wish to quiet down. It has a single button that must be pressed and then it starts to transmit its signal using codes that are stored in its memory for all major TV brands. It takes about 2 minutes to send all the codes, but most TV sets will turn off. The TV Disabler also has a green LED that starts glowing once the device is transmitting.

Since the original kit from Adafruit doesn’t have a case, you can make one like the one in the picture above. This project uses a modified Miniature General Purpose ABS Box 1551 Series from Maplin Electronics Ltd. You will have to make 2 holes, one for the button, and the other for the LED. Putting it all inside the box may be tricky, but once you get it right you will have the TV-B-Gone ready and waiting. And you can say goodbye to those noisy TVs disturbing you.

don’t forget to check youritronics custom version of tv-b-gone.

New TV-B-Gone Case Style: [Link]

Twinkling LED Heart of Love

“Love is a smoke raised with the fume of sighs,

Being purged, a fire sparkling in lovers’ eyes,

Being vexed, a sea nourished with lovers’ tears.

What is it else? A madness most discreet,

A choking gall and a preserving sweet.” (William Shakespeare)

When in love it can be important to find the right gifts for the right occasions. You know, the kind of thing that would bring a big smile to her face (followed by a wet kiss). It can be difficult to even remember to buy a present, let alone come up with something that will be appreciated. But fear not! I have found the solution to the problem and next Valentine’s Day you will be ready to really impress your sweetheart.

The Twinkling LED Heart of Love is a wonderful DIY project that will melt her heart and turn the next 14th of February into an unforgettable event. The Heart of Love is based on an Atmel AVR ATmega168 microcontroller coupled with 20 red LEDs that… blink randomly! The heart itself can be made of cardboard and, although red is the usual color for love-related objects, you can show your creativity and paint it something meaningful to you and your damsel. Like orange, if you’re both Netherlands soccer fans. Or black, if you’re black metal fans (pentagram is optional). Originality is usually appreciated, so go for it!

Tips and tricks: your Heart of Love is awesome and will surely knock her socks off, but don’t start explaining how it’s made, how the microcontroller works and so on, because she might start yawning and eventually fall asleep.

As for me… I think I’ll settle for a big bouquet of red roses, thank you very much.

Twinkling LED Heart of Love: [Link]

I recently ordered some samples from TI, which included the TMP275 digital sensor. The sensor has some nice features which I quote from it’s datasheet:

The TMP275 is a 0.5°C accurate, Two-Wire, serial output temperature sensor available in an MSOP-8 or an SO-8 package. The TMP275 is capable of reading temperatures with a resolution of 0.0625°C. The TMP275 is SMBus-compatible and allows up to eight devices on one bus. It is ideal for extended temperature measurement in a variety of communication, computer, consumer, environmental, industrial, and instrumentation applications. The TMP275 is specified for operation over a temperature range of −40°C to +125°C.

The easiest way to get the temperature out of the TMP275 seemed to be I2C. So I started by designing a board which has all the components needed: the sensor, an atmega8 brain, and some other components needed for the display and for powering the board. The display is a 4 digit 7 segment display from kingbright product code CA56-12GWA. As for the display part of the board, I used PNP transistors on the common anodes and resistors on the segments to limit the current draw on the atmega’s pins. The transistors are not current limited so the display will alaways light-up the same no matter how many segments are turned on.

TMP275 digital thermometer board

For the supply part of the board, I choose to make it portable and power it from a 9V battery, so I needed to use a voltage regulator. The choice was the good old 7805 because it’s cheap and easy to find.

I2C is a pretty common protocol so various libraries can be found on the web. I chose Peter Fleury’s I2C library because it was very well documented. The only external components needed by the TMP275 are a bypass capacitor between VCC and GND and two pull-up resistors required on SDA and SCL lines.

All the I2C stuff is handled by the library, so I only had to write a couple of lines of code to get the temperature out of the sensor:

 i2c_start_wait(sensor+I2C_WRITE);	// set device address and write mode
 i2c_write(0x0);			// write pointer register 00000000 to select temp register
 i2c_rep_start(sensor+I2C_READ);	//set device address and read mode
 temp_high=i2c_readAck();		// Read high byte of temperature
 temp_low=i2c_readNak();		// Read low byte of temperature

After reading the temperature from the sensor I had to display it on the 4 digit display. For that I had to write a display macro, which figures out the numbers and how to display them, basically I used software multiplexing. I even tested it on negative temperatures by placing the sensor in my fridge :). The readout was correct because I checked with another thermometer.

These new type of digital sensors are great, because you don’t have to worry about analog to digital conversion, all the  ADC is done inside the sensor. I mainly started working with this sensor because I want to incorporate a temperature reading function into a future project. Now that this part is done, is time to move onto the next one, ultrasonic range finder, which I’m guessing wont be as easy as the temperature reading.

I tried to comment every line of my code, but if you feel you don’t understand something, just post a comment and I’ll reply.

Seven segment display

In this article I intend to explain the functionality and usage of the seven segment display, probably you have seen many projects with these type of displays, however the price drop of LCD’s tend to overtake the market, there are a still few applications for which these devices are more suited. For large numeric displays, like clock’s, railway station displays, low-cost measuring devices or very stressing environments the led based displays are better, and cheaper.  The most simple led display available is the seven segment display, it consists of 7 led stripes arranged forming the number 8, because of its simple construction it is very robust and can function in very low or high temperatures, can withstand vibrations,  mechanical shocks without problems, for what the LCD would fail to work or even get permanently damaged.

single sevene segment

If we look at one digit we can see 10pins each segment and the small dot are LED’s, each of them has one terminal connected to a common pin, from this comes the name common anode or common cathode, and the other terminal is connected to a standalone pin, since the common pin is doubled, we have the 10 pins for each digit.

seven segment config

Lets take as example the common anode type, to light the segments we need to connect the positive supply rail to the common pin, and pull to ground the segments, each segment depending on its size can handle a few miliamps, after all we are talking about LED’s not bulbs. That’s fine if you need just one number to display, but how can these digits be connected to form a multi-digit display? The first approach is to connect each segment to a micro-controller pin, this way for each digit you need 8 pins and isn’t elegant at all.

The other solution is to connect each corresponding segment from the digits to a common bus, and power the digits one at a time, thus multiplexing the data.

seven segment schematic

This multiplexing probably sounds more complicated than it really is, look at the next picture:

illustrated seven segment operation

Since the digits share the same data bus, each digit will have the same number displayed, like the wheel on the picture, to change the number the “data guy” rotates the wheel. So how can we display 1234 you might ask, well wee need another guy, the selector, which will leave only one digit to be seen, all the others are shut off, by synchronizing the “data guy” and the “selector guy ” so they operate at the same time, when the wheel is at the 1111 position, the selector opens the first window, when at 2222 it opens the second and so on. By changing the data and selecting the digits at many times per second the human eye will see a steady image with 1234, the display refresh rate should be above 50 times in 1 second, otherwise the image may flicker.

In the schematic the “selector guy” is implemented by the PNP(BC327) transistors and the “data guy” is the data bus (PORTB0..7). For the practical demonstration I used my own avr development board with ATmega88, four HD1131R type seven segment digits which I rescued from an old TV a few years ago, the connections are made on a prototyping pcb with scrap wires. The data port is PORTB, for selection the PD4..PD7 pins where used.

Like I mentioned earlier we need a periodic data update with digit selection to have a steady image, and since the entire display refresh should be above 50Hz and we have four digits we need to change the digits at frequencies greater than 200Hz. Since the amount of time which one digit is turned on is 1/digit count, as the display has more digits the light intensity gets weaker, in our case the HD1131R has 1.6V voltage drop, by powering from 5V and trough 330Ohm results 10mA trough each segment, but since we have 4 digits the average current received by each segment is 10/4=2.5mA, this will result in a very fade light. For the demo application I used 220Ohm values, with the on board 100Ohm resistors the average current is 2.5mA/segment, although I could have used only the on board resistors, thus having 8.5mA average current, but the peak would be 35mA, and the micro-controller can handle at maximum 25mA/pin, off course the pin won’t get blowed right away from 35-50mA, but you should be careful when designing similar circuits.

That’s enough about the hardware, let’s see the software, for the periodic refresh I used a timer interrupt with 244Hz, resulting in 61Hz refresh rate, in Europe we have 50Hz AC power, so that’s fine, but in the case of 60Hz AC power the refresh rate should be at 70Hz to avoid the stroboscopic effect.

For the display data I used 4 byte buffer from which the interrupt reads and sends to PORTB, the buffer index can be used also for digit selection(see void DisplayData(uint8_t* Display) ).

Because of the seven segment data format by directly writing 5 to PORTB, won’t result in displaying 5, so the numeric data must be converted first, because there isn’t any easy algorithm to mathematically make this conversion, we must use another method, for a one digit display you could make if-else or switch statements, but with 2 digits you already need 100 lines of code, for 3 digits 1000 lines and so on. A very handy solution is a look-up table:

const uint8_t DigitCharTable[] = { DigImage0, DigImage1, DigImage2, DigImage3, DigImage4,\
DigImage5, DigImage6, DigImage7, DigImage8, DigImage9, };

By indexing the table with the numeric value 0-9 we get the needed data format, example PORTB = DigitCharTable[5]; results in displaying 5;

The void NumToDispValue(int16_t Number, uint8_t* DataBuffer) function uses this method to convert 16bit signed value into display compatible string.

After the conversion made, the actual display buffer needs to be updated with the new value, here is a tricky part, by converting 1234 into display compatible data we will have [DigImage1, DigImage2, DigImage3, DigImage4], by having DigImage1 at the first position and my display has  D4,D3,D2,D1 physical configuration the data displayed will look like this: 4321, it gets reversed. This can be overcome by reversing the selection lines PD4..PD7, or by copying the reversed string into the display buffer(see void StrUpdateDisplay(uint8_t* DisplayBuffer, uint8_t* UpdateData, uint8_t InvDir)  ).

After the conversion, the result is a string(not ascii!), so the string manipulation techniques can be easily used, the dot can be added to any digit, simply by setting the 7-th bit in that byte(see macro WITHPOINT(a) in SSDisplay.h ). There is also possible to display a limited amount of characters like E,F,c,C.., (see SSDisplay.h) it won’t be pretty but it’s readable.

Last but not least, since the refresh is done in interrupt, the display buffer update operation should be made atomic, in other words first disable the refresh interrupt, and then update the buffer, otherwise the image will flicker, and don’t forget to re-enable the interrupt after!

If you use only the refresh interrupt, than it’s easier to just disable all interrupts globally, although if you have other interrupt sources too, then disable only the refresh interrupt, this way you won’t hold back the other incoming events.

For data source I used the ADC to measure the potentiometer output, you can also tweak the macro’s used to handle the ADC, the dot in the 2th digit is activated if the ADC value  is above 512.

The demo project was made using avr-gcc and avrstudio, some variable type notations may differ from the ANSI C standard since I use the avr-gcc typedefs, the entire project among with schematics, pdf’s is available for download.

In the next article I will explain the usage of the matrix keyboard.

Seven segment display explained: [download]



© 2007-2011 YourITronics | Any logo, trademark and project represented here are property of their respective owners | Wordpress | Privacy Policy    RSS