Last year my 2006 Ford Taurus (~157 000 miles) started to loose some coolant. Mechanic, while performing regular maintenance service, told me it is due to replace water pump. Should I invest ~ 600$ in repair or save some money and do that myself? After some hesitation I decided to proceed myself. First of all I collected as mush information as possibly of what to do and how. Two YouTube clips came exceptionally useful. This one is about the whole process.
Second one is about changing serpentine belt tensioner. Even if there is no need to change it, one need to remove belt and all related components to get access to the water pump.
Both these clips are probably all what you need to know to replace water pump on the Ford Taurus 1996-2006 year. I myself cannot add much to that apart of telling some additional tips regarding tools used.
From my experience set of metric wrenches 8,10,13,15 and the same set of sockets gives enough flexibility to unscrew and screw back all bolts of this project. Just pay an attention that 13 mm socket has to be deep. Regular short socket will be not good for some bolts mounting water pump.
To unscrew and then put back belt tensioner there is need in torx bit. Unfortunately second video mistakenly states that bit has to be T27 size. This is wrong. For me size T50 worked well.
Second video shows nice tip of attaching bigger wrench to the 15 mm, making release of tensioner easy. Like this:
That worked for me, apart of the fact that due to my inexperience 15 mm wrench slipped out of my hand and fell down. I had a trouble to get it back. To avoid such a mistake again I put some tape on the joint. Because of that the pair of wrenches worked as single tool. After the job done it was easy to remove tape and separate wrenches.
One of dis-assembling steps is to detach heater hose from the water pump. That sounds easy, but... I tried to pull hose as hard as I can without any success (later on I found that big buildup at the end of water pump pipe, as seen on first picture, was the cause) . Then I watched first video one more time and at 1:47 found the answer. Mechanic used special hook to separate hose form the water pump pipe. I made myself similar out of inexpensive awl. That helped.
So here is the conclusion. It is doable to replace water pump even if you are inexperienced mechanic. You just need the garage, some inexpensive tools and online access to order parts and find proper info.
This is photo of our front yard how it looks now (picture made on November 8 of 2017).
And this is the photo made on January 15 of 2017. As you can see it is quite a transformation. This is the result of my biggest DIY project so far: conversion of lawn to garden. The are several reasons for our family to make that conversion:
First and most important: big water usage during summer months. It is usually hot were we live and there are no any rains from May till October. Water bills easy could reach hundreds dollars. And in case state declares drought period, there could be charge for over-usage.
It is not that easy to maintain lawn in good shape. You see, even in the winter (rain season here) it is far from perfect, but I can assure you that during July or August it is much worse. Brown spots her end there, weeds in place of grass.
I had to mow lawn two times per month and I did not like that.
The last (but not least): to save the water our state willing to pay for lawn to garden replacement up two dollars per each square feet converted.
So our family decided to proceed. The project started in January and ended in May. We did everything ourselves without any professional help. Here are project stages:
Breaking the turf (grass) with garden shovel.
Cultivating the soil with Tiller Joe electrical tiller/cultivator ( that step I repeated three times to fully destroy the grass).
Fixing irrigation pipes, which were broken during steps 1 and 2. Replacing sprinklers with water pressure reducers.
Planting drought tolerant shrubs and flowers.
Covering soil with mulch,
Installing dripping manifolds on top of water pressure reducers. Installing tubes with drip emitters.
I described this process in more details here: https://www.instructables.com/id/How-I-Made-Money-While-I-Worked-on-My-Front-Yard/ . In this post I would like to speak a little bit more about one topic which did not take enough attention yet. While converting irrigation from sprinkling to dripping I first tried Rain Bird Drip Emitter Conversion Kit which has everything:
raiser with pressure reducer.
Six port dripping manifold.
Fifty feet of dripping tube.
Six drip emitters.
Six stakes to hold emitters in place next to plant root.
It works OK, so I wanted to buy more of the same. But alas, my local Home Depot was out of stock. I decided to buy components separately. Raisers, tubes and emitters were not a problem. But there were no manifolds exactly the same as in the kit. So I had to try others.
At the picture above you can see everything I tried:
Rain Bird EMT-6X Xeri 6-Outlet 1/2-Inch Drip Manifold (bottom right: the same as in conversion kit).
All manifolds but last one I did not like. While first three were more sophisticated compare to manifold in the kit (water consumption adjustment, changing of outlet angle position), they all suffer form the same disease: water leak at the foundation of outlets. One would say that such a leak is not important for outdoor devices, but I could not agree. Eventually I ordered manifolds number four on Amazon and installed them. No adjustment or changing of outlet angle, but no leak as well. I returned all manifolds but number four back to hardware stores.
Let us return to the Useless Machine topic one more time.
Classical useless machine usually made out of four electrical components, namely:
Electrical battery.
Gear motor.
DPDT switch (usually toggle, sometimes rocker).
Micro-switch.
This is probably minimal set: it is hard to imagine anything more efficient. But once an idea came to my mind: maybe such a machine is not absolutely perfect. Useless machine must cut itself out of power as soon as it returns to the original state. That achieved with help of the micro-switch. Machine arm,while returning back, pushes switch, its normally closed contact becomes open, machine fully stops and looks dead. But if tester tries to move an arm manually, micro-switch is released again, its closing contact provides power to the motor. That case is visible on the clip of Rocker Switch Useless Machine starting at second 19. So machine here actually is not dead, it just plays dead! That's good opportunity for the new design : make the machine, which will allow manual rotation of the arm, when machine is turned off. In other words make the machine really dead at the end of its working cycle. To achieve that I decided to get rid of micro-switch and use for backward movement an energy stored in the capacitor, charged while machine arm moves forward, . Below you can see circuit diagram of such a machine:
When switch connects motor to the battery and motor moves the arm forward, electrical current is flowing through the circuit of diode and relay, mounted in parallel to the motor. Relay is forced to close its normally opened contact. Through that contact (and small resistor) capacitor is connected to battery and receives some charge.
When arm turns the switch back, motor is disconnected from battery, but connected to the capacitor in the opposite polarity. Motor rotates backward and returns arm to its original state. Diode now stays in the opposite direction on the way of electrical current, so relay contact stays open and capacitor is disconnected from the battery. Capacitor mostly is discharged providing the movement of the motor, the rest will be discharged through the stopped motor winding. You see, in theory it looks simple. But I must tell you that this design is much more demanding on the spec of components, compare to classical schematic. After some trial and error iteration I came up to the next set component:
Solarobotics gear-motor GM17 ( I could not make it working reliably with GM2 or other motors with similar spec).
Super capacitor 0.1 F. (I used NEC 5.5 V capacitor). Bigger capacitor would be fine but smaller probably not.
5V relay. Here type is not that important.
Schottky diode. Here type is not that important.
Resistor 5 Ohm. It is optional but it keeps electrical current trough the battery under 1 Amp at the beginning, when the capacitor is fully discharged. Type does not matter here, but better to have 0.5 W.
Four 1.2 V rechargeable batteries. Type does not matter.
As you can see on the video tester may manually rotate the arm when machine is turned off. Done!
I published more detailed description on instrcuctables site
Update 11/12/2017. fixed bug in diagrams: missing wire between switch terminals.
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/typedefenum {OUT_LOW, OUT_HIGH} OutputLevel;
volatileuint16_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;\}voidclearAll()
{ // set all outputs low
DDRB =0xFF; PORTB =0;
DDRC =0xFF; PORTC =0;
DDRD =0xFF; PORTD =0;
}
voidactivateTimer0()
{
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 descriptorintmoonlight(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:
There are two kinds of Windows programs: Windows GUI or Console Application. There could be third case: process, which does not have any visual representation at all and needs to be running in the background. For that case program maybe be built as Windows GUI, but it should not have any code, which creates Windows objects. But what if you want from application sometimes to be silent and sometimes to be verbose and to have a console. Possible use cases are:
Printing version of the utility if started with special flag (like -V)
Program needs complicated tune up through the command line arguments or configuration file, but normally is running on the background. It would be beneficially to have a choice either run it with console or run it quietly.
That could be achieved by compiling application as Windows GUI and allocating or attaching console to the process during run-time if needed. There are a lot of examples how to do that in C/C++. When I myself looked for the solution several years ago I have found this link helpful. Fragment of the code, which creates console may look like this.
// taken from: http://www.codeproject.com/KB/dialog/ConsoleAdapter.aspx
AllocConsole();
int fdout = _open_osfhandle((long)GetStdHandle(STD_OUTPUT_HANDLE), _O_TEXT);
FILE* fout = _fdopen(fdout, "w");
*stdout =*fout;
int fdin = _open_osfhandle((long)GetStdHandle(STD_INPUT_HANDLE), _O_TEXT);
FILE* fin = _fdopen(fdin, "r");
*stdin =*fin;
Nowadays I found myself programming more and more in Go. While initially Go compiler was intended for Linux only, that is not the case anymore. Windows now is the first class citizen in the Go world. Recently I needed to create application, which may open the console if that demanded by command line argument, but work invisibly otherwise . To my surprise there were not that many online information how to do that in Go. I did find one answered question in StackOverflow. Alas, proposed solution did not work for me out of the box. But using it as starting point and after some googling I have found workable solution. Here is sample of Go application, which will allocate console, print some prompt, wait for keyboard input and quit.
// go build -ldflags -H=windowsguipackage main
import"fmt"import"os"import"syscall"func main() {
modkernel32 := syscall.NewLazyDLL("kernel32.dll")
procAllocConsole := modkernel32.NewProc("AllocConsole")
r0, r1, err0 := syscall.Syscall(procAllocConsole.Addr(), 0, 0, 0, 0)
if r0 ==0 { // Allocation failed, probably process already has a console
fmt.Printf("Could not allocate console: %s. Check build flags..", err0)
os.Exit(1)
}
hout, err1 := syscall.GetStdHandle(syscall.STD_OUTPUT_HANDLE)
hin, err2 := syscall.GetStdHandle(syscall.STD_INPUT_HANDLE)
if err1 !=nil|| err2 !=nil { // nowhere to print the error
os.Exit(2)
}
os.Stdout = os.NewFile(uintptr(hout), "/dev/stdout")
os.Stdin = os.NewFile(uintptr(hin), "/dev/stdin")
fmt.Printf("Hello!\nResult of console allocation: ")
fmt.Printf("r0=%d,r1=%d,err=%s\nFor Goodbye press Enter..", r0, r1, err0)
var s string
fmt.Scanln(&s)
os.Exit(0)
}
I would like to point some details about syscall.Syscall invocation for AllocConsole :
This function has five arguments. It is different of what you will find in the online Go Doc . Looks like doc references Linux definition, which is not the same as Windows.
Second parameter here is number of arguments in dll function. For our case it is 0.
Function returns three variables, but only first is really meaningful. It is the result returned by AllocConsole function. Second variables always 0. Third variables is an error, but in cannot be analyzed in the regular Go way as far as it is never nil. Still it could be useful: in case of success its value is different from value on failure (for example if application was build with no windowsgui flag and already has the console ) .
Hobbyist and DYI makers very often extend usage of elements and components beyond its usual assignments. I would like to share with you one such a case.
Whenever you drill through the wooden or plastic sheet you has to be really careful not to drill through. The common well know method to prevent that is to use tape or scotch wrapped around the drill bit. Once I was out of tape and had to look for substitution. Piece of heat shrink tube came in handy. It fitted drill bit exactly, I just needed to cut proper length of it. That was very lucky finding. I entirely stopped using tape for this task and switched to heat shrink or straw tubing. Especially convenient it becomes for projects which needed drilling with the same drill size but with different depth. Switching between tubes can be done in a second.
The best result is achieved when tube sits tight on the drill bit. In case you does not have exact heat shrink size, you may cut tube, which is too narrow, alone. It will still work. But you need to be more careful to stop drilling right at the moment when tube touches the surface. Otherwise it may be torn away by drill rotation.
Controlling depth of drilling (that idea you actually see here).
Using heat shrink while hanging picture on sheet rock wall
Protecting awl tip
Keeping tweezers tips together.
Making paper clip to work better.
That topic got some attention and was even featured by one of the site editor. Author Phil B told me about one more usage of heat shrink: fixing claps on kindle reader case. I am sure there are many more cases which extends usage of heat shrink tubes.
Updated: 11/28/2017. Today I read about one more very useful usage of heat shrink: as thread locker.
Author Left-filed Designs published this blog https://www.instructables.com/id/DIY-Self-Locking-Nut/ . Very good. Will use myself for sure.
This project is a remake of the DIY project "Sit-n-Stand monitor station" described in the my old post: How did I join the Uprising. Recently my family moved into the new house and a lot of old stuff including some of DIY things did not survive the moving. I have to make the station again. This time it looks less DIY and more furniture like (I hope). The basic principle is the same: desk with monitor moves up and down within sides sliders. Pulley system with counter weight compensates gravity force making moving easy. But there are some differences:
Instead of single pulley line in the middle of the desk there are two lines on both sides of the desk.
I made desk as light as possible (but without any sacrifice of sturdiness).
Light desk allowed me to switch from 3-times advantage pulley system to 2-times advantage system. As a result of that counterweight moves withing the boundaries of the hutch.
I mounted two shelves in the inner side of the hutch making some use of hutch volume.
Detailed steps of this project is published on the "Instructables" site right here: Sit&Stand Computer Desk Hutch . I even submitted it to couple of "Instructables" contests. I cannot tell that submission made the big splash but project got some attention. While it does not win first prize it reached one contest final and here is my award: "Instrcutables" robot t-shirt.
No, I did not pay that many for this cardholder. I am not even sure I ever will pay $5 for any cardholder. I got mine completely free. It was taken out of computer, which was prepared to be utilized by E-waste service. Processor passive cooler grabbed my attention and pretty soon I have found some use in it. That was an easiest project I ever made. Out of curiosity I did the online search to find out the pedigree of this beast. And here you can see the result.
Indeed it has a spectacular specification and outstanding price. That money may buy you Apple MakBook Air nowadays. Why people complain about an inflation?
This is the project I made in 2010 as a response to the publication about useless machines in Make Magazine1. 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 2 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 3. 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 4.
// script routineintprotothread(struct pt* upt)
{ // called each timer interrupt staticint 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.
1 Brett Coulthard. '"The most useless machine" (Issue 23 of Make Magazine). 2010
2 You cannot buy it anymore but there is the substitution with a better functionality in the same package but with slightly different wiring.
3Protothread Home Page.
4 The whole source code is available at this storage.
People use pegboards as garage tool organizers. This is well-known fact. Sometimes pegboards are used inside kitchen to arrange cooking spoons, knifes etc. This is not so well-known but still an old trick. In this project I put pegboard inside the picture frame. Picture frame serves here two purposes: it strips pegboard off its garage-like look and it makes process of installation easy.
Project is very simple. First you need to choose the proper frame. Be sure that it has two hangers (if not you have to install them yourself as I did). Then cut the proper size pegboard, put it into the frame and hang the organizer on the kitchen wall.
Now you can invite the chef to arrange cooking tools in a convenient and aesthetic way.
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:
Push the encoder: reserved LED is turned on
Rotate the encoder to choose value you want to set (hour or minute).
Push the encoder again, now clock are ready to set the value.
Rotate the encoder to set the proper value.
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.
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).
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.
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:
