In the Moonlight

This is the moon simulator with bat silhouette which I made as a decor for this  Halloween.

The core part of the project is twelve backlight white LED modules ( I bought them from the adafruit). LEDs are controlled by Atmega328 micro controller. The schematic of the project is fairly simple:

Adm here you can see project assembly with some internals visible:

Twelve LED modules put in the middle of sandwich made out of two Plexiglas  sheets attached with the help of Velcro strips.  Paper Bat attached to the front of the moon with Velcro as well as front and back cardboard shields .

 Program to control the device is short enough to be present entirely in this blog:

/*
 * moon.c
 * Created: 10/22/2016 1:14:19 PM
 *  Author: jumbleview
 */ 
#include <avr/io.h>
#include <avr/interrupt.h>
#include "./pt-1.4/pt.h" // http://dunkels.com/adam/pt/

typedef enum {OUT_LOW, OUT_HIGH} OutputLevel;
volatile uint16_t pulses;

#define pinOut(port, bit, outLevel) \
(DDR##port |= (1 << ( DD##port##bit)));\
switch(outLevel) \
{\
 case OUT_LOW: (PORT##port &= ~(1 << (PORT##port##bit))); break;\
 case OUT_HIGH: (PORT##port |= (1 << (PORT##port##bit))); break;\
}
void clearAll()
{ // set all outputs low
 DDRB = 0xFF; PORTB = 0;
 DDRC = 0xFF; PORTC = 0;
 DDRD = 0xFF; PORTD = 0;
}
void activateTimer0()
{
 cli();
 pulses = 0;
 TCCR0A=0; // Normal operation
 TCCR0B=2; // f divider 64  : about 2 ms for interrupt ...
 TIMSK0 = 1; // for system clock f= 1Mhz (CKDIV8 set)
 sei();
}
struct pt wpt; // protothread descriptor

int moonlight(struct pt* mlpt)
{
 PT_BEGIN(mlpt);  // New Moon 
  PT_YIELD(mlpt); 
   pinOut(C,5,OUT_HIGH); pinOut(B,1,OUT_HIGH);
  PT_YIELD(mlpt);
   pinOut(D,0,OUT_HIGH); pinOut(B,2,OUT_HIGH);
  PT_YIELD(mlpt);
   pinOut(D,1,OUT_HIGH); pinOut(B,0,OUT_HIGH);
  PT_YIELD(mlpt); // First Quarter   
   pinOut(D,2,OUT_HIGH); pinOut(D,7,OUT_HIGH);
  PT_YIELD(mlpt);
   pinOut(D,3,OUT_HIGH); pinOut(D,6,OUT_HIGH);
  PT_YIELD(mlpt);
   pinOut(D,4,OUT_HIGH); pinOut(D,5,OUT_HIGH);
   pinOut(C,0,OUT_HIGH); pinOut(C,1,OUT_HIGH);
  PT_YIELD(mlpt);  // Full Moon + Red Eyes
  PT_YIELD(mlpt); 
   pinOut(C,0,OUT_LOW); pinOut(C,1,OUT_LOW);
   pinOut(C,5,OUT_LOW); pinOut(B,1,OUT_LOW);
  PT_YIELD(mlpt);
   pinOut(D,0,OUT_LOW); pinOut(B,2,OUT_LOW);
  PT_YIELD(mlpt);
   pinOut(D,1,OUT_LOW); pinOut(B,0,OUT_LOW);
  PT_YIELD(mlpt);  // Third Quarter
   pinOut(D,2,OUT_LOW); pinOut(D,7,OUT_LOW);
  PT_YIELD(mlpt);
   pinOut(D,3,OUT_LOW); pinOut(D,6,OUT_LOW);
  PT_YIELD(mlpt);
   pinOut(D,4,OUT_LOW); pinOut(D,5,OUT_LOW);
  PT_RESTART(mlpt); // New Moon
 PT_END(mlpt);
}
ISR(TIMER0_OVF_vect)
{
 pulses++;
 uint16_t mod =pulses%750;
 if (mod == 0){
  moonlight(&wpt);  
 }
}
int main(void)
{
 PT_INIT(&wpt); // initiate protothread structure...
 clearAll();
 activateTimer0();
    while(1) { }
}

To  compile and load program into the controller memory I used Atmel Studio 6.1. Code includes three header files.

• File "io.h" contains definitions to work with input/output (comes with Studio installation)
• File "interrupt.h" is defining interrupt vectors (comes with Studio installation)
• File "pt.h" is Adam Dunkels implementation of protothread library.

Protothred library deserves some additional notes. I included it to my programming  tool box recently and nowadays use it any time I need to program embedded devices in "C ". It provides multitasking framework and allows to code device states efficiently and conveniently.  I highly recommend to try it for any programmer  who works with micro-controllers in "C".

As you can see device is simple to made and program. Some additional details you can find in my "Instructables" project.

The only problem I see is relatively high project price. Mostly it is the price of LED modules ($2.50 for each). Nothing could be done here. To gain some additional benefits I decided to substitute  Bat with Reindeer so the device is quite usable  as winter decor:

Useless Machines, Atmel Controllers & Protothreads

This is the project I made in 2010 as a response to the publication about useless machines in Make Magazine¹. In overall excellent article there was one statement which looked controversial to me. Author stated that a machine with a microprocessor does not cut itself completely off power and from that point of view cannot be fully qualified as useless machine. This is not true. Sure you can build a machine with microprocessor which at the end of cycle cuts itself off power. And here is its wiring diagram of the machine from the clip above.

As central component this project utilizes Pololu B-168 controller ² with Atmel ATmega168 as a brain. In addition controller has two H-bridges for bi-polar load. One bridge in this project controls the motor, another controls the reed relay which keep the machine on power disregarding of the control switch state. To eliminate toggle switch (the reason for that you can read here) I designed the push button custom made out of two micro-switches. To justify presence of the controller more complicated task assigned to the machine. This task could be described in in these statements:

• The Machine waits till tester hits the button. With first hit turn itself on.
• Thew Machine waits some time if there is no hits anymore.
• The Machine calculates the number of hits.
• If pause after last hit is big enough working cycle begins and the machine arm hits button as many time as tester did.
• At the end machine cuts itself off power.

While preparing this post I decided to rewrite program having in mind to try one well known but new to me technique, namely Protothreads ³. This is the framework based on C language trick which allows operator switch to be embedded inside C code blocks like if, while or for. Such obscure language feature allows to use case statements as breakpoints where the task may yield execution to other tasks and from where it can resume execution when it gets the control next time. For the detail explanation I would reference you to author website. After reading it you will understand why not everyone in programming community accepts these ideas and why there is no known company which includes it into the corporate coding standards. But for hobby project I can use whatever I like, right? Fragment of the code below contains protothread routine which implements machine working cycle ⁴.

// script routine
int protothread(struct pt* upt)
{  // called each timer interrupt 
 static int count=0, ix;
 static u_time timer;
 PT_BEGIN(upt); // PT_INIT is called form the main function
 // just in case to avoid race condition at the end
 PT_YIELD_UNTIL(upt,isButtonPressed());
  
 turnRelay(DeviceON); // keep device powered 
 turnMotor(DeviceOFF);
 turnLED(DeviceOFF);
 do { // counting cycle
  PT_WAIT_UNTIL(upt,isButtonReleased());
  timer = schedule(750);
  count++;
  PT_WAIT_UNTIL(upt,isExpired(timer)||
    isButtonPressed());
 } while(!isExpired(timer));
 
 for(ix = 0; ix != count; ++ix) { // working cycle
  turnLED(DeviceON);
  turnMotor(DeviceON);
  PT_WAIT_UNTIL(upt,isButtonPressed());
  turnMotor(DeviceOFF);
  timer = schedule(20);
  PT_WAIT_UNTIL(upt,isExpired(timer));
  turnMotor(DeviceBACKWARD);
  turnLED(DeviceOFF);
  PT_WAIT_UNTIL(upt,isArmDown());
  turnMotor(DeviceOFF);
  timer = schedule(20);
  PT_WAIT_UNTIL(upt,isExpired(timer));
 }
 turnRelay(DeviceOFF); // kill the machine
 timer = schedule( 20);
 PT_WAIT_UNTIL(upt,isExpired(timer));
 PT_END(upt);
 return PT_EXITED;
}

See for yourself but to me it looks like good pseudo code which expresses program logic in clear and conscious way.
And at the end some observations from my limited experience with protothreads:

• All yields/resumings of particular protothread have to be in the same protothread routine, in other words you cannot spread switch case statements across more then one function.
• Protothread states must not be stored inside local auto variables, only static or global variables have to be used.
• When working with Microsoft Visual Studio projects you must change default project setting of Debug Information Format field from Program Database For Edit and Continue (/ZI),to Program Database(/Zi). Otherwise your program will not compile.

¹ Brett Coulthard. '"The most useless machine" (Issue 23 of Make Magazine). 2010
² You cannot buy it anymore but there is the substitution with a better functionality in the same package but with slightly different wiring.
³Protothread Home Page.
⁴ The whole source code is available at this storage.

Wall Clock with Atmel Microcontroller

Time measuring devices always look special to me.  I admire the royal nobility of a tower clock,the steady pace of a pendulum mechanism, the instant obedience of a stop watch. Eventually I decided to build one such device myself. While making a mechanical device is out of my ability, building an electronic clock is a relatively easy task. All that you need nowadays is a few inexpensive  components, rudimentary soldering skills and some programming experience.  

The clock above is what I made for our bedroom (thanks to my wife who allowed me to put this creature on the wall).

What is special about this clock: 

•  It is a twenty four hours clock with accuracy up to one minute.
• It uses a single active component: Atmega328 controller, which keeps the time and controls LEDs without help of any external microchip.
• Time accuracy is provided  by an external oscillator while internal oscillator provides processor working frequency. 
• Technique known as charlieplexing is used to handle the number of  LEDs exceeding number of controller's  I/O pins. 
• This bedroom clock  possess an important feature: it can turns light OFF  and ON according to the schedule. This way it's light does not distract us during sleep time but allows easy time reading at dawn.

Let us describe the clock interface. This clock has two dials: inner (yellow) dial for hours and outer (green) dial for minutes. These two dials provide time reading with accuracy up to three minutes. Three correction  LEDs in the middle improve accuracy up to one minute.

Rules to read the time are simple:

•   During AM hours single LED is turned ON  showing current hour. LED which points to XII hour  is always OFF.
• During PM hours group of LEDs are ON staring from the LED which points to XII LED and ending with the current hour. 
• Next LED is switched ON when there are two minutes left till the start of new hour.
•  Each green LED of outer dial represents 5 minutes interval. LED which point to 60 minutes is always ON  as well as LED next to the current minute and all LEDs in between. This way the clock provides at least three minutes accuracy.
• Three LEDs in the middle allow time correction:

Pictures below illustrate time reading rules.

Clock contains this set of components:

• Atmel controller. I have used Atmega 328 but less powerful controller could be used as well.
• Clock oscillator 32768 Hz.
• Thirty LEDs (5 mm size).
• 15 resistors 51 Ohm each (0.25 or 0.125 does not matter).
• Radio Shack protopype board (catalog number 276-170)
• Two three pins  headers (to build ISP connection between controller and PC)
• Capacitor 0.047 micro farad 
• Encoder to set up clock time. I have used Panasonic EVQ-WTEF2515B
• Hookup wire and old IDE cable.
• Power supply 5 V. It must provide at least 300 mA of current. I have used supply from old Sharp  handheld computer.

These components are connected according to the circuit diagram below:

To make soldering of  four LEDs to the single resistor I  prepared the board by making some cuts with a knife.

Here is how the board looks after soldering of all components.

I decided to use as a clock plate the wooden board from Michael's. As you can see I did not try hard to make it strictly symmetrical, having in mind the asymmetrical shape of the board. 

The clock was programmed with help of Atmel  studio 6.1 in C language. Source code and project file are  available here https://bitbucket.org/jumbleview/clock30/src.

Setting the time is not hard. For that three LEDs at the back of clock are used:

To set the time there is the need to follow next steps:

1. Push the encoder: reserved LED is turned on
2. Rotate the encoder to choose value you want to set (hour or minute).
3. Push the encoder  again, now clock are ready to set the value.
4. Rotate the encoder to set the proper value.
5. Push the encoder again: the value is set.

To set the other value you  may repeat steps 1-5.

And here is the movie, which shows process of setting clock minutes.

Atmel Microcontroller Plays the Tic-Tac-Toe Game

A couple of years ago I made an electronic Tic-Tac-Toe game with  Pololu baby Orangutan controller as the central component. Pololu  is an excellent device  but for Tic-Tac-Toe game it was an overkill. Its motor drivers were of no use and  it required  at least 5 V power source, so I had to add an adapter to make device workable on two batteries. Recently I decided to gain some experience with bare bone Atmel controllers and repeated this project with ATmega 168. Setting  this controller to the lowest possible frequency (1 MHz) allowed me to eliminate the power adapter. (Two AAA rechargeable batteries provides 2.4 V, which is more than enough for ATmega 168 at this frequency). Here is the circuit diagram of this toy.

Let us look at the list of components:

1. All electronics were mounted on a RadioShack component PC Board 276-168.

2. Central processor Atmega 168 (do not remember where exactly I bought it, many online providers sell it)

3. Nine Bi-polar bi-color 5mm Green/Red LEDs. (again I did not keep the record of purchase,  some online providers sell it)

4. RadioShack 2 AAA battery holder  270-398

5. Nine resistors 51 Ohm 0.25 W (0.125 W is OK as well)

6. Panasonic  EVQ-WTEF2515B Encoder (goldmine-elec-products.com; alas, looks like they do not sell it anymore)

7. Ceramic capacitor 0.47 uF.

8. RadioShack slide switch 275-409

9. Male headers 2.54 mm to make six contacts ISP header. SItes pololu.com or hobbyengineering.com sells various types of them.

10. RadioShack 2-pack 14-PIN IC socket (optional, just to have the possibility to reuse controller  on other projects).

11.Hook-up 26 gauge wire ( hobbyengineering.com ) and 30 gauge precut wire  (Frys electronic store).

As  an enclosure  I used a box from Johnson&Johnson emergency kit. I had to treat edges of the board with file to make it fit into the enclosure.

As you can see the density of project components on the boards is not high.  Soldering elements  to the board and connecting it with 26 gauge wire was not that hard. To find out how LED was oriented on the board follow the simple rule: top of any LED on my diagram corresponds to the longer LED leg.  Contacts of panasonic encoder are very fragile  so I used 30 Gauge wire here. The PC board layout does not provide the proper place to solder ISP header. So I have to separate  three contact plates with utility knife and solder wire directly to contact plates occupied by headers.

Of course, the main part here is the program. For machine to choose the right move there is a well known algorithm: game tree search.   There are many sources to look for. In particular I have used this Berkeley lecture: http://www.cs.berkeley.edu/~jrs/61bf10/lec/18.pdf and strictly followed the described here game three search with simple pruning algorithm converting pseudo code into the C language. The only deviation from the algorithm  I did during programming  of the first  computer move. If computer starts the game it chooses randomly among central and four corner squares. If computer does not start the game it makes its first move in to the center if the center is  free  or chooses randomly any corner square if center is occupied. There are two reasons for such deviation. Making a move when the board is  empty means too many choosing attempts (hundred thousands) and it will take a lot of time  for a low frequency controller to calculate it. In addition introducing some randomness makes the game on the computer side less predictable and boring.

Source code for the toy is available here https://bitbucket.org/jumbleview/three-in-a-row/src/

After compiling code with free Atmel Studio 6.1, the resulting hex file was written into the controller flash memory with the help of Atmel ISP MKII (I bought  mine at mouser.com )

Let us look at the compiler printing regarding the program memory allocation:

Program Memory Usage : 3548 bytes   21.7 % Full

Data Memory Usage : 57 bytes   5.6 % Full

Based on that we can conclude that  after recompilation the code will work on any of controllers from the line:  Atmega48, ATmega88, ATmega168, ATmega328.

And finally here is how the Atmel controller plays the Tic-Tac-Toe game: