• Use your TOS and PWM skills to implement two nodes of a cellular automata-like system for distributing bird songs
• Take the completed "birds" to the atrium to join the flock

In this lab you will learn the following:

• How to build a multi-module radio application
• How well the proposed flock algorithm works in practice
   

Flock Algorithm:
 
Within a single "bird", the flock algorithm that you will implement is as follows:

Implement the above algorithm with attention to the implementation details below.
 

Some Implementation Details:

The Atrium Group ID will be 122. Each mote will use the same group ID, and Node ID (Local #)   == the number on your mote's label.

The average bird song length is 2.845 sec, the sum of all the song lengths is 45.52 sec.

Our 16 bird songs in numbered order are:

Store your songs in flash program space. Here is progspace.h which shows how to do that.

There are 4 types of Active Messages your program must handle; they are as follows:

While listening, we collect the information we hear (AM #42 type packets) in a 64-entry circular FIFO queue.
Each queue entry looks as follows:

Each entry writes over the oldest entry in the queue.
 
The algorithm for deciding the song to sing is as follows:

 
For all entries in our circular FIFO queue{
   // calculate weight_i for songNum i == 0 to 15
   Weight_i = sum of TOS_msg_strength  in circular FIFO queue for each songNum
}

Find  Weight_max == Largest Weight; Weight_maxSongNum is song with Weight_max

Find  Weight_{min == Smallest non-zero Weight;} Weight_minSongNum is song with Weight_min
 
x = rand() % Probability
y = rand() % Silence

if(x == 0 )
   SONG = Weight_minSongNum

else if(y == 0)
     Don't sing a song-- go to C.

else{
   if(Weight_max < minThreshold) ||
    ((Weight_max > Threshold) && (You have already sung Weight_maxSongNum more than Repetition times)) )
      SONG = random song not among the last three songs you've sung more than Repetition times
   else
      SONG = Weight_maxSongNum
}
 
Notes:

The threshold and Repetition count are meant to ensure that songs are
allowed to propagate through the flock, but then die off after a while. 
The repetition allows a strong song to propagate to a large number of
nodes, but then once a song has played for a while, it should die off. 
This growth and dieoff is accomplished by limiting the number of
repetitions once the threshold is reached.

The count of the number of times you've sung a song should be incremented
only when you sing the weightMax song and the weight of that song is above
the threshold value.  This count is what you'll compare against Repetition
to determine whether or not to add the song to the set of three songs that
you'll NOT choose from when choosing a random song. This do-not-sing list
causes the very strong songs to die off.  Once a song falls off the
do-not-sing list (3 other songs have been put on) its count should be
reset to 0.

TOS_Msg.strength is automatically updated with the packet strength during reception.

You can set the transmission power level using the function
CC1000Control.SetRFPower(int)
    Use the component CC1000ControlM.

Random numbers:
/* Return the next 16 bit random number */
  async command uint16_t Random.rand()

Returns unsigned 16 bit number.

It's seeded from the node ID, so each mote will have a different number sequence:
  /* Initialize the seed from the ID of the node */
  async command result_t Random.init()

See tos/system/RandomLFSR.nc

For the purposes of the final project assume that the timer function takes milliseconds. If we give you a time of 1 second assume if you set a timer to fire in 1000ms it will fire 1 second later. For the flock to be successful we all must use the same assumptions.

You can remove your light sensor, but you'll need to add a sound transducer to your second mote.

Extra Credit: Improve your sound quality by modifying your PWM software.
Hints: 1) consider using 5-bit instead of 8-bit PWM
          2) consider using timer 3 CTC mode and output compare interrupt
NOBODY WILL HELP YOU WITH THIS!!!  DON'T ASK HOW!!!

Deliverables

Note: If you use the atomic statement, you MUST justify its use in your comments in your source.  The indiscriminate use of atomic blocks will be count against you! Be sure to describe in your comments why an atomic block was necessary, and why it is better than a different design. Your compile should not show any atomic or async warnings; we may check this during the grading process.

1) Use the test program provided by the course staff to test your algorithm. (The test program will be distributed near the end of this week) Feel free to modify the test program to generate more elaborate testing scenarios and to share the testing scenarios with other members of the class. The more testing completed before the final check off the better.

2) A final test will be applied by the course staff to see if your bird is following the algorithm protocol. This final test will be given before the final and will account for the largest chunk of the project grade. You should show up to the final test highly confident that there are no errors.

3) Once your birds pass the final screening test, you may proceed to the atrium for the final demonstration.

TURN-IN:  Hand in a COMMENTED print-out of all your  code.  Put your name(s) on the print-out.

End