The algorithms shown here are screaming out "table" "table" "table".

Management of irregular type sequences such as shown here are most often best handled through the use of a table. Each entry in the table can consist of something like // action // parameter // port/bit //. A simple code routine can simply initilaize an index to the table to the first entry and then scan down through the table one step at a time.

The action member of each element can include functions such as:

SET port pit
CLR port bit
LOAD loop counter
LOOP decrement counter and change index if not zero
STOP sequence

The parameter member of each element can be used in various ways based upon the action value. For example if the action is SET or CLR this could be a delay time to wait till proceeding to the next index in the table. For the LOAD action this could be the count to put into the looping management counter. Finally if the action was the LOOP type the parameter could be the index number to branch to if the loop counter is non-zero after the decrement. (And if programming in Assembler the index value inserted can be computed at assembly time using some simple label arithmetic instantiated via a macro. Harder to do in C.)

This scheme makes it very easy to make arbitrarily complex sequences of the LEDs without having to write new code each time.

Some will say that this may be too complicated of an approach for students and beginning programmers but I would say otherwise. It is a very good way to force programmers to think of appropriate ways to write programs instead of the HORRIBLE code we see in the first posting here. If a beginner learns things like this from the onset of their programming venture they will forever think of good ways to do things instead of bad ways.

Michael Karas