Implementing a sensor network with simpliciTI using AP as data hub

Here is some code which does what I think you are looking for.  It replaces the project for the AP as data hub under the ez430 platform and also provides modified main files for the autoack version of the project.  You will want to copy the files in the appropriate directories into the same directories in your installation of simpliciti as this set of files only contains those files which needed to be changed.

7888.SimpliciTI-IAR-1.1.1.zip

The code implements a simple command driven interface via the back channel virtual com port on the ez430 devices.  You can control the whole system from a hyperterminal window or you can use the GUI package in the polling_pwms subdirectory.  If you want the source code for the GUI, let me know but its a bit big to post directly if you don't need it.

You will program up each end device (up to 10) using the end device configuration for the ez430-CC2500 and make sure each device has a different address.  Then program up one ez430-CC2500 as an access point and attach this one to your computer.

If you want to use hyperterminal, find the correct port by looking at the device manager and seeing which port is added when you unplug and re-plug the access point dongle.  Then open a connection using 9600 baud, 8 bit data, 1 stop bit, and no flow control.  Once the connection is open, type L^m^j where ^M is (ctrl + m) and ^j is (ctrl + j).  Note characters are case sensitive.  After typing this three character command, if all is working properly, you should get a loopback command response from the access point.  This proves the com port is working to the dongle.

After you know the com port is working, turn on one end device at a time. you should get confirmation in the hyperterminal window that another link was established.  After you have setup your network with a number of end devices (1 is all you need but more shows the system better) type the command C^m^j and the access point should respond with the number of connected links.

If you type the command Inn^m^j (a capital I as in Identify) where nn is the node number you wish to identify, i.e. 00 for node number zero, 01 for node 1, etc., within a couple of seconds of pressing the ^j you should see one of the LED's on the corresponding end device blink to identify it.

If you now type the command Qnn^m^j, again nn is the node number, after a couple of seconds the node will respond with the value held in it's PWM value register.

Finally, if you type the command Pnn:xxx^m^j where nn is the node number, and xxx is a three digit decimal number between 000 and 100 inclusive, you will set the PWM register on node nn to the value xxx.  Unfortunately, I haven't had the time to make the PWM code work properly so for now it merely holds the data in a variable on the end device.

The reason for the delay's in operations is that the network is set up with the end devices as polling end devices.  This means they turn off thier radios and sleep for about 4 seconds.  Then when they wake up they querry the access point to see if there are any messages for it and if so it downloads them at that time and responds if necessary.

One last demonstration is to press the button on one of the end devices.  You should see a response in the hyperterminal window indicating the state of the button.  Note that there is no delay here as the radio is awaken immediately as the button press represents an event to respond to.

The radios don't actually sleep, the code merely turns off the radio so it appears to be sleeping.  This simplifies the code for the demonstration but everywhere in the code where a long delay is implemented is where you would actually put the system to sleep.

If you install the GUI, you can manage all of this simply by clicking buttons and stuff.  Make sure the access point is plugged in before opening the com port.  The GUI will detect the correct com port automatically.  Each time a new node is linked into the network, a set of controls for that node will be displayed.

Hope this is the type of code you were looking for,

Jim Noxon

Allow me to make some definitions first.

Generaly, a lower case t is used for continuous time systems.  When moving to sampled systems, T_i is used as it represents the time of the i^th sample.  This reason for detailing this semantic difference is to ease the mathematical representation a bit.  Note that T_i represents a sample period as in T_i = t_i+1 - t_i.  Further simplification results if we make all the sample periods the same, i.e. T₀ = T₁ = T₂ = ... = T_i.  Thus, all sample periods can be represented by the constant T₀.  In this case, each sample time is then merely T_i = iT₀.  In this case, the sample period wouldn't need to be sent with each ADC sample as the constant T₀ would be known at compile time.

In your system it sounds like you are using a non constant sample period thus your requirement to send the sample period with each sample.  In this case and from a code stand point, it would be easier to send the sample time of t_i+1 as the actual sample period can be reconstructed from this stream of sample times as above.  Note that t₀ = 0 in this case.

Now for how to do it.  The suggested form would be to simply have a timer count from 0 to FFFF (or what ever value you choose) but a modulo 2 value can be easier when calculating the sample period.

Next, when you sample the ADC, simply sample the timer value at the same time.  You shouldn't need to worry if the samples of the ADC and timer are not simultaneous as long as the latency between the two is constant, as in a couple of machine instructions of time.  You may want to disable interrupts while sampling the ADC and timer otherwise you may get some sample periods which include the latency of an interrupt being run.

Once you have the sample of the ADC and timer, package them up and send them across the radio link.

Now for the code on the far end radio. 

void get_samples( void )
{
  static uint16_t last_time_sample = 0;
  uint16_t time_sample;
  uint16_t sample_period;
  uint16_t adc_sample;

  // get samples from radio
  radio_recieve( &adc_sample, &time_sample );
  // calculate t(i+1)-t(i)
  sample_period = time_sample - last_time_sample;
  // save sample time history
  last_time_sample = time_sample;
  // output current sample and sample period
  plot( adc_sample, sample_period );
}

If you prefer, you could return the data in a structure instead of calling the plot function but you should get the idea.

The subtraction works if the timer is allowed to count to its maximum value as the difference will always be calculated correctly from the modulo arithmetic of finite sized integers.  If you don't want your timer to count to maximum value then you just need to put a check in to determine if the timer overflowed by comparing it to the last sample time.

Hope this is what you were looking for.

Jim Noxon

I believe that link leads to the same post I was talking about in a previous comment. But I figured out how to debug the AP and the ED.

Since English is not my first language I didn't understand what a "CCS instance" was, so I created a similar project on the same workspace and tried to do what was showed on the link we posted before. After going over that and looking for other posts I realized that for the case of the MSP430 you can't have more than one processor on the same target configuration. That is discussed on this post:

http://e2e.ti.com/support/development_tools/code_composer_studio/f/81/p/104982/370249.aspx#370249

Then since I had to terminate the debug session if I tried to debug other project within the same workspace I tried launching another CCS (I realized that this happens to be another CCS instance) in other workspace. Nevertheless it wasn't detecting the other FET. Then what I did is to modify the Target Configuration on one of the two instances such that one used TI MSP430 USB2 as a connection while the other kept using the default TI MSP430 USB1 connection. Of course I added the MSP430FG4618 as the device for the modified Target Configuration. Now I am modifying the code and debugging the projects.

So in summary, to debug two projects with CCS you need to launch two CCS instances with a different work space on each, and modify the Target Configuration such that the connection is not done by the same device.

Regards,

Efrain