Why does this site cause a script to run? I have my web-traffic monitored for me by eXTReMe tracker. They offer a free tracker. If you want to try it, check out their site. And if there are Google ads on the page, they are run with scripts, too.
Bookmark this on Delicious
Recommend to StumbleUpon
This is one of a collection of pages which, together, attempt to show you "everything" about the Arduino's programming language.
There is a page for you with more information about the project in general, and the way these pages are organized, if you want that.
Please visit my page about power browsing notes sometime.
This page, and the software it references, ©TK Boyd, Dec 2009- Sept 2015.
In the first tutorial we made a start, covered some basics. We even got a pair of LEDs winking!
In this tutorial, the program we create is equally useless in its own right, but some more important principles are illustrated.
You'll need an Arduino with three LEDs attached. I've put mine on pins 11, 12 and 13. With very slight changes to the program, you can put them on other pins if you would rather.
Turn your Arduino so that you are looking at the LEDs with the one on pin 13 at the left. (And, if using an Arduino Pro Mini, don't let the fact that the on-board LED for pin 13 is beside the PIN for pin 10 confuse you! (Why Programmers Go Gray: Mr Murphy was working overtime this morning, 14 Sep 15, as I went through this tutorial again, six years after originally writing it. I had two red LEDs and one green one. And, thanks to Mr Murphy, I had my green LED on pin 10, and the reds on 12 and 13. So when the on-board green LED on the board, beside pin 10 on the Pro Mini, wasn't in sync with my external green LED I was confused (at first). "Of course", one of my red LEDs was in sync with the green LED on the board.... Sigh.))
Our program is going to count in binary. It is going to do it two ways. Whoopee. But at least it can't be too hard, can it?
(Code revisited 9/15... worked, using Arduino IDE 1.6.5. (Didn't revise "version" ids in the text below, but ran the old code in the new IDE. No changes needed from 2009 code, I'm happy to say.)
With 3 LEDs, we can show, in binary 0-7. For those who don't know binary, the binary equivalent of 0 to 7 is as follows, * standing for an LED that is glowing, - standing for one that is dark.
- - - - - * - * - - * * * - - * - * * * - * * *
That's 0 to 7 in binary. That was "the hard part" of this tutorial.
Now... making the Arduino make the LEDs do that. I'm going to have the left hand LED on pin 13, the middle LED on pin 12, the right hand LED on pin 11. And will call them LED2, LED1 and LED0, respectively. Note that this is a slight re-assignment, relative the names used in the first tutorial.
By the way: Two terms, illustrated with the decimal number 789. "7", standing for "7 lots of 100" is the "most significant digit" in that number, or "MS digit", and 9 is the "least significant" (LS) digit. In the binary number 110, the LS digit is a 0. The MS digit, the first "1", stands for "1 lot of 4".
The first program to achieve this result is really, really simple. It just does everything "by hand", as it were. you can copy/ paste this into your Arduino IDE to get started...
/*FEAa1CountSimple
ver 27 Dec 09
Requires 3 LEDs
*/
const byte LED0=11;//LED for LS bit connected here
const byte LED1=12;//LED connected here
const byte LED2=13;//LED for MS bit connected here
//LED2 should be on the left, LED0 on the right
const word delayDuration=600;
void setup()//"setup" always present
{
pinMode(LED0,OUTPUT);
pinMode(LED1,OUTPUT);
pinMode(LED2,OUTPUT);
}
void loop()//This function always present
{
//show zero: All LEDs off, - - -
digitalWrite(LED0,LOW);
digitalWrite(LED1,LOW);
digitalWrite(LED2,LOW);
delay(delayDuration);//To give human time to see first state
//show 1: Only LS LED on, - - *
digitalWrite(LED0,HIGH);
digitalWrite(LED1,LOW);
digitalWrite(LED2,LOW);
delay(delayDuration);//To give human time to see second state
//show 2: - * -
digitalWrite(LED0,LOW);
digitalWrite(LED1,HIGH);
digitalWrite(LED2,LOW);
delay(delayDuration);
//show 3: - * *
digitalWrite(LED0,HIGH);
digitalWrite(LED1,HIGH);
digitalWrite(LED2,LOW);
delay(delayDuration);
//show 4: * - -
digitalWrite(LED0,LOW);
digitalWrite(LED1,LOW);
digitalWrite(LED2,HIGH);
delay(delayDuration);
//showing 5-7 this crude way is left as an exercise for the student!
//Hint: Use copy/paste to copy a whole block of three writes and a
// delay, and then tweak the text.
// and finally....
delay(delayDuration);
delay(delayDuration);//Create a longer delay before
//going back and counting up from zero again.
}
If, as I hope, you have been faithfully and patiently reading carefully up to here, without skimming, without too many "yeah, yeah"s, then hold on to your hat. The pace is going to pick up here.
Look at the pedestrian code above. See the frequently repeated blocks of three "digitalWrite(something)"s? Wouldn't it be nice if there were a word, say, "setLEDs", which could turn the three LEDs on or off, in a pattern of our choosing?
The great news is that we can make such a word!
Here's the new program, using our new word. Don't worry, all will be explained!
/*FEAa1CountWithFunction
ver 27 Dec 09
Requires 3 LEDs
*/
const byte LED0=11;//LED for LS bit connected here
const byte LED1=12;//LED connected here
const byte LED2=13;//LED for MS bit connected here
const word delayDuration=600;
void setup()//"setup" always present
{
pinMode(LED0,OUTPUT);
pinMode(LED1,OUTPUT);
pinMode(LED2,OUTPUT);
}
void loop()//This function always present
{
//show zero: All LEDs off, - - -
setLEDs(0,0,0);
delay(delayDuration);//To give human time to see first state
//show 1: Only LS LED on, - - *
setLEDs(0,0,1);
delay(delayDuration);//To give human time to see state
//show 2: - * -
setLEDs(0,1,0);
delay(delayDuration);
//show 3: - * *
setLEDs(0,1,1);
delay(delayDuration);
//show 4: * - -
setLEDs(1,0,0);
delay(delayDuration);
//show 5: * - *
setLEDs(1,0,1);
delay(delayDuration);
//show 6: * * -
setLEDs(1,1,0);
delay(delayDuration);
//show 7: * * *
setLEDs(1,1,1);
delay(delayDuration);//To give human time to see last state
// and finally....
delay(delayDuration);
delay(delayDuration);//Create a longer delay before
//going back and counting up from zero again.
}
void setLEDs(byte bL2, byte bL1, byte bL0)
{
if (bL0==0) digitalWrite(LED0,LOW);
else digitalWrite(LED0,HIGH);
if (bL1==0) digitalWrite(LED1,LOW);
else digitalWrite(LED1,HIGH);
if (bL2==0) digitalWrite(LED2,LOW);
else digitalWrite(LED2,HIGH);
}
Again... just copy/ paste that into your IDE, replacing the first program.
The "really clever" bit is down at the bottom... but we're not going to worry about that... yet.
Look at the main "stuff" in the "loop" function.... e.g....
//show zero: All LEDs off, - - -
setLEDs(0,0,0);
delay(delayDuration);//To give human time to see first state
//show 1: Only LS LED on, - - *
setLEDs(0,0,1);
delay(delayDuration);//To give human time to see state
//show 2: - * -
setLEDs(0,1,0);
delay(delayDuration);
Notice how easy that is to read?
Presumably... and we will come to it... the setLEDs function turns some LEDs on, some off, depending on the 1s and 0s in the brackets following the function name.
setLEDs is a newly created function, made up by me. (How is something we will come to.) The fact that you can make up functions gives you tremendous power to make your programs clever and at the same time clear.
How did we create the "setLEDs" function? The stuff at the bottom of the program created the function. I.e. this stuff, which we will go through in a moment....
void setLEDs(byte bL2, byte bL1, byte bL0)
{
if (bL0==0) digitalWrite(LED0,LOW);
else digitalWrite(LED0,HIGH);
if (bL1==0) digitalWrite(LED1,LOW);
else digitalWrite(LED1,HIGH);
if (bL2==0) digitalWrite(LED2,LOW);
else digitalWrite(LED2,HIGH);
}
Parts should look familiar. Remember the basics of the obligatory setup and loop functions? They were....
void setup()
{
}
and
void loop()
{
}
The "void" is present. Instead of "setup" or "loop", we have this function's name, "setLEDs". We have the parentheses (ordinary brackets), and we have the curly braces.
Okay, we have something IN the parentheses. That's new. We'll deal with it in a moment. We have three "if" statements, with "else" clauses... but they shouldn't hold too many terrors. We see "digitalWrite", which we've met before, and the arguments for them shouldn't be too scary. Although you are forgiven if you are wondering when, for instance, LED0 is set low, and when it is set high.
First the stuff in the parentheses. There are three things. Each starts "byte". This is a keyword. It says that something is going to be of data type "byte", i.e., it can be a whole number from 0 to 255. WHAT can be 0 to 255? The "thing" we are going to "store in the variable". A variable is a place where we can put a piece of data. In the current program, that datum will either be zero or one, so that much at least is easy. WHERE are we putting zero or one? We're putting them in VARIABLES (places to store things) called bL2, bL1 and bL0. Those are the names of the three variables we CREATED when we put what we did inside the parentheses following "void setLEDs". The variable names start "b" to remind us that they are for holding byte type data. Then they have an "L" in their name for "LED", and lastly a 2,1 or 0 to indicate WHICH LED that datum relates to.
So... is it a zero or a one that gets put into the variable? And when do we do this "putting into variables"?
The when/ where of that is: While the Arduino is processing the setLED commands up in the "loop" function.
All of the stuff below (and including)....
void setLEDs(byte....
DEFINES the "setLEDs" function. It says what that function does.
The reason we bothered to define the function is that we wanted to use it. All we have to do to use it is to put "setLEDs(0,0,1)", or something equivalent inside the curly braces of the "setup" or "loop" functions. When we do that, we are "calling" the function. I.e., we're telling the Arduino "Go off to where the function was defined, and do what it says to do. When we call the setLED function, we can put whatever numbers we want inside the brackets... but only zero and one make any sense. Anything except a zero will be treated the same way as a one.
Where does the "0,0,1" (or similar) go?
Look again at the bottom of the program, at the place where setLEDs is defined.
The first zero goes into the bL2 variable. The second goes into the bL1 variable, and the one goes into the bL0 variable.
So what?
Read on!
Now you need to understand "if... else..." statements. They aren't deeply mysterious, but they are fussy that you do them right.
An "if... else..." statement always starts with the word "if". See: I told you it wasn't hard.
Then you'll always get something in brackets. In this case, the first "if... else..." has....
(bL0==0)
The thing in brackets always boils down to "true" or "false". With bL0==0, we are asking: "Is what's stored in the variable called bL0 a zero?" In other words, "Is the data stored in bL0 equal to zero?" (Note the double equal signs. They are used when you are doing a comparison. Here we are comparing what is in bL0 with zero. (If you see a single equals sign, as in the const statements at the start of the program, you are moving something into a variable or constant. If you did "bL0=25;", you would change what was in that variable, making bL0 hold 25 instead of what was there previously.))
So... apologies for the digression. Let's recap. We're looking at the "if... else..." statement.
It starts with "if".
Then there's the thing in the brackets. It always boils down to "true" or "false".
Then there's an ordinary statement, in this case that statement is....
digitalWrite(LED0,LOW);
(Don't leave out the semi-colon. It is important)
Then there's the word "else", followed by another statement.
Can you guess? If bL0==0 is true, then you do the first embedded statement. If what's stored in the variable bL0 is not a zero, you do the statement following the word "else". (You don't do the "else" statement if you do the first embedded statement.)
Not hard, really. If you are feeling a headache coming on, look again at.....
if (bL0==0) digitalWrite(LED0,LOW);
else digitalWrite(LED0,HIGH);
... and ask yourself "What SHOULD this do?" We wanted some code which sometimes turns the LED on, sometimes turns it off. Remember that something will have been put into bL0 by the process of calling the function. Break the whole thing down into its parts....
It REALLY is simple... when you get the hang of it.
Don't let the "then" get you thinking about times... The "then" is not used as in: "I will boil the kettle then pour the water over the tea bag." It is used as in "If a pupil works hard then the teacher will reward."
It's good that if/ thens are simple, 'cause there are two more of them in the function. Very similar to the first one, they look at the other two variables, and turn the other two LEDs on or off as requested when the function is called.
Brilliant! We have a program to count from 0 to 7 on some LEDs. But I don't think it is as clear as it could be yet. And I want to show you more "clever tricks". So we're going to modify it again.
But just before we do: BE CAREFUL when creating a condition. If you say, for instance, if (bTmp=47) when you MEANT to say if (bTmp==47), your program will "work"... but won't do what you wanted it to do. If you are testing if two things are equal, you need the DOUBLE equals sign symbol. As if that were not bad enough, the compiler won't catch your mistake if you only used a single equals sign. In some web browsers, you don't see any gap between the two equals signs. But they at least do look twice as wide as a single equals sign, and they will copy/paste as two. I can't put a space between them ("= =") for better clarity, or else the code won't copy/ paste successfully.
Onward...
That business of "making up new words", i.e. defining and using functions, is extremely powerful. We're going to write a new function called "showOnLEDs". It will be used like this....
showOnLEDs(0); showOnLEDs(1); showOnLEDs(2); showOnLEDs(3);... etc.
Inside "showOnLEDs" we're going to use more "if" statements. And deep within our program, we will still be using setLEDs... but in "loop", the "highest" level of the program, we will use the human friendly "showOnLEDs". That will make it easy to see at a glance what is going on. The details of how what gets done is accomplished is there, in the code, but neatly parceled up in the functions used to build the code.
Here's the new version. Note the new name, which is meant to tell you that this version uses a "ShowOn" function. (The changes made to create it are discussed below....)
/*FEAa1CountWithShowOn
ver 27 Dec 09
Requires 3 LEDs
*/
const byte LED0=11;//LED for LS bit connected here
const byte LED1=12;//LED connected here
const byte LED2=13;//LED for MS bit connected here
const word delayDuration=600;
void setup()//"setup" always present
{
pinMode(LED0,OUTPUT);
pinMode(LED1,OUTPUT);
pinMode(LED2,OUTPUT);
}
void loop()//This function always present
{
showOnLEDs(0);
showOnLEDs(1);
showOnLEDs(2);
showOnLEDs(3);
showOnLEDs(4);
showOnLEDs(5);
showOnLEDs(6);
showOnLEDs(7);
// and finally....
delay(delayDuration);
delay(delayDuration);//Create a longer delay before
//going back and counting up from zero again.
}
void setLEDs(byte bL2, byte bL1, byte bL0)
{
if (bL0==0) digitalWrite(LED0,LOW);
else digitalWrite(LED0,HIGH);
if (bL1==0) digitalWrite(LED1,LOW);
else digitalWrite(LED1,HIGH);
if (bL2==0) digitalWrite(LED2,LOW);
else digitalWrite(LED2,HIGH);
}
void showOnLEDs(byte bNumber)
/*The following might look like a lot of typing,
but with judicious use of copy/paste, it takes no
time at all. Also, because the code follows a
pattern, errors are easy to spot.*/
{
if (bNumber==0) setLEDs(0,0,0);
if (bNumber==1) setLEDs(0,0,1);
if (bNumber==2) setLEDs(0,1,0);
if (bNumber==3) setLEDs(0,1,1);
if (bNumber==4) setLEDs(1,0,0);
if (bNumber==5) setLEDs(1,0,1);
if (bNumber==6) setLEDs(1,1,0);
if (bNumber==7) setLEDs(1,1,1);
delay(delayDuration);
}
Look at FEAa1CountWithShowOn. Within "loop", things are now really simple....
void loop()//This function always present
{
showOnLEDs(0);
showOnLEDs(1);
showOnLEDs(2);
showOnLEDs(3);
showOnLEDs(4);
showOnLEDs(5);
showOnLEDs(6);
showOnLEDs(7);
// and finally....
delay(delayDuration);
delay(delayDuration);//Create a longer delay before
//going back and counting up from zero again.
}
The setLEDs function is the same as before. We've added, at the end of the code, a definition for a showOnLEDs function. Before looking at it too closely, notice a detail: the "delay(delayDuration);" has been moved from "higher" levels of the program to always occur as part of the showOnLEDs function. This just removes a distracting element from the higher level.
And look at the new bit, the showOnLEDs function definition. Yes, it goes on a bit... but there's nothing particularly challenging here....
void showOnLEDs(byte bNumber)
/*The following might look like a lot of typing,
but with judicious use of copy/paste, it takes no
time at all. Also, because the code follows a
pattern, errors are easy to spot.*/
{
if (bNumber==0) setLEDs(0,0,0);
if (bNumber==1) setLEDs(0,0,1);
if (bNumber==2) setLEDs(0,1,0);
if (bNumber==3) setLEDs(0,1,1);
if (bNumber==4) setLEDs(1,0,0);
if (bNumber==5) setLEDs(1,0,1);
if (bNumber==6) setLEDs(1,1,0);
if (bNumber==7) setLEDs(1,1,1);
delay(delayDuration);
}
(Yes... if you've heard of "case" structures, that is what you would use here... and the Arduino language has one. And, yes, this is sloppy because it does not deal with the possibility that someone would send it something other than 0 to 7.... but hey! This is an introduction!)
It can be even more elegant. Next we're going to play with JUST the....
showOnLEDs(0);
showOnLEDs(1);
showOnLEDs(2);
showOnLEDs(3);
showOnLEDs(4);
showOnLEDs(5);
showOnLEDs(6);
showOnLEDs(7);
... part of the previous counting program, to illustrate some more things.
Again... here's the re-written code. What was changed will be explained in a moment.
/*FEAa1CountWithLoopCounter
ver 27 Dec 09
Requires 3 LEDs
*/
const byte LED0=11;//LED for LS bit connected here
const byte LED1=12;//LED connected here
const byte LED2=13;//LED for MS bit connected here
const word delayDuration=600;
void setup()//"setup" always present
{
pinMode(LED0,OUTPUT);
pinMode(LED1,OUTPUT);
pinMode(LED2,OUTPUT);
}
void loop()//This function always present
{
byte bLoopCount=0;
showOnLEDs(bLoopCount);//0
bLoopCount=bLoopCount+1;
showOnLEDs(bLoopCount);//1
bLoopCount=bLoopCount+1;
showOnLEDs(bLoopCount);//2
bLoopCount=bLoopCount+1;
showOnLEDs(bLoopCount);//3
bLoopCount=bLoopCount+1;
showOnLEDs(bLoopCount);//4
bLoopCount=bLoopCount+1;
showOnLEDs(bLoopCount);//5
bLoopCount=bLoopCount+1;
showOnLEDs(bLoopCount);//6
bLoopCount=bLoopCount+1;
showOnLEDs(bLoopCount);//7
// and finally....
delay(delayDuration);
delay(delayDuration);//Create a longer delay before
//going back and counting up from zero again.
}
void setLEDs(byte bL2, byte bL1, byte bL0)
{
if (bL0==0) digitalWrite(LED0,LOW);
else digitalWrite(LED0,HIGH);
if (bL1==0) digitalWrite(LED1,LOW);
else digitalWrite(LED1,HIGH);
if (bL2==0) digitalWrite(LED2,LOW);
else digitalWrite(LED2,HIGH);
}
void showOnLEDs(byte bNumber)
/*The following might look like a lot of typing,
but with judicious use of copy/paste, it takes no
time at all. Also, because the code follows a
pattern, errors are easy to spot.*/
{
if (bNumber==0) setLEDs(0,0,0);
if (bNumber==1) setLEDs(0,0,1);
if (bNumber==2) setLEDs(0,1,0);
if (bNumber==3) setLEDs(0,1,1);
if (bNumber==4) setLEDs(1,0,0);
if (bNumber==5) setLEDs(1,0,1);
if (bNumber==6) setLEDs(1,1,0);
if (bNumber==7) setLEDs(1,1,1);
delay(delayDuration);
}
This may not yet look like an improvement! But we are "on a road". Patience, Grasshopper. Read on.
First we had to create a variable to hold a byte while we're in the "loop" function. Nothing easier. Just after....
void loop()
{
.... insert...
byte bLoopCount=0;
That establishes a variable called bLoopCount, and puts a zero in it to start things off.
(Variables are cool and important. They are places to put stuff. More will become evident, I hope. N.B. Their names are case sensitive. bLoopcount and bLoopCount are DIFFERENT, as far as the Arduino environment is concerned. If you get "xxx was not declared....", you may well have simply changed, somewhere, some capital letters to lower case versions, or vice versa.)
Have a look at the rest of the new loop(). You should see the pattern in it, at least! Even if it doesn't entirely make sense to you at this point.
As bLoopCount will be holding zero at the time we do the first showOnLEDs(bLoopCount), it will be as good as showOnLEDs(0).
The line....
bLoopCount=bLoopCount+1;
... may puzzle the more mathematical readers. Forget what you thought the equals sign was about. In the Arduino read "=" as "becomes" (unless it is a double =, as met recently in "if" statements)
So....
bLoopCount=bLoopCount+1;
...means "what is in bLoopCount BECOMES whatever was in bLoopCount previously, plus one.
So! Our new code is as good as the....
showOnLEDs(0) showOnLEDs(1) showOnLEDs(2)....
...we had earlier. So why did we mess with it!
Patience! All will be revealed. Here's why we "messed up" our nice simple program....
All (but one) of those "showOnLEDs can be dispensed with if you replace the loop() we had previously with this simple little bit of code....
void loop()//This function always present
{
byte bLoopCount=0;
do {
showOnLEDs(bLoopCount);
bLoopCount=bLoopCount+1;
}
while (bLoopCount<8);
// and finally....
delay(delayDuration);
delay(delayDuration);//Create a longer delay before
//going back and counting up from zero again.
}
Much of this new loop() has already been explained. Here's the rest...
The "do" is a keyword. It marks the start of a loop. The curly braces (after the "do", before the "while") mark a block of statements, all of which are to be done again and again until the condition following the "while" is no longer true.
So, the general form of the "do" statement is....
Note that the "do" statement, like any other, ends with a semicolon. The statement or statements within the "do" statement ("bundled" by means of the curly braces) also have semicolons, as usual. However tedious computers may be, they are usually consistent!
(This solution above is often called a "repeat...until" structure in other languages.)
ANOTHER way to skin this cat!....
The following will work perfectly well, too.
void loop()//This function always present
{
byte bLoopCount=0;
while (bLoopCount<8) {
showOnLEDs(bLoopCount);
bLoopCount=bLoopCount+1;
};
// and finally....
delay(delayDuration);
delay(delayDuration);//Create a longer delay before
//going back and counting up from zero again.
}
In this instance, there is little difference between the alternatives, but there are times when either a "do... while" or a "while..." is easier than the close alternative. If you find one or the other easier to read, easier to grasp at a glance, then use that! Remember: A Good Program is one that you can understand, when you look at the sourcecode.
Other than the code being more clear, a VERY good reason all by itself, why bother?
For what we have been dealing with, showing zero to seven, the pedestrian....
showOnLEDs(0) showOnLEDs(1) showOnLEDs(2)....
... works perfectly well. Imagine how happy you will be to know about using loops and a variable if, as sometimes happens, you want to do something like show every number from zero to 255! (You would need 8 LEDs, but other than that, easily done.) Also, our crude solution only works if we know in advance the start and end numbers. That is not always the case.
Lastly, another way to do a loop!..... the "for" statement. Very powerful. Used a lot by many programmers.
In order to show zero to 7 on the LEDs, we just rewrite the loop function as follows....
void loop()//This function always present
{
for (byte bLoopCount=0;
bLoopCount<8;
bLoopCount++)
{
showOnLEDs(bLoopCount);
}
// and finally....
delay(delayDuration);
delay(delayDuration);//Create a longer delay before
//going back and counting up from zero again.
}
This, though it may be hard to see it, is essentially what we had before.
The declaration and initialization of the variable "bLoopCount" is now taken care of just after the word "for". The test for how long we loop is the second element inside the parentheses after "for" (we will loop WHILE that condition is true), and, most mysterious of all, the third element, the "bLoopCount++" is equivalent to the old "bLoopCount=bLoopCount+1;"
You can either use the more obvious form, already shown to you, or you can start using the wonderful "for" keyword. The nice people at Arduino HQ have put a full discussion of the "for" keyword online (and all the others, of course.)
Well done getting to here! We will be moving on from having LEDs show use zero to seven in the next tutorial!!! (But we will re-use the code we've developed... for other things. Remember: One of the characteristics of Good Software is that it can be adapted to serve multiple needs.)
The search engine is not intelligent. It merely seeks the words you specify. It will not do anything sensible with "What does the 'could not compile' error mean?" It will just return references to pages with "what", "does", "could", "not".... etc.
SPELL your search term properly. When I review search logs, it is amazing how many people ask the engine to search for something meaningless.
Why does this site cause a script to run? I have my web-traffic monitored for me by eXTReMe tracker. They offer a free tracker. If you want to try it, check out their site. And if there are Google ads on the page, they are run with scripts, too.
Here is how you can contact this page's editor. This page, and the software it references, ©TK Boyd, 1/2010.
Page tested for compliance with INDUSTRY (not MS-only) standards, using the free, publicly accessible validator at validator.w3.org