Tag Archive | "socket"

Tutorial: Video output from your Arduino

Create video output from your Arduino in chapter 35 of tutorials about the Arduino universe. The first chapter is here, the complete series is detailed here.

[Updated 10/01/2013]

In this chapter we will examine something different – the ability of our Arduino and compatible boards to create composite video output. In other words, displaying stuff from the Arduino on a TV. A lot of people were unaware of the ability to do this, however the process is very simple and not difficult to implement from a hardware perspective. Within this chapter we will learn to construct the minimum hardware required and demonstrate basic functions to get started.

To whet your appetite, here is a quick video demonstration of what is possible:

You can’t expect too much from a 16 MHz microcontroller without a video card… but the price is right, and with some imagination and the right functions you can do quite well. To make this happen we need to knock out some hardware of our own. Connection is very easy. First we need to locate three pins on our Arduino board. They will be used to output Sync, Video and also GND. For those with Arduino Uno/Freetronics Eleven etc Sync is digital 9, video is digital 7 and GND is … GND. If you have a Mega/Mega2560 Sync is digital 11 and video is A7. There is also the ability to generate audio with the methods in this article, and if you want to do this the Uno (etc.) pin is digital 11 or 10 on the Mega.

The monitor or television used needs to have a composite video-in socket (jack). For those with older televisions that have a VCR connected, you could use the video-in socket on the VCR. The schematic for video out is very simple, you only need two normal 0.25W resistors and a video lead:

If you’re not up for soldering into an RCA plug, a simple way is to chop up a standard video lead as such:

Then just wire the termination of the two resistors to the centre core (“pin”) and GND to the shield. For the purpose of this article I have made a quick TV-out shield that also includes a thumb joystick (as reviewed here).

A real triumph of engineering… however it solves the problem. The vertical trimmer is connected to A0;  the horizontal to A1; the button to digital 8 via a 10k0 pull-up resistor. Next, you will need to download and install the arduino-tvout library. It can be found here. We will use the TVoutBeta1.zip version.  Those of you who may have a nootropic design Hackvision – please note your library is different.

Now to see how to integrate TV-out into our sketch. We will run through the basic functions which integrated with your imagination should see some interesting results…  So let’s go!

For every project, place these two lines at the top of your sketch:

The first brings in the library, and the second line creates an instance of TV to use with the library functions. Next, we need to activate TVout and select the appropriate broadcast standard (PAL or NTSC). In void setup() use either

Now for the main functions. The first one of interest will be:

which … clears the screen. Or if you would like to fill the screen with white, use

Moving on – to write some text. First we need to select a font. There are three basic fonts to choose from:

  • font4x6 (each character being 4 pixels by 6 pixels, etc.)
  • font6x8
  • font8x8

Well there is four, but it wouldn’t display for me. Working on it! To choose a font use:

Then to write the text, choose the screen location with:

then display the text with:

You can also use TV.println(); to add a carriage return as expected. Display single characters with a position in the one function using:

So let’s have a look at the various fonts in action with the following sketch:


Now to move into the 1970s with some basic graphical functions. We have a screen resolution of 128 by 96 pixels to work with. When planning your display, you need to ensure that the sketch never attempts to display a pixel outside of the 128 x 96 screen area. Doing so generally causes the Arduino to reboot.

First let’s start with basic pixels. To draw a pixel, use:

where x and y are the coordinates of the pixel, and z is the colour (1 = white, 0 = black, 2 = inverse of current pixel’s colour). You want more than a pixel? How about a line:

Draws a line from x1, y1 to x2, y2 of colour colour. (1 = white, 0 = black, 2 = inverse of current pixel’s colour).

Rectangles? Easy:

Draws a rectangle with the top-left corner at x,y; width w, height h, colour and optional fill colour. Circles are just as simple:

Draws a circle with centre at x,y; radius r pixels, edge colour, optional fill colour.

Now to see these functions in action with the following sketch:

And for the video demonstration:

So there you have it, a start with Arduino and TV-out. Furthermore, a big thanks to http://code.google.com/u/mdmetzle/ for the arduino-tvout library.


Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in arduino, COM-09032, education, lesson, tutorial, tv out, videoComments (42)

Kit review – ogi lumen Nixie Tube system

Hello readers

Time to finish off the month with a fascinating kit review  – the ogi lumen nixie tube system. The younger readers amongst us may be thinking “what is a nixie tube?” Here is an example of four in a row:


If you cast your mind back to before the time of LCDs, and before LEDs… to the mid-1950s. Nixie tubes were used to display data in various forms on electrical devices, from test equipment, scales, elevator indicators, possible doomsday machines, clocks – anything that required visual output would be a candidate. Although nixie tubes are now totally out of date, as with many things there is a growing trend to use them again, for cool retro-style, nostalgia and those people who enjoy living in the past.

How nixie tubes work is quite simple, an element is within a vacuum tube full of gas, such as neon. When a high-voltage (~190 volts DC) current flows through the element, it glows. For more information, here is a great explanation. You will note that they are similar to in look but different in design to the vacuum-fluorescent displays, as used in the ice tube clock reviewed a few months previously. The tubes used in this kit are the Soviet model IN-12A:


The IN-12A tube can display the digits zero to nine, with a nice orange glow.  For the uninitiated, sourcing and making nixie tubes can be quite difficult. Apart from procuring the tubes themselves, you need a suitable power supply and logic ICs that can handle the higher voltage to control the tubes. Thankfully Ogi Lumen have put together a system of kits to make using these nixie tubes simple and interesting. There are three components to the system, the first being the power supply:


Note that the power supply is preassembled. This supply can generate the necessary 150 to 220 volts DC to energise our nixie tubes. Yes – up to 220 volts! For example:


However the current required is quite small – one power supply can handle up to twenty-four IN12A nixie tubes. My example in the photograph above is drawing 110~120 milliamps from a 12V DC supply. For those of you assembling these kits, please be careful. It can be easy to physically move the kit about whilst in operation, and touching the live HV pads will hurt a lot. After bumping the HV line on the PCB, my whole left arm went into a spasm and hurt for the time it took to see my doctor. So be careful.

The second item required is the driver kit. This is a board that takes care of the shift-registers and power for two of the nixie tubes. Driver kits can be slotted together to form a row of nixie tubes. The third and final item is the nixie duo kit. This contains two IN-12A tubes, matching sockets and a PCB to muont them. This PCB then slots into the driver kit PCB. You can buy the driver and duo kit as a set for a discount.

From a hardware perspective, assembling the kits is relatively simple. There isn’t any tricky soldering or SMD to worry about, however you will need a lot of solder. The contents of the duo and driver kits are as follows:


Before you start soldering, please download and take note of the instructional .pdf files available for the duo and driver board kits. Assembling the driver kit (on the right) is very straight forward. However – please read the instructions! An interesting part of note is the K155ИД1IC:


This is the Russian equivalent of the 74141. This is a BCD-decimal decoder IC that can handle the high voltages required for nixie tubes. When soldering the resistors, take care with R2 – it will need to be positioned horizontally so as to not rub against the duo board:


When it is time to assemble the duo board, you will need time and patience. At a first glance, one would imagine that the sockets drop into the PCB, and the nixie tubes will happily be seated into the sockets. This is not so, don’t solder in the sockets first! The pins on the bottom of the socket also form part of the socket for the tube legs – which can alter the positioning of the socket legs. Make sure you have the socket with pin 1 at the top of the PCB. After some trial and error, the best way to insert the tubes is to first partially place the sockets into the PCB:


… then fully insert the tubes into their sockets. Make sure the tube is the right way up – check that the digit 3 in the tube is the right way up. Then push the whole lot into the PCB. At this point you should check to make sure the sockets are in line with each other:


(Notice how thick the PCB is…) At which point you can solder them in, followed by the row of connector pins:


By this stage you will need some fresh air from all that soldering. The PCB holes for the socket pins really take a lot. Now you can connect the power supply to the driver board and give the tubes a test-toast:


All the tubes should have their elements glowing. This is a good start. The next step is to connect the appropriate microcontroller and start displaying. As noted in the instructions, the 74141 BCD-decimal ICs are controlled by standard 74HC595 shift-register ICs, so your microcontroller needs to send out a data, clock and latch line. My following examples have been created using the Ardiuno system and a compatible board.

The first example is a method of displaying integers. It uses the Nixie library which you can download here.

That was just an arbitrary demonstration to get some numbers displayed. Here is a short video clip of it in action:

Now for another, more useful example. By using a DS1307 real-time clock IC with the Arduino, we can make a nice clock that displays the time and date. For more information on using the DS1307 with Arduino, please visit this tutorial. You can download the example nixie clock .pde file from here. And finally, here is the clock in action:

The problem with these tubes is that you will never have enough. Already I have thought of a few things to make that require a lot more tubes, so in the next month or so stay tuned to tronixstuff.com as there will be more projects with these kits.

In conclusion, this was a great kit and anyone looking to use some numerical nixie tubes will do very well with the Ogi Lumen products. Furthermore the designs are released under Creative Commons by-sa-nc, and the files are available to download from the product pages. And finally, it is a lot of fun – people will generally ask you about the tubes as they may have never seen them before.

Remember, if you have any questions about these modules please contact Ogi Lumen via their website. Higher resolution images available on flickr.

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

[Note – the kit assembled in this article was received from Ogi Lumen for review purposes]

Posted in arduino, kit review, learning electronics, nixie, ogilumenComments (11)

Project – ZIF socket Arduino-compatible board

In this tutorial we make an Arduino-compatible board that holds the microcontroller in a ZIF socket.

Updated 18/03/2013

Today we are going to make a different type of Arduino-compatible board, one that has a ZIF (“zero insertion force”) socket. Our reason for making this is simple – now and again you may need to program more than one bootrom with a sketch, for example if you were planning to make your own electronics kits that were based on the Arduino system. Your alternative would be to use a chip puller and constantly insert and remove microcontrollers from your usual Arduino or compatible board – which is bad for the board, bad for the chips (the friction and pressure on the legs, as well as possible static build-up), and bad for your wrist.

So here is our problem – we need a board with a ZIF socket:


The Eleven board is great, but we just cannot squeeze in the socket. So instead, let’s make our own. Like any project, the first thing to do is plan the circuit and make a schematic:


You have to hand it to the Arduino team, they have made things very easy for us. As we are not using this board for day to day use, all we need is enough circuitry to enable programming. In this case, the connection between the board and the PC will be made with an FTDI cable (these offer an interface between serial and the USB port):


Furthermore, we will use the 5 V power supply from the USB port via the FTDI cable as well. Easy! So now it is time to collect the required parts:


You will notice in the photo above there is a button, originally I was going to have a reset button, but after testing it proved unnecessary. Our required parts consist of:

  • one 28-pin ZIF socket, 0.3″ width (don’t fall into the trap of ordering the wide one)
  • An Arduino bootrom for testing, etc
  • one 16 MHz ceramic resonator (easier than using a crystal and two capacitors, timing is not critical as this is only a programming board)
  • 6-pin header strip to connect the FTDI cable to the board
  • an FTDI cable (the 5v one)
  • two 0.1uF ceramic capacitors
  • one 10k ohm resistor
  • some rubber feet (to protect your desk when using the board
  • some veroboard
  • hookup wire, some solder, and the usual tools

Before soldering away, it pays to test the circuit on a breadboard. At this stage you can test the operation, program the microcontroller, and test that microcontroller in another board:


Again, you can ignore the button. For testing purposes, I uploaded the “blink” sketch to the microcontroller, then tested that unit in the Eleven. The LED blinked as expected, so all was good. I repeated the process a few times, but uploaded a different sketch every second time, and re-inserted the bootrom between every upload. After ten cycles of doing this, I was confident with the design, so transferred the lot to the permanent veroboard:


The black marks on the board are to help me navigate, for example the arrow means the 5 V rail, etc. Now for the rear end:


There are high-resolution photos in flickr if you want to follow this design exactly.

Before using the veroboard, experience has taught me that they are always dirty and solder doesn’t take too well. If possible, try and clean your veroboard first with some cleaning spray, usually an aerosol package available from most electronics retailers. Or even just a damp cloth, then dry the board afterwards with a dry cloth. Moving on…

Before testing the completed board, please double check the routing and that you have cut the correct PCB tracks. If you are unsure about some solder joints, use the continuity function or resistance function of a multimeter to check for shorts between tracks.

After the board passed those tests, I stuck on the feet – and admired the finished product:


However, it was time to repeat the testing. If I may make a general observation, try and test things as you move along, step by step. For example, with this project, don’t skip the breadboarding step. It is important to check the design works. Don’t skip checking for solder bridges, or not double-check your routing. It is always much easier to fix a mistake when it has been made, then to have to troubleshoot a ‘completed’ project.

But at the end of the day, I now have something that is useful and will save me time during kit production (still in design stage people), making a few blinky offspring,  and prevent damaging my regular boards. High resolution images are available from flickr.

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in arduino, atmega328, COM-09420, freetronics, microcontrollers, projects, PRT-09175, tutorial, zif socketComments (6)

Subscribe via email

Receive notifications of new posts by email.

The Arduino Book

Arduino Workshop

Für unsere deutschen Freunde

Dla naszych polskich przyjaciół ...

Australian Electronics!

Buy and support Silicon Chip - Australia's only Electronics Magazine.

Use of our content…

%d bloggers like this: