Archive | dice

Build an Arduino-controlled Larson Scanner

Introduction

For fun and a little bit of learning, let’s make a Larson Scanner. This isn’t a new project, for example we reviewed a kit in the past – however after finding some large LEDs we decided to make our own version. We’ll use an Arduino-compatible circuit to control the LEDs, and explain both the hardware and required Arduino sketch – then build a temporary small and a more permanent large version (and a bonus project).

So what is a Larson Scanner anyway? Named in honour of Glen A. Larson the creator of television shows such as Battlestar Galactica and Knight Rider – as this kit recreates the left and right blinking motion used in props from those television shows. For example:

Making your own is quite simple, it’s just eight LEDs or lamps blinking in a certain order. If you’re not familiar with the Arduino hardware, please have a quick review of this tutorial before continuing.

Small version

If you’re just interested in whipping up a solderless breadboard or small version, it will take less than fifteen minutes. Just get an Arduino Uno or compatible board and construct the following circuit (the resistors are 560Ω):

Arduino Larson Scanner

The sketch is also very simple. There are two ways to address those digital output pins, and to save sanity and clock cycles we’re going to use port manipulation instead of many digitalWrite() functions. So for our circuit above, enter and upload the following sketch:

Notice how the ones and zeros in the byte send to PORTD (digital pins 7~0) represent the “movement” of the scanner? You’d have to agree this is a better method of addressing the LEDs. Have some fun and experiment with the patterns you can generate and also the delay. In the following video we’ve quickly demonstrated the circuit on a solderless breadboard using different delay periods:

Large Version

Now to make something more permanent, and much larger. There are many ways of completing this project, so the following version will be a design narrative that you can follow to help with planning your own. The first consideration will be the LEDs you want to use. For our example we used some Kingbright DLC2-6SRD 20mm bright red versions we had in stock:

KINGBRIGHT DLC2-6SRD

However you can use what you have available. The key to success will be driving the LEDs at their maximum brightness without damage. So you need to find out the best forward voltage and current for the LEDs, then do some basic mathematics. From our example LEDs’ data sheet, the maximum brightness is from 60 mA of current, at just under 6 V. A quick connection to a variable power supply shows the LEDs at this setting:

LED on

We can’t get this kind of brightness from our Arduino 5V circuit, so instead we’ll increase the circuit supply voltage to 9V and use resistors to reduce the current for the LEDs. To find the resistor value, use the following:

resistor formula… where Vs is the supply voltage (9), VLED is the forward voltage for the LED (5.6), and ILED is the forward current (60 mA). The value for R is 56.66 Ω – however you can’t get that value, so 68 Ω will be the closest value from the supplier. Finally, the power of the resistor required (in watts) is calculated by W = VA. So W = 3.4 (voltage drop over resistor) * 0.06 = 0.204 W. So we’ll need 68 Ω 0.25 W resistors for our LEDs. Thus instead of running the LED straight off a digital output, it will be switched on and off via a simple BC548 transistor – shown in the following schematic example:

transistor switchThe digital output for each LED is connected to the 1k Ω resistor and thus switches the transistor on to allow the current to flow through the LED when required. This is repeated for each LED we intend to use – which for the case of our large scanner project is six. (Why six? Someone bought a board which was too narrow for eight…) Next is the Arduino-compatible circuit. Timing isn’t critical so we’ll save components by using a ceramic resonator instead of a crystal and two capacitors. And as shown below (note that although the image on the microcontroller says ATmega168, we’ll use an ATmega328P):

basic Arduino circuit

(If you’re not up for making your own Arduino-compatible circuit, there’s plenty of alternative small boards you can use such as the Nano or LeoStick). Although the symbol for Y1 (the resonator) looks complex, it’s just a resonator – for example:

resonatorthe centre pin goes to GND and the outside pins go to XTAL1 and XTAL2 on the microcontroller. It isn’t polarised so either direction is fine.

At this point you may also want to consider how you’ll upload and update sketches on the project. One method is to mount the microcontroller in a socket, and just yank it between an Arduino board to upload the sketch, and then put it back in the project board. If you use this method then you’ll need a microcontroller with the Arduino bootloader.  However a more civilised method is to add ICSP header pins – they’re the 2 x 3 pins you see on most boards, for example:

ICSP

With which you can use a USBASP programmer to connect your board directly to a computer just like a normal Arduino. Just use Ctrl-Shift-U to upload your sketch via the programmer. Furthermore you can use bare microcontrollers without the bootloader, as all the necessary code is included with the direct upload. So if this method interests you, add the following to your circuit:

ICSP schematicThe RESET pin is connected to pin 1 of the microcontroller. Speaking of which, if you’re unsure about which pins on the ATmega328P are which, a variety of suppliers have handy labels you can stick on top, for example:

ATmega328 Arduino label

At this point it’s time to put it all together. We’re using a random piece of prototyping PCB, and your final plan will depend on your board. As an aside, check out the Lochmaster stripboard planning software if you use stripboard a lot. As mentioned earlier your final schematic will vary depending on the number of LEDs, their requirements with respect to current and your choice of Arduino platform. By now you have the knowledge to plan the circuit yourself. After some work here’s our final board:

larson scanner

… and the scanner in action. We used the same sketch as for the temporary version – however reduce it to six outputs (D0~5) to match the LEDs.

 Bonus project – Electronic Die

What else can you do with six LEDs? Make an electronic die! Here’s a simple sketch that simply picks a random number every five seconds. The random number generator is seeded from unused an analogue input pin.

And a quick video of our die in action:

Conclusion

We hope you found this interesting and at least made a temporary scanner on a breadboard – or at least learned something. Kudos if you went ahead and made a larger one. If you made a video, share it with us in the comments. And if you made it this far – check out my new book “Arduino Workshop” from No Starch Press.

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, dice, die, larson scanner, LED, projects, tronixstuff, tutorial6 Comments

Quick Project – 20th Century Electronic Dice

In this tutorial we make electronic dice without using a microcontroller!

Updated 18/03/2013

After publishing an article which described the design of an electronic die (dice), one of my twitter followers said that they made them in the past just with a 555 timer IC and a 4017 logic IC. A fair point, as one does sometimes get carried away with microcontrollers sometimes. Just to show that I haven’t lost touch, here is a basic rendition of the die project again but without any of that fancy microcontroller jibber-jabber. I will just present the schematic and demonstration, however if you want to make one on some protoboard, doing so should be quite simple.

First off, here is the schematic. I really should learn to use Eagle or somesuch, but a pen and paper is so much quicker:

die1schemss

Now what is happening here? I’m glad you asked. On the left we have a 555 timer in astable mode. For more information about 555 ICs, please visit our part review. When the user presses SW1, power is applied to the 555 and it merrily sends out pulses from pin 3. To increase the speed of the pulses, decrease the values for R1 and R2.

The pulses are received into IC2, a “4017 five-stage Johnson decade counter”. [data sheet] This is still a very old yet useful IC. It has ten output pins, Q0~Q9. Every time the 4017 receives a pulse, starting from power-on or a reset, starting from Q0 it sets an output pin to high (pins default to low). We have sourced LEDs D1~D6 from the first six output pins on our 4017. So when it receives the fast pulses from the 555, it quickly blinks the LEDs in order. When the user releases SW1, the pulses stop arriving from the 555, and the 4017 stops counting – and leaves the current pin HIGH so we can read the value. And here it is in real life:

die1boardss

The parts list:

  • R1, R2 – 82k ohm resistors
  • R3 – 1.8k ohm resistor
  • C1, C3 – 100 nF polyester capacitors
  • C2 – 10nF polyester capacitor
  • D1~D6 – typical LEDs of your choice
  • IC1 – 555 timer IC
  • IC2 – 4017 CMOS counter IC
  • SW1 – normally-open button
  • 5 V power supply (use an LM7805 regulator if 5 V not available)

There are a few things to take note of if building this circuit. The 4017 IC is quite prone to static, so please take care. Furthermore, all unused output pins need to be connected to ground. (Yes, I missed that in the schematic for pin 9). And finally, you can only source 10mA per output pin, which explains the higher than usual value for R3.

Quick note: In the past we have discussed capacitors and their use for smoothing noise from DC current. The circuit above is a perfect example – the 4017 is quite susceptible to noise and will not count properly without C3 between 5V and GND.

Finally, in the spirit of this article, less is more. We could use another 555 in a monostable configuration to limit the running time of the astable 555 pulse-generating timer, but a human can do that with their digits. Furthermore, a reset button could be added onto the 4017, so that’s up to you. Finally, here it is in action:

So there. However you can now see the advantages of using a microcontroller. Each extra function or ‘trick’ created by a line or two of code with our new die could require an exponential amount of hardware, power consumption, board space and possibly a total redesign. However doing it ‘the old way’ is interesting and helps prototyping practice and troubleshooting.

But while we have all of these parts out, we’ll have a little more fun… let’s do it with an actual number being display, instead of a flurry of blinking LEDs. We still need the 555 timer to create our pulses, so that remains the same:

die2aschemss

and here is the rest of the circuit:

die2bschemss

So in this example, the 555 is sending out pulses on request via SW1. However this time, the 4518 BCD counter [data sheet] receives those pulses, counts them (from zero to nine then repeat) and converts the current value to binary-coded decimal. Next, the BCD value is sent over to the 4511 BCD to 7-segment driver IC [data sheet]. This IC converts reads the BCD and sets outputs that are suitable for driving 7-segment LED modules. These outputs are sent via 330 ohm resistors to protect the LED segments. Then finally, the digit zero to nine can be displayed on the LED unit.

With some trickery we could limit this display to the numbers 1~6, if you want to do that go for it. So in this case our ‘die’ has in fact 10 values. I’m sure there are some games that could make use of it. Anyhow, here it is in real life:

die2boardss

You may be wondering what happened to R3~R9. In this case I am using a DIP resistor array. This is just eight resistors in one package, which makes life easier.

The parts list:

  • R1, R2 – 82k ohm resistors
  • R3~R9 – 330 ohm resistors
  • C1, 100 nF polyester capacitor
  • C2 – 10nF polyester capacitor
  • D1 – common-cathode 7-segment LED display
  • IC1 – 555 timer IC
  • IC2 – 4518 CMOS counter IC
  • IC3 – 4511 BCD to 7-segment IC
  • SW1 – normally-open button
  • 5V power supply (use an LM7805 regulator if 5V not available)

And here it is in action:

You can now see why the Arduino and other microcontrollers have taken off in popularity. They really do lighten the load with regards to planning and hardware construction. However it is enjoyable to do things the old way sometimes, ergo this article. If you are interested in articles like this one that use digital electronics, please let me know via the Google Group and there will be more projects similar to this one, but in greater detail. One day I may even pull the finger out and make a TTL clock…

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 4017, 4511, 4518, 555, dice, learning electronics, tutorial2 Comments

Project – Let’s make Electronic Dice

In this project we make electronic dice.

Updated 18/03/2013

In this article you can learn how to make an electronic die (die is the singular of dice), using an ATmega328 with Arduino bootloader and a few inexpensive components. The reason for doing this is to introduce another object that you can build, learn from and be proud of. It is a fairly simple procedure, and at the end you will have something that is useful for a long time to come. Again this article will be a design-narrative, so please read it in full before making a die yourself.

First of all, here is a photo of my finished product.

finishedssss1

Naturally the cosmetic design is up to you, I have used this box, LEDs and switches as they were already in my stock of parts. The die is quite a simple design – with a twist. Inside the unit is a mercury switch. This consists of a small glass tube with two wires at one end and a small amount of mercury. When the mercury rolls over the wires, they are shorted out. Just like a push button when it is pushed, for example:

tiltdemoss

 

We will make use of this switch to start the die “rolling” – to simulate the use of a non-electronic, under-engineered wooden die. For safety, I will be using a mercury switch that is enclosed with plastic:

tiltswitchss

Over the last few years several people have contacted me saying “don’t use mercury switches”. Fair enough, if you don’t want to either, use element-14  part number 540614.

First of all, the circuit is assembled on a breadboard using our Eleven Arduino-compatible board. There is no need to build the complete independent circuit yet, as we just want to test the aspects of the sketch, and try various LEDs out. I have some bright blue ones which match with the blue housing:

bboard1ss

There is a function in the sketch (below) called

which is used to display the numbers 1 to 6. The following video is a demonstration of this:

The sketch is quite simple – you can download it from here. Once the behaviour of the die met my expectation, I used my ZIF-socket programming board to upload the sketch into a nice fresh ATmega328 with bootloader. One could also add a piezo buzzer for sound effects, as described in sketch. This will end up being a birthday present for a young niece, so I have omitted the sound effects.

Next,  time to rebuild the circuit on the breadboard – using the bootrom and not our Eleven. Here is the schematic:

dieschematicss

and the resulting layout:

prototypess

And it works! Things are starting to come together now. As usual I was curious about the current draw, as this helps me determine how long the battery will last. On standby it draws between 10 and 20 milliamps, and between 30 and 40 milliamps when displaying numbers.

By now you probably would like to see it work, so here is the prototype demonstration:

Now it is your turn… from a hardware perspective, we will need the following:

  • IC1 – ATmega328 with Arduino bootloader programmed with the sketch
  • IC2 – LM78L05 voltage regulator – note that with the front facing you, pins are 1-output, 2-GND, 3-input
  • D1-D7 – LEDs of your choosing
  • R1, R9: 10 kilo ohm resistors
  • R2-R8: 560 ohm resistors
  • X1 – 16 MHz resonator – centre pin to ground, outside pins to IC1 pins 9 and 10
  • small piece of protoboard
  • SW1 – on/off button
  • SW2 – mercury tilt switch
  • 9V PP3 battery and snap
  • optional – 28-pin IC socket
  • a nice case, but not too large
  • some thin heatshrink
  • some sponge or insulating foam which has a width and length slightly larger than the protoboard

The ideal housing would be one that fits in the palm of your hand. However, such miniaturisation levels are quite difficult in the home workshop. The biggest problem (literally) was the power supply. The only battery with the voltage and a decent amp-hour rating was the 9V PP3. Alkaline models are usually good for 500 to 625 mAh, and should power the die for about ten hours of continuous use. Furthermore, whilst running the prototype on the breadboard, it would function down to 6 volts, however the LEDs were a little dim – but still perfectly usable. However I managed to squeeze it all in – sans the IC socket.

So if you are like me, and soldering the IC in directly – make sure you are happy with your sketch!

Anyhow, time to start the hardware work of assembly. Using veroboard/protoboard is easy if you plan things out first.

Remember – to fail to plan is to plan to fail

So in this case, I like to get some graph paper and draw out the tracks with a highlighter, such as:

templatess

My diagram shows the tracks as they would be on the rear of the veroboard. With this, using a pencil one can mark out component placement, links, and where to cut tracks if necessary. Those long lines are great for +5V and ground. Etcetera. When you have laid out the parts, go and have a break. Return and check your work, then fire up your iron and go!

Once completed you then have an easy to follow plan to solder along with. Here is the above example after I finished soldering:

after

After the soldering was completed, and the board checked for any shorts or poor-quality joints – it was time to have a clean-up and clear the mess away. Now it was time to stuff the whole lot into the housing… but it would be prudent to test the circuit beforehand. So I soldered in the tilt switch, and the battery snap, connected the battery – and it worked. Notice in the image below the placement of the centre LED – I have used some heatshrink over the legs to totally insulate them, and have it at the centre of the board:

almostdoness

Now to focus on the enclosure. In order to keep the costs down I used a box (and almost everything else) from my existing stock. It turned out to be a little small, but with some creative squeezing everything would fit. The PCB and battery are separated by a thin layer of anti-static foam, to prevent the possibility of the sharp edges of the PCB underside scratching the label of the battery and causing a short.

The final messy task was to drill the holes for the LEDs and the power switch. The switch was easy enough, just knock a small hole in then use a tapered reamer to get the exact size:

switchholess

Then to drill the holes in the lid for the LEDs to poke through. Easily done, just be sure to mark where you want the holes to be before drilling. Furthermore, you need to get the LEDs as far through the holes as possible:

ledsholess

Then the final step before sealing the lot up is to get the power wires soldered to the switch and the battery snap:

beforelidss

When you are putting everything in the box, make sure the tilt switch is tilted so that when the die is at rest, the tilt switch is laying in the off position. Otherwise the die will just merrily repeat forever until you turn it off.

finishedssss1

And of course, an action video:

Once again I hope that this demonstration has shown how easy it is for anyone with some spare time and the knowledge from my Arduino tutorials can create something from scratch.

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, dice, games, projects, tutorial4 Comments


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: