This Nesc/TinyOS application is for measuring the temperature with maximum of two sensors. One acts like a '''Base Station''' and has to be connected with the USB connection to the computer. The second acts like a '''Remote Station''' and transmitts its temperature reading via the radio to the '''Base Station'''. At the final stage, the '''Base Station''' transmitts the complete data, both temperature readings, to the computer every second. Please note that the application described here can be used without any '''Remote Station'''.
In this document it is described how to install the Nesc/TinyOS application <code>TRead</code> and how to retreive and interpret the data.

It is assumed that the installation of TinyOS 1.x and Nesc is installed with the nessecary components.

== Installation of the application ==

Extract the [http://rtime.felk.cvut.cz/wsn/RT_Object_Tracking/TRead.zip TRead.zip] application in the folder <code>xxx/tinyos-1.x/apps/</code>. Then in the folder <code>xxx/tinyos-1.x/apps</code>, install the application by following line:

(For Tmote Sky connected to USB port 0) 
<code>make telosb && make telosb install.$2 bsl,/dev/ttyUSB0</code>

NOTE! 
In the file <code>TReadM.nc</code>, at the top, there is a preprocessor definition <code>#define BASE_STATION</code>.
When installing for the '''Remote station''', comment this line and install as described above. For '''Base Station''', leave it as it is.

== Retrieving the data ==

Extract the [http://rtime.felk.cvut.cz/wsn/RT_Object_Tracking/TReadSerial.zip TReadSerial.zip] file. Here, you will find a C++ class called <code>CSerialCom</code> that can be used for retreiving the data.

 API: Opens the connection to a serial device
with i.e "/dev/USB0" (Linux)
 <code>int openDevice(const char* pDevice)</code>
 
Closes the connection to the serial device
 <code>void closeDevice(void)</code>
 
Settings for the serial device 
'''IN''': Only type available: <code>TYPE_TMOTE_SKY</code>
 <code>void setOptions(int type)</code>
 
Retreives the data from the serial port if any available. Max waiting 
time for the data retreival is 6s. Where after the return value will be 0. 
'''IN''': <code>pData</code>: where the data should be stored. allocated by the caller 
'''Return''': Nr of bytes allocated in the pData buffer.
 <code>int getData(char* & pData)</code>
 
Sends the to the serial device NOTE! Doesn't work!
 '''IN''': <code>pData</code>: buffer to transmitt
 <code>length</code>: number of bytes to send from the buffer
 <code>int sendData(uint8_t* pData, int length);</code>
 

== Interpretting the data ==

The data is retrived in so called raw format as following:

[[Image:SerialRawStream.png]] B = Byte(s)

'''7E''': The leading and trailing ''framing byte'' <code>0x7E</code> can be ignored. 

'''TYPE''': In this application, <code>0x42</code> Which means no acknowledge is required. 

'''NN''': Number of bytes of data that is sent in this packet

'''RESERVED''': TMote reservation

'''DEST'''. ADDR: Packet destination. In this application: <code>0xFF 0xFF</code>

'''MSG TYPE''': Not used in this application. Always: 0x01

'''GRP ID''': Group ID. Default set to 0x7D

'''DATA''': NN bytes of data sent. Explained further down

'''CRC''': Checksum (ignored)

 '''''DATA''''' 
The encapsulated data is in the following format:

[[Image:SerialData.png]]

LOCAL = Base Station
 REMOTE = Remote Station

'''NOTE!'''
 1. The raw stream is in '''Little Endian''' format
 2. The following escaped are used for maintaing the framing byte protocol
0x7E -> 0x7D 0x5E
0x7D -> 0x7D 0x5D

=== Example ===
The data will be retreived as following (HEX VALUES)

<code>7E 42 08 00 00 00 00 00 7D 5E 00 01 7D 5D XX XX XX XX XX XX XX XX RR (RR) 7E</code> 
After removing the framing bytes and the escape code sequences, the ACTUAL packet is: 
<code>42 08 00 00 00 00 00 7E 00 01 7D XX XX XX XX XX XX XX XX RR (RR)</code> 

TYPE is 42 (NO_ACK). Data length is 8 bytes in the data region.

== Additional ==
The temperature can be calculated with the following C# code. However, it's not tested:

<code>
Calculating Temperature in Engineering Units
/// <summary>
/// Calculates the temperature, in degrees Celsius of the:
///
/// Panasonic ERT-J1VR103J Thermistor
///
/// The formula in the MTS Series User Manual is:
/// 1/T(K) = a + b × ln(Rthr) + c × [ln(Rthr)]^3
///
/// where:
/// Rthr = R1(ADC_FS-ADC)/ADC
/// a = 0.00130705
/// b = 0.000214381
/// c = 0.000000093
/// R1 = 10 kOhm
/// ADC_FS = 1023
/// ADC = output value from mote’s ADC measurement.
///
/// Note that an adjusted temp (adjTemp) is used because the
/// actual temp reading is a 10 bit value that has been compressed
/// into a single byte. As such it must be shifted left 2 bit places.
///
/// The value for _temp is the raw sensor reading from the SurgeMsg.
///
/// </summary>
/// <returns>Temperature in Degrees Celsius as a float.</returns>
float CalculateTempC()
{
int adjTemp = _temp << 2;

// prevent divide by zero.
if(adjTemp == 0)
return 0F;

float temperature, a, b, c, Rthr;
a = 0.001307050F;
b = 0.000214381F;
c = 0.000000093F;
Rthr = 10000 * (1023 - adjTemp) / adjTemp;

temperature = 1 / (float)(a + b * Math.Log(Rthr) + c *
Math.Pow(Math.Log(Rthr),3));
temperature -= 273.15F; // Convert from Kelvin to Celcius

}
</code>

Real-Time Object Tracking

2007-04-21T15:16:32Z

Indy: /* '''Tasks''' */

Temperature reading application

2007-04-17T20:56:55Z

Indy: /* Installation of the application */

This Nesc/TinyOS application is for measuring the temperature with maximum of two sensors. One acts like a '''Base Station''' and has to be connected with the USB connection to the computer. The second acts like a '''Remote Station''' and transmitts its temperature reading via the radio to the '''Base Station'''. At the final stage, the '''Base Station''' transmitts the complete data, both temperature readings, to the computer every second. Please note that the application described here can be used without any '''Remote Station'''.
In this document it is described how to install the Nesc/TinyOS application <code>TRead</code> and how to retreive and interpret the data.

It is assumed that the installation of TinyOS 1.x and Nesc is installed with the nessecary components.

== Installation of the application ==

Extract the [http://rtime.felk.cvut.cz/wsn/RT_Object_Tracking/TRead.zip TRead.zip] application in the folder <code>xxx/tinyos-1.x/apps/</code>. Then in the folder <code>xxx/tinyos-1.x/apps</code>, install the application by following line:

(For Tmote Sky connected to USB port 0) 
<code>make telosb && make telosb install.$2 bsl,/dev/ttyUSB0</code>

NOTE! 
In the file <code>TReadM.nc</code>, at the top, there is a preprocessor definition <code>#define BASE_STATION</code>.
When installing for the '''Remote station''', comment this line and install as described above. For '''Base Station''', leave it as it is.

== Retrieving the data ==

Extract the [http://rtime.felk.cvut.cz/wsn/RT_Object_Tracking/TReadSerial.zip TReadSerial.zip] file. Here, you will find a C++ class called <code>CSerialCom</code> that can be used for retreiving the data.

 API: Opens the connection to a serial device
with i.e "/dev/USB0" (Linux)
 <code>int openDevice(const char* pDevice)</code>
 
Closes the connection to the serial device
 <code>void closeDevice(void)</code>
 
Settings for the serial device 
'''IN''': Only type available: <code>TYPE_TMOTE_SKY</code>
 <code>void setOptions(int type)</code>
 
Retreives the data from the serial port if any available. Max waiting 
time for the data retreival is 6s. Where after the return value will be 0. 
'''IN''': <code>pData</code>: where the data should be stored. allocated by the caller 
'''Return''': Nr of bytes allocated in the pData buffer.
 <code>int getData(char* & pData)</code>
 
Sends the to the serial device NOTE! Doesn't work!
 '''IN''': <code>pData</code>: buffer to transmitt
 <code>length</code>: number of bytes to send from the buffer
 <code>int sendData(uint8_t* pData, int length);</code>
 

== Interpretting the data ==

The data is retrived in so called raw format as following:

[[Image:SerialRawStream.png]] B = Byte(s)

'''7E''': The leading and trailing ''framing byte'' <code>0x7E</code> can be ignored. 

'''TYPE''': In this application, <code>0x42</code> Which means no acknowledge is required. 

'''NN''': Number of bytes of data that is sent in this packet

'''RESERVED''': TMote reservation

'''DEST'''. ADDR: Packet destination. In this application: <code>0xFF 0xFF</code>

'''MSG TYPE''': Not used in this application. Always: 0x01

'''GRP ID''': Group ID. Default set to 0x7D

'''DATA''': NN bytes of data sent. Explained further down

'''CRC''': Checksum (ignored)

 '''''DATA''''' 
The encapsulated data is in the following format:

[[Image:SerialData.png]]

LOCAL = Base Station
 REMOTE = Remote Station

'''NOTE!'''
 1. The raw stream is in '''Little Endian''' format
 2. The following escaped are used for maintaing the framing byte protocol
0x7E -> 0x7D 0x5E
0x/D -> 0x7D 0x5D

=== Example ===
The data will be retreived as following (HEX VALUES)

<code>7E 42 08 00 00 00 00 00 7D 5E 00 01 7D 5D XX XX XX XX XX XX XX XX RR (RR) 7E</code> 
After removing the framing bytes and the escape code sequences, the ACTUAL packet is: 
<code>42 08 00 00 00 00 00 7E 00 01 7D XX XX XX XX XX XX XX XX RR (RR)</code> 

TYPE is 42 (NO_ACK). Data length is 8 bytes in the data region.

== Additional ==
The temperature can be calculated with the following C# code. However, it's not tested:

<code>
Calculating Temperature in Engineering Units
/// <summary>
/// Calculates the temperature, in degrees Celsius of the:
///
/// Panasonic ERT-J1VR103J Thermistor
///
/// The formula in the MTS Series User Manual is:
/// 1/T(K) = a + b × ln(Rthr) + c × [ln(Rthr)]^3
///
/// where:
/// Rthr = R1(ADC_FS-ADC)/ADC
/// a = 0.00130705
/// b = 0.000214381
/// c = 0.000000093
/// R1 = 10 kOhm
/// ADC_FS = 1023
/// ADC = output value from mote’s ADC measurement.
///
/// Note that an adjusted temp (adjTemp) is used because the
/// actual temp reading is a 10 bit value that has been compressed
/// into a single byte. As such it must be shifted left 2 bit places.
///
/// The value for _temp is the raw sensor reading from the SurgeMsg.
///
/// </summary>
/// <returns>Temperature in Degrees Celsius as a float.</returns>
float CalculateTempC()
{
int adjTemp = _temp << 2;

// prevent divide by zero.
if(adjTemp == 0)
return 0F;

float temperature, a, b, c, Rthr;
a = 0.001307050F;
b = 0.000214381F;
c = 0.000000093F;
Rthr = 10000 * (1023 - adjTemp) / adjTemp;

temperature = 1 / (float)(a + b * Math.Log(Rthr) + c *
Math.Pow(Math.Log(Rthr),3));
temperature -= 273.15F; // Convert from Kelvin to Celcius

}
</code>

Temperature reading application

2007-04-17T20:56:41Z

Indy: /* Retrieving the data */

This Nesc/TinyOS application is for measuring the temperature with maximum of two sensors. One acts like a '''Base Station''' and has to be connected with the USB connection to the computer. The second acts like a '''Remote Station''' and transmitts its temperature reading via the radio to the '''Base Station'''. At the final stage, the '''Base Station''' transmitts the complete data, both temperature readings, to the computer every second. Please note that the application described here can be used without any '''Remote Station'''.
In this document it is described how to install the Nesc/TinyOS application <code>TRead</code> and how to retreive and interpret the data.

It is assumed that the installation of TinyOS 1.x and Nesc is installed with the nessecary components.

== Installation of the application ==

Extract the [http://rtime.felk.cvut.cz/wsn/RT_Object_Tracking/TRead.zip TRead] application in the folder <code>xxx/tinyos-1.x/apps/</code>. Then in the folder <code>xxx/tinyos-1.x/apps</code>, install the application by following line:

(For Tmote Sky connected to USB port 0) 
<code>make telosb && make telosb install.$2 bsl,/dev/ttyUSB0</code>

NOTE! 
In the file <code>TReadM.nc</code>, at the top, there is a preprocessor definition <code>#define BASE_STATION</code>.
When installing for the '''Remote station''', comment this line and install as described above. For '''Base Station''', leave it as it is.

== Retrieving the data ==

Extract the [http://rtime.felk.cvut.cz/wsn/RT_Object_Tracking/TReadSerial.zip TReadSerial.zip] file. Here, you will find a C++ class called <code>CSerialCom</code> that can be used for retreiving the data.

 API: Opens the connection to a serial device
with i.e "/dev/USB0" (Linux)
 <code>int openDevice(const char* pDevice)</code>
 
Closes the connection to the serial device
 <code>void closeDevice(void)</code>
 
Settings for the serial device 
'''IN''': Only type available: <code>TYPE_TMOTE_SKY</code>
 <code>void setOptions(int type)</code>
 
Retreives the data from the serial port if any available. Max waiting 
time for the data retreival is 6s. Where after the return value will be 0. 
'''IN''': <code>pData</code>: where the data should be stored. allocated by the caller 
'''Return''': Nr of bytes allocated in the pData buffer.
 <code>int getData(char* & pData)</code>
 
Sends the to the serial device NOTE! Doesn't work!
 '''IN''': <code>pData</code>: buffer to transmitt
 <code>length</code>: number of bytes to send from the buffer
 <code>int sendData(uint8_t* pData, int length);</code>
 

== Interpretting the data ==

The data is retrived in so called raw format as following:

[[Image:SerialRawStream.png]] B = Byte(s)

'''7E''': The leading and trailing ''framing byte'' <code>0x7E</code> can be ignored. 

'''TYPE''': In this application, <code>0x42</code> Which means no acknowledge is required. 

'''NN''': Number of bytes of data that is sent in this packet

'''RESERVED''': TMote reservation

'''DEST'''. ADDR: Packet destination. In this application: <code>0xFF 0xFF</code>

'''MSG TYPE''': Not used in this application. Always: 0x01

'''GRP ID''': Group ID. Default set to 0x7D

'''DATA''': NN bytes of data sent. Explained further down

'''CRC''': Checksum (ignored)

 '''''DATA''''' 
The encapsulated data is in the following format:

[[Image:SerialData.png]]

LOCAL = Base Station
 REMOTE = Remote Station

'''NOTE!'''
 1. The raw stream is in '''Little Endian''' format
 2. The following escaped are used for maintaing the framing byte protocol
0x7E -> 0x7D 0x5E
0x/D -> 0x7D 0x5D

=== Example ===
The data will be retreived as following (HEX VALUES)

<code>7E 42 08 00 00 00 00 00 7D 5E 00 01 7D 5D XX XX XX XX XX XX XX XX RR (RR) 7E</code> 
After removing the framing bytes and the escape code sequences, the ACTUAL packet is: 
<code>42 08 00 00 00 00 00 7E 00 01 7D XX XX XX XX XX XX XX XX RR (RR)</code> 

TYPE is 42 (NO_ACK). Data length is 8 bytes in the data region.

== Additional ==
The temperature can be calculated with the following C# code. However, it's not tested:

<code>
Calculating Temperature in Engineering Units
/// <summary>
/// Calculates the temperature, in degrees Celsius of the:
///
/// Panasonic ERT-J1VR103J Thermistor
///
/// The formula in the MTS Series User Manual is:
/// 1/T(K) = a + b × ln(Rthr) + c × [ln(Rthr)]^3
///
/// where:
/// Rthr = R1(ADC_FS-ADC)/ADC
/// a = 0.00130705
/// b = 0.000214381
/// c = 0.000000093
/// R1 = 10 kOhm
/// ADC_FS = 1023
/// ADC = output value from mote’s ADC measurement.
///
/// Note that an adjusted temp (adjTemp) is used because the
/// actual temp reading is a 10 bit value that has been compressed
/// into a single byte. As such it must be shifted left 2 bit places.
///
/// The value for _temp is the raw sensor reading from the SurgeMsg.
///
/// </summary>
/// <returns>Temperature in Degrees Celsius as a float.</returns>
float CalculateTempC()
{
int adjTemp = _temp << 2;

// prevent divide by zero.
if(adjTemp == 0)
return 0F;

float temperature, a, b, c, Rthr;
a = 0.001307050F;
b = 0.000214381F;
c = 0.000000093F;
Rthr = 10000 * (1023 - adjTemp) / adjTemp;

temperature = 1 / (float)(a + b * Math.Log(Rthr) + c *
Math.Pow(Math.Log(Rthr),3));
temperature -= 273.15F; // Convert from Kelvin to Celcius

}
</code>

Temperature reading application

2007-04-17T20:55:53Z

Indy: /* Installation of the application */

This Nesc/TinyOS application is for measuring the temperature with maximum of two sensors. One acts like a '''Base Station''' and has to be connected with the USB connection to the computer. The second acts like a '''Remote Station''' and transmitts its temperature reading via the radio to the '''Base Station'''. At the final stage, the '''Base Station''' transmitts the complete data, both temperature readings, to the computer every second. Please note that the application described here can be used without any '''Remote Station'''.
In this document it is described how to install the Nesc/TinyOS application <code>TRead</code> and how to retreive and interpret the data.

It is assumed that the installation of TinyOS 1.x and Nesc is installed with the nessecary components.

== Installation of the application ==

Extract the [http://rtime.felk.cvut.cz/wsn/RT_Object_Tracking/TRead.zip TRead] application in the folder <code>xxx/tinyos-1.x/apps/</code>. Then in the folder <code>xxx/tinyos-1.x/apps</code>, install the application by following line:

(For Tmote Sky connected to USB port 0) 
<code>make telosb && make telosb install.$2 bsl,/dev/ttyUSB0</code>

NOTE! 
In the file <code>TReadM.nc</code>, at the top, there is a preprocessor definition <code>#define BASE_STATION</code>.
When installing for the '''Remote station''', comment this line and install as described above. For '''Base Station''', leave it as it is.

== Retrieving the data ==

Extract the TReadSerial.zip file. Here, you will find a C++ class called <code>CSerialCom</code> that can be used for retreiving the data.

 API: Opens the connection to a serial device
with i.e "/dev/USB0" (Linux)
 <code>int openDevice(const char* pDevice)</code>
 
Closes the connection to the serial device
 <code>void closeDevice(void)</code>
 
Settings for the serial device 
'''IN''': Only type available: <code>TYPE_TMOTE_SKY</code>
 <code>void setOptions(int type)</code>
 
Retreives the data from the serial port if any available. Max waiting 
time for the data retreival is 6s. Where after the return value will be 0. 
'''IN''': <code>pData</code>: where the data should be stored. allocated by the caller 
'''Return''': Nr of bytes allocated in the pData buffer.
 <code>int getData(char* & pData)</code>
 
Sends the to the serial device NOTE! Doesn't work!
 '''IN''': <code>pData</code>: buffer to transmitt
 <code>length</code>: number of bytes to send from the buffer
 <code>int sendData(uint8_t* pData, int length);</code>
 

== Interpretting the data ==

The data is retrived in so called raw format as following:

[[Image:SerialRawStream.png]] B = Byte(s)

'''7E''': The leading and trailing ''framing byte'' <code>0x7E</code> can be ignored. 

'''TYPE''': In this application, <code>0x42</code> Which means no acknowledge is required. 

'''NN''': Number of bytes of data that is sent in this packet

'''RESERVED''': TMote reservation

'''DEST'''. ADDR: Packet destination. In this application: <code>0xFF 0xFF</code>

'''MSG TYPE''': Not used in this application. Always: 0x01

'''GRP ID''': Group ID. Default set to 0x7D

'''DATA''': NN bytes of data sent. Explained further down

'''CRC''': Checksum (ignored)

 '''''DATA''''' 
The encapsulated data is in the following format:

[[Image:SerialData.png]]

LOCAL = Base Station
 REMOTE = Remote Station

'''NOTE!'''
 1. The raw stream is in '''Little Endian''' format
 2. The following escaped are used for maintaing the framing byte protocol
0x7E -> 0x7D 0x5E
0x/D -> 0x7D 0x5D

=== Example ===
The data will be retreived as following (HEX VALUES)

<code>7E 42 08 00 00 00 00 00 7D 5E 00 01 7D 5D XX XX XX XX XX XX XX XX RR (RR) 7E</code> 
After removing the framing bytes and the escape code sequences, the ACTUAL packet is: 
<code>42 08 00 00 00 00 00 7E 00 01 7D XX XX XX XX XX XX XX XX RR (RR)</code> 

TYPE is 42 (NO_ACK). Data length is 8 bytes in the data region.

== Additional ==
The temperature can be calculated with the following C# code. However, it's not tested:

<code>
Calculating Temperature in Engineering Units
/// <summary>
/// Calculates the temperature, in degrees Celsius of the:
///
/// Panasonic ERT-J1VR103J Thermistor
///
/// The formula in the MTS Series User Manual is:
/// 1/T(K) = a + b × ln(Rthr) + c × [ln(Rthr)]^3
///
/// where:
/// Rthr = R1(ADC_FS-ADC)/ADC
/// a = 0.00130705
/// b = 0.000214381
/// c = 0.000000093
/// R1 = 10 kOhm
/// ADC_FS = 1023
/// ADC = output value from mote’s ADC measurement.
///
/// Note that an adjusted temp (adjTemp) is used because the
/// actual temp reading is a 10 bit value that has been compressed
/// into a single byte. As such it must be shifted left 2 bit places.
///
/// The value for _temp is the raw sensor reading from the SurgeMsg.
///
/// </summary>
/// <returns>Temperature in Degrees Celsius as a float.</returns>
float CalculateTempC()
{
int adjTemp = _temp << 2;

// prevent divide by zero.
if(adjTemp == 0)
return 0F;

float temperature, a, b, c, Rthr;
a = 0.001307050F;
b = 0.000214381F;
c = 0.000000093F;
Rthr = 10000 * (1023 - adjTemp) / adjTemp;

temperature = 1 / (float)(a + b * Math.Log(Rthr) + c *
Math.Pow(Math.Log(Rthr),3));
temperature -= 273.15F; // Convert from Kelvin to Celcius

}
</code>

Temperature reading application

2007-04-15T15:10:28Z

Indy: /* Installation of the application */

This Nesc/TinyOS application is for measuring the temperature with maximum of two sensors. One acts like a '''Base Station''' and has to be connected with the USB connection to the computer. The second acts like a '''Remote Station''' and transmitts its temperature reading via the radio to the '''Base Station'''. At the final stage, the '''Base Station''' transmitts the complete data, both temperature readings, to the computer every second. Please note that the application described here can be used without any '''Remote Station'''.
In this document it is described how to install the Nesc/TinyOS application <code>TRead</code> and how to retreive and interpret the data.

It is assumed that the installation of TinyOS 1.x and Nesc is installed with the nessecary components.

== Installation of the application ==

Extract the TRead application in the folder <code>xxx/tinyos-1.x/apps/</code>. Then in the folder <code>xxx/tinyos-1.x/apps</code>, install the application by following line:

(For Tmote Sky connected to USB port 0) 
<code>make telosb && make telosb install.$2 bsl,/dev/ttyUSB0</code>

NOTE! 
In the file <code>TReadM.nc</code>, at the top, there is a preprocessor definition <code>#define BASE_STATION</code>.
When installing for the '''Remote station''', comment this line and install as described above. For '''Base Station''', leave it as it is.

== Retrieving the data ==

Extract the TReadSerial.zip file. Here, you will find a C++ class called <code>CSerialCom</code> that can be used for retreiving the data.

 API: Opens the connection to a serial device
with i.e "/dev/USB0" (Linux)
 <code>int openDevice(const char* pDevice)</code>
 
Closes the connection to the serial device
 <code>void closeDevice(void)</code>
 
Settings for the serial device 
'''IN''': Only type available: <code>TYPE_TMOTE_SKY</code>
 <code>void setOptions(int type)</code>
 
Retreives the data from the serial port if any available. Max waiting 
time for the data retreival is 6s. Where after the return value will be 0. 
'''IN''': <code>pData</code>: where the data should be stored. allocated by the caller 
'''Return''': Nr of bytes allocated in the pData buffer.
 <code>int getData(char* & pData)</code>
 
Sends the to the serial device NOTE! Doesn't work!
 '''IN''': <code>pData</code>: buffer to transmitt
 <code>length</code>: number of bytes to send from the buffer
 <code>int sendData(uint8_t* pData, int length);</code>
 

== Interpretting the data ==

The data is retrived in so called raw format as following:

[[Image:SerialRawStream.png]] B = Byte(s)

'''7E''': The leading and trailing ''framing byte'' <code>0x7E</code> can be ignored. 

'''TYPE''': In this application, <code>0x42</code> Which means no acknowledge is required. 

'''NN''': Number of bytes of data that is sent in this packet

'''RESERVED''': TMote reservation

'''DEST'''. ADDR: Packet destination. In this application: <code>0xFF 0xFF</code>

'''MSG TYPE''': Not used in this application. Always: 0x01

'''GRP ID''': Group ID. Default set to 0x7D

'''DATA''': NN bytes of data sent. Explained further down

'''CRC''': Checksum (ignored)

 '''''DATA''''' 
The encapsulated data is in the following format:

[[Image:SerialData.png]]

LOCAL = Base Station
 REMOTE = Remote Station

'''NOTE!'''
 1. The raw stream is in '''Little Endian''' format
 2. The following escaped are used for maintaing the framing byte protocol
0x7E -> 0x7D 0x5E
0x/D -> 0x7D 0x5D

=== Example ===
The data will be retreived as following (HEX VALUES)

<code>7E 42 08 00 00 00 00 00 7D 5E 00 01 7D 5D XX XX XX XX XX XX XX XX RR (RR) 7E</code> 
After removing the framing bytes and the escape code sequences, the ACTUAL packet is: 
<code>42 08 00 00 00 00 00 7E 00 01 7D XX XX XX XX XX XX XX XX RR (RR)</code> 

TYPE is 42 (NO_ACK). Data length is 8 bytes in the data region.

== Additional ==
The temperature can be calculated with the following C# code. However, it's not tested:

<code>
Calculating Temperature in Engineering Units
/// <summary>
/// Calculates the temperature, in degrees Celsius of the:
///
/// Panasonic ERT-J1VR103J Thermistor
///
/// The formula in the MTS Series User Manual is:
/// 1/T(K) = a + b × ln(Rthr) + c × [ln(Rthr)]^3
///
/// where:
/// Rthr = R1(ADC_FS-ADC)/ADC
/// a = 0.00130705
/// b = 0.000214381
/// c = 0.000000093
/// R1 = 10 kOhm
/// ADC_FS = 1023
/// ADC = output value from mote’s ADC measurement.
///
/// Note that an adjusted temp (adjTemp) is used because the
/// actual temp reading is a 10 bit value that has been compressed
/// into a single byte. As such it must be shifted left 2 bit places.
///
/// The value for _temp is the raw sensor reading from the SurgeMsg.
///
/// </summary>
/// <returns>Temperature in Degrees Celsius as a float.</returns>
float CalculateTempC()
{
int adjTemp = _temp << 2;

// prevent divide by zero.
if(adjTemp == 0)
return 0F;

float temperature, a, b, c, Rthr;
a = 0.001307050F;
b = 0.000214381F;
c = 0.000000093F;
Rthr = 10000 * (1023 - adjTemp) / adjTemp;

temperature = 1 / (float)(a + b * Math.Log(Rthr) + c *
Math.Pow(Math.Log(Rthr),3));
temperature -= 273.15F; // Convert from Kelvin to Celcius

}
</code>

Temperature reading application

2007-04-15T15:09:59Z

Indy: /* Installation of the application */

This Nesc/TinyOS application is for measuring the temperature with maximum of two sensors. One acts like a '''Base Station''' and has to be connected with the USB connection to the computer. The second acts like a '''Remote Station''' and transmitts its temperature reading via the radio to the '''Base Station'''. At the final stage, the '''Base Station''' transmitts the complete data, both temperature readings, to the computer every second. Please note that the application described here can be used without any '''Remote Station'''.
In this document it is described how to install the Nesc/TinyOS application <code>TRead</code> and how to retreive and interpret the data.

It is assumed that the installation of TinyOS 1.x and Nesc is installed with the nessecary components.

== Installation of the application ==

Extract the TRead application in the folder <code>xxx/tinyos-1.x/apps/</code>. Then in the folder <code>xxx/tinyos-1.x/apps</code>, install the application by following line:

(For connection to USB port 0) 
<code>make telosb && make telosb install.$2 bsl,/dev/ttyUSB0</code>

NOTE! 
In the file <code>TReadM.nc</code>, at the top, there is a preprocessor definition <code>#define BASE_STATION</code>.
When installing for the '''Remote station''', comment this line and install as described above. For '''Base Station''', leave it as it is.

== Retrieving the data ==

Extract the TReadSerial.zip file. Here, you will find a C++ class called <code>CSerialCom</code> that can be used for retreiving the data.

 API: Opens the connection to a serial device
with i.e "/dev/USB0" (Linux)
 <code>int openDevice(const char* pDevice)</code>
 
Closes the connection to the serial device
 <code>void closeDevice(void)</code>
 
Settings for the serial device 
'''IN''': Only type available: <code>TYPE_TMOTE_SKY</code>
 <code>void setOptions(int type)</code>
 
Retreives the data from the serial port if any available. Max waiting 
time for the data retreival is 6s. Where after the return value will be 0. 
'''IN''': <code>pData</code>: where the data should be stored. allocated by the caller 
'''Return''': Nr of bytes allocated in the pData buffer.
 <code>int getData(char* & pData)</code>
 
Sends the to the serial device NOTE! Doesn't work!
 '''IN''': <code>pData</code>: buffer to transmitt
 <code>length</code>: number of bytes to send from the buffer
 <code>int sendData(uint8_t* pData, int length);</code>
 

== Interpretting the data ==

The data is retrived in so called raw format as following:

[[Image:SerialRawStream.png]] B = Byte(s)

'''7E''': The leading and trailing ''framing byte'' <code>0x7E</code> can be ignored. 

'''TYPE''': In this application, <code>0x42</code> Which means no acknowledge is required. 

'''NN''': Number of bytes of data that is sent in this packet

'''RESERVED''': TMote reservation

'''DEST'''. ADDR: Packet destination. In this application: <code>0xFF 0xFF</code>

'''MSG TYPE''': Not used in this application. Always: 0x01

'''GRP ID''': Group ID. Default set to 0x7D

'''DATA''': NN bytes of data sent. Explained further down

'''CRC''': Checksum (ignored)

 '''''DATA''''' 
The encapsulated data is in the following format:

[[Image:SerialData.png]]

LOCAL = Base Station
 REMOTE = Remote Station

'''NOTE!'''
 1. The raw stream is in '''Little Endian''' format
 2. The following escaped are used for maintaing the framing byte protocol
0x7E -> 0x7D 0x5E
0x/D -> 0x7D 0x5D

=== Example ===
The data will be retreived as following (HEX VALUES)

<code>7E 42 08 00 00 00 00 00 7D 5E 00 01 7D 5D XX XX XX XX XX XX XX XX RR (RR) 7E</code> 
After removing the framing bytes and the escape code sequences, the ACTUAL packet is: 
<code>42 08 00 00 00 00 00 7E 00 01 7D XX XX XX XX XX XX XX XX RR (RR)</code> 

TYPE is 42 (NO_ACK). Data length is 8 bytes in the data region.

== Additional ==
The temperature can be calculated with the following C# code. However, it's not tested:

<code>
Calculating Temperature in Engineering Units
/// <summary>
/// Calculates the temperature, in degrees Celsius of the:
///
/// Panasonic ERT-J1VR103J Thermistor
///
/// The formula in the MTS Series User Manual is:
/// 1/T(K) = a + b × ln(Rthr) + c × [ln(Rthr)]^3
///
/// where:
/// Rthr = R1(ADC_FS-ADC)/ADC
/// a = 0.00130705
/// b = 0.000214381
/// c = 0.000000093
/// R1 = 10 kOhm
/// ADC_FS = 1023
/// ADC = output value from mote’s ADC measurement.
///
/// Note that an adjusted temp (adjTemp) is used because the
/// actual temp reading is a 10 bit value that has been compressed
/// into a single byte. As such it must be shifted left 2 bit places.
///
/// The value for _temp is the raw sensor reading from the SurgeMsg.
///
/// </summary>
/// <returns>Temperature in Degrees Celsius as a float.</returns>
float CalculateTempC()
{
int adjTemp = _temp << 2;

// prevent divide by zero.
if(adjTemp == 0)
return 0F;

float temperature, a, b, c, Rthr;
a = 0.001307050F;
b = 0.000214381F;
c = 0.000000093F;
Rthr = 10000 * (1023 - adjTemp) / adjTemp;

temperature = 1 / (float)(a + b * Math.Log(Rthr) + c *
Math.Pow(Math.Log(Rthr),3));
temperature -= 273.15F; // Convert from Kelvin to Celcius

}
</code>

Temperature reading application

2007-04-15T14:09:59Z

Indy: /* Retrieving the data */

This Nesc/TinyOS application is for measuring the temperature with maximum of two sensors. One acts like a '''Base Station''' and has to be connected with the USB connection to the computer. The second acts like a '''Remote Station''' and transmitts its temperature reading via the radio to the '''Base Station'''. At the final stage, the '''Base Station''' transmitts the complete data, both temperature readings, to the computer every second. Please note that the application described here can be used without any '''Remote Station'''.
In this document it is described how to install the Nesc/TinyOS application <code>TRead</code> and how to retreive and interpret the data.

It is assumed that the installation of TinyOS 1.x and Nesc is installed with the nessecary components.

== Installation of the application ==

Extract the TRead application in the folder <code>xxx/tinyos-1.x/apps/</code>. Then in the folder <code>xxx/tinyos-1.x/apps</code>, install the application by following line:

<code>make telosb && installXXXXXXXX</code>

NOTE! 
In the file <code>TReadM.nc</code>, at the top, there is a preprocessor definition <code>#define BASE_STATION</code>.
When installing for the '''Remote station''', comment this line and install as described above. For '''Base Station''', leave it as it is.

== Retrieving the data ==

Extract the TReadSerial.zip file. Here, you will find a C++ class called <code>CSerialCom</code> that can be used for retreiving the data.

 API: Opens the connection to a serial device
with i.e "/dev/USB0" (Linux)
 <code>int openDevice(const char* pDevice)</code>
 
Closes the connection to the serial device
 <code>void closeDevice(void)</code>
 
Settings for the serial device 
'''IN''': Only type available: <code>TYPE_TMOTE_SKY</code>
 <code>void setOptions(int type)</code>
 
Retreives the data from the serial port if any available. Max waiting 
time for the data retreival is 6s. Where after the return value will be 0. 
'''IN''': <code>pData</code>: where the data should be stored. allocated by the caller 
'''Return''': Nr of bytes allocated in the pData buffer.
 <code>int getData(char* & pData)</code>
 
Sends the to the serial device NOTE! Doesn't work!
 '''IN''': <code>pData</code>: buffer to transmitt
 <code>length</code>: number of bytes to send from the buffer
 <code>int sendData(uint8_t* pData, int length);</code>
 

== Interpretting the data ==

The data is retrived in so called raw format as following:

[[Image:SerialRawStream.png]] B = Byte(s)

'''7E''': The leading and trailing ''framing byte'' <code>0x7E</code> can be ignored. 

'''TYPE''': In this application, <code>0x42</code> Which means no acknowledge is required. 

'''NN''': Number of bytes of data that is sent in this packet

'''RESERVED''': TMote reservation

'''DEST'''. ADDR: Packet destination. In this application: <code>0xFF 0xFF</code>

'''MSG TYPE''': Not used in this application. Always: 0x01

'''GRP ID''': Group ID. Default set to 0x7D

'''DATA''': NN bytes of data sent. Explained further down

'''CRC''': Checksum (ignored)

 '''''DATA''''' 
The encapsulated data is in the following format:

[[Image:SerialData.png]]

LOCAL = Base Station
 REMOTE = Remote Station

'''NOTE!'''
 1. The raw stream is in '''Little Endian''' format
 2. The following escaped are used for maintaing the framing byte protocol
0x7E -> 0x7D 0x5E
0x/D -> 0x7D 0x5D

=== Example ===
The data will be retreived as following (HEX VALUES)

<code>7E 42 08 00 00 00 00 00 7D 5E 00 01 7D 5D XX XX XX XX XX XX XX XX RR (RR) 7E</code> 
After removing the framing bytes and the escape code sequences, the ACTUAL packet is: 
<code>42 08 00 00 00 00 00 7E 00 01 7D XX XX XX XX XX XX XX XX RR (RR)</code> 

TYPE is 42 (NO_ACK). Data length is 8 bytes in the data region.

== Additional ==
The temperature can be calculated with the following C# code. However, it's not tested:

<code>
Calculating Temperature in Engineering Units
/// <summary>
/// Calculates the temperature, in degrees Celsius of the:
///
/// Panasonic ERT-J1VR103J Thermistor
///
/// The formula in the MTS Series User Manual is:
/// 1/T(K) = a + b × ln(Rthr) + c × [ln(Rthr)]^3
///
/// where:
/// Rthr = R1(ADC_FS-ADC)/ADC
/// a = 0.00130705
/// b = 0.000214381
/// c = 0.000000093
/// R1 = 10 kOhm
/// ADC_FS = 1023
/// ADC = output value from mote’s ADC measurement.
///
/// Note that an adjusted temp (adjTemp) is used because the
/// actual temp reading is a 10 bit value that has been compressed
/// into a single byte. As such it must be shifted left 2 bit places.
///
/// The value for _temp is the raw sensor reading from the SurgeMsg.
///
/// </summary>
/// <returns>Temperature in Degrees Celsius as a float.</returns>
float CalculateTempC()
{
int adjTemp = _temp << 2;

// prevent divide by zero.
if(adjTemp == 0)
return 0F;

float temperature, a, b, c, Rthr;
a = 0.001307050F;
b = 0.000214381F;
c = 0.000000093F;
Rthr = 10000 * (1023 - adjTemp) / adjTemp;

temperature = 1 / (float)(a + b * Math.Log(Rthr) + c *
Math.Pow(Math.Log(Rthr),3));
temperature -= 273.15F; // Convert from Kelvin to Celcius

}
</code>

Temperature reading application

2007-04-15T14:09:38Z

Indy: /* Retrieving the data */

This Nesc/TinyOS application is for measuring the temperature with maximum of two sensors. One acts like a '''Base Station''' and has to be connected with the USB connection to the computer. The second acts like a '''Remote Station''' and transmitts its temperature reading via the radio to the '''Base Station'''. At the final stage, the '''Base Station''' transmitts the complete data, both temperature readings, to the computer every second. Please note that the application described here can be used without any '''Remote Station'''.
In this document it is described how to install the Nesc/TinyOS application <code>TRead</code> and how to retreive and interpret the data.

It is assumed that the installation of TinyOS 1.x and Nesc is installed with the nessecary components.

== Installation of the application ==

Extract the TRead application in the folder <code>xxx/tinyos-1.x/apps/</code>. Then in the folder <code>xxx/tinyos-1.x/apps</code>, install the application by following line:

<code>make telosb && installXXXXXXXX</code>

NOTE! 
In the file <code>TReadM.nc</code>, at the top, there is a preprocessor definition <code>#define BASE_STATION</code>.
When installing for the '''Remote station''', comment this line and install as described above. For '''Base Station''', leave it as it is.

== Retrieving the data ==

API:

Extract the TReadSerial.zip file. Here, you will find a C++ class called <code>CSerialCom</code> that can be used for retreiving the data.
 Opens the connection to a serial device
with i.e "/dev/USB0" (Linux)
 <code>int openDevice(const char* pDevice)</code>
 
Closes the connection to the serial device
 <code>void closeDevice(void)</code>
 
Settings for the serial device 
'''IN''': Only type available: <code>TYPE_TMOTE_SKY</code>
 <code>void setOptions(int type)</code>
 
Retreives the data from the serial port if any available. Max waiting 
time for the data retreival is 6s. Where after the return value will be 0. 
'''IN''': <code>pData</code>: where the data should be stored. allocated by the caller 
'''Return''': Nr of bytes allocated in the pData buffer.
 <code>int getData(char* & pData)</code>
 
Sends the to the serial device NOTE! Doesn't work!
 '''IN''': <code>pData</code>: buffer to transmitt
 <code>length</code>: number of bytes to send from the buffer
 <code>int sendData(uint8_t* pData, int length);</code>
 

== Interpretting the data ==

The data is retrived in so called raw format as following:

[[Image:SerialRawStream.png]] B = Byte(s)

'''7E''': The leading and trailing ''framing byte'' <code>0x7E</code> can be ignored. 

'''TYPE''': In this application, <code>0x42</code> Which means no acknowledge is required. 

'''NN''': Number of bytes of data that is sent in this packet

'''RESERVED''': TMote reservation

'''DEST'''. ADDR: Packet destination. In this application: <code>0xFF 0xFF</code>

'''MSG TYPE''': Not used in this application. Always: 0x01

'''GRP ID''': Group ID. Default set to 0x7D

'''DATA''': NN bytes of data sent. Explained further down

'''CRC''': Checksum (ignored)

 '''''DATA''''' 
The encapsulated data is in the following format:

[[Image:SerialData.png]]

LOCAL = Base Station
 REMOTE = Remote Station

'''NOTE!'''
 1. The raw stream is in '''Little Endian''' format
 2. The following escaped are used for maintaing the framing byte protocol
0x7E -> 0x7D 0x5E
0x/D -> 0x7D 0x5D

=== Example ===
The data will be retreived as following (HEX VALUES)

<code>7E 42 08 00 00 00 00 00 7D 5E 00 01 7D 5D XX XX XX XX XX XX XX XX RR (RR) 7E</code> 
After removing the framing bytes and the escape code sequences, the ACTUAL packet is: 
<code>42 08 00 00 00 00 00 7E 00 01 7D XX XX XX XX XX XX XX XX RR (RR)</code> 

TYPE is 42 (NO_ACK). Data length is 8 bytes in the data region.

== Additional ==
The temperature can be calculated with the following C# code. However, it's not tested:

<code>
Calculating Temperature in Engineering Units
/// <summary>
/// Calculates the temperature, in degrees Celsius of the:
///
/// Panasonic ERT-J1VR103J Thermistor
///
/// The formula in the MTS Series User Manual is:
/// 1/T(K) = a + b × ln(Rthr) + c × [ln(Rthr)]^3
///
/// where:
/// Rthr = R1(ADC_FS-ADC)/ADC
/// a = 0.00130705
/// b = 0.000214381
/// c = 0.000000093
/// R1 = 10 kOhm
/// ADC_FS = 1023
/// ADC = output value from mote’s ADC measurement.
///
/// Note that an adjusted temp (adjTemp) is used because the
/// actual temp reading is a 10 bit value that has been compressed
/// into a single byte. As such it must be shifted left 2 bit places.
///
/// The value for _temp is the raw sensor reading from the SurgeMsg.
///
/// </summary>
/// <returns>Temperature in Degrees Celsius as a float.</returns>
float CalculateTempC()
{
int adjTemp = _temp << 2;

// prevent divide by zero.
if(adjTemp == 0)
return 0F;

float temperature, a, b, c, Rthr;
a = 0.001307050F;
b = 0.000214381F;
c = 0.000000093F;
Rthr = 10000 * (1023 - adjTemp) / adjTemp;

temperature = 1 / (float)(a + b * Math.Log(Rthr) + c *
Math.Pow(Math.Log(Rthr),3));
temperature -= 273.15F; // Convert from Kelvin to Celcius

}
</code>

Temperature reading application

2007-04-15T14:08:50Z

Indy:

This Nesc/TinyOS application is for measuring the temperature with maximum of two sensors. One acts like a '''Base Station''' and has to be connected with the USB connection to the computer. The second acts like a '''Remote Station''' and transmitts its temperature reading via the radio to the '''Base Station'''. At the final stage, the '''Base Station''' transmitts the complete data, both temperature readings, to the computer every second. Please note that the application described here can be used without any '''Remote Station'''.
In this document it is described how to install the Nesc/TinyOS application <code>TRead</code> and how to retreive and interpret the data.

It is assumed that the installation of TinyOS 1.x and Nesc is installed with the nessecary components.

== Installation of the application ==

Extract the TRead application in the folder <code>xxx/tinyos-1.x/apps/</code>. Then in the folder <code>xxx/tinyos-1.x/apps</code>, install the application by following line:

<code>make telosb && installXXXXXXXX</code>

NOTE! 
In the file <code>TReadM.nc</code>, at the top, there is a preprocessor definition <code>#define BASE_STATION</code>.
When installing for the '''Remote station''', comment this line and install as described above. For '''Base Station''', leave it as it is.

== Retrieving the data ==

Extract the TReadSerial.zip file. Here, you will find a C++ class called <code>CSerialCom</code> that can be used for retreiving the data.
 Opens the connection to a serial device
with i.e "/dev/USB0" (Linux)
 <code>int openDevice(const char* pDevice)</code>
 
Closes the connection to the serial device
 <code>void closeDevice(void)</code>
 
Settings for the serial device 
'''IN''': Only type available: <code>TYPE_TMOTE_SKY</code>
 <code>void setOptions(int type)</code>
 
Retreives the data from the serial port if any available. Max waiting 
time for the data retreival is 6s. Where after the return value will be 0. 
'''IN''': <code>pData</code>: where the data should be stored. allocated by the caller 
'''Return''': Nr of bytes allocated in the pData buffer.
 <code>int getData(char* & pData)</code>
 
Sends the to the serial device NOTE! Doesn't work!
 '''IN''': <code>pData</code>: buffer to transmitt
 <code>length</code>: number of bytes to send from the buffer
 <code>int sendData(uint8_t* pData, int length);</code>
 

== Interpretting the data ==

The data is retrived in so called raw format as following:

[[Image:SerialRawStream.png]] B = Byte(s)

'''7E''': The leading and trailing ''framing byte'' <code>0x7E</code> can be ignored. 

'''TYPE''': In this application, <code>0x42</code> Which means no acknowledge is required. 

'''NN''': Number of bytes of data that is sent in this packet

'''RESERVED''': TMote reservation

'''DEST'''. ADDR: Packet destination. In this application: <code>0xFF 0xFF</code>

'''MSG TYPE''': Not used in this application. Always: 0x01

'''GRP ID''': Group ID. Default set to 0x7D

'''DATA''': NN bytes of data sent. Explained further down

'''CRC''': Checksum (ignored)

 '''''DATA''''' 
The encapsulated data is in the following format:

[[Image:SerialData.png]]

LOCAL = Base Station
 REMOTE = Remote Station

'''NOTE!'''
 1. The raw stream is in '''Little Endian''' format
 2. The following escaped are used for maintaing the framing byte protocol
0x7E -> 0x7D 0x5E
0x/D -> 0x7D 0x5D

=== Example ===
The data will be retreived as following (HEX VALUES)

<code>7E 42 08 00 00 00 00 00 7D 5E 00 01 7D 5D XX XX XX XX XX XX XX XX RR (RR) 7E</code> 
After removing the framing bytes and the escape code sequences, the ACTUAL packet is: 
<code>42 08 00 00 00 00 00 7E 00 01 7D XX XX XX XX XX XX XX XX RR (RR)</code> 

TYPE is 42 (NO_ACK). Data length is 8 bytes in the data region.

== Additional ==
The temperature can be calculated with the following C# code. However, it's not tested:

<code>
Calculating Temperature in Engineering Units
/// <summary>
/// Calculates the temperature, in degrees Celsius of the:
///
/// Panasonic ERT-J1VR103J Thermistor
///
/// The formula in the MTS Series User Manual is:
/// 1/T(K) = a + b × ln(Rthr) + c × [ln(Rthr)]^3
///
/// where:
/// Rthr = R1(ADC_FS-ADC)/ADC
/// a = 0.00130705
/// b = 0.000214381
/// c = 0.000000093
/// R1 = 10 kOhm
/// ADC_FS = 1023
/// ADC = output value from mote’s ADC measurement.
///
/// Note that an adjusted temp (adjTemp) is used because the
/// actual temp reading is a 10 bit value that has been compressed
/// into a single byte. As such it must be shifted left 2 bit places.
///
/// The value for _temp is the raw sensor reading from the SurgeMsg.
///
/// </summary>
/// <returns>Temperature in Degrees Celsius as a float.</returns>
float CalculateTempC()
{
int adjTemp = _temp << 2;

// prevent divide by zero.
if(adjTemp == 0)
return 0F;

float temperature, a, b, c, Rthr;
a = 0.001307050F;
b = 0.000214381F;
c = 0.000000093F;
Rthr = 10000 * (1023 - adjTemp) / adjTemp;

temperature = 1 / (float)(a + b * Math.Log(Rthr) + c *
Math.Pow(Math.Log(Rthr),3));
temperature -= 273.15F; // Convert from Kelvin to Celcius

}
</code>

Temperature reading application

2007-04-15T14:01:59Z

Indy: /* EXAMPLE */

This Nesc/TinyOS application is for measuring the temperature with maximum of two sensors. One acts like a '''Base Station''' and has to be connected with the USB connection to the computer. The second acts like a '''Remote Station''' and transmitts its temperature reading via the radio to the '''Base Station'''. At the final stage, the base station transmitts the complete data, both temperature readings, to the computer every second.
In this document it is described how to install the Nesc/TinyOS, how to retreive the the data and how to interpret the data.

It is assumed that the installation of TinyOS 1.x and Nesc is installed with the nessecary components.

== Installation of the application ==

Extract the TRead application in the folder <code>/tinyos-1.x/apps/</code>. Then in the folder xxx/tinyos-1.x/apps, install the application by following line:

<code>make telosb && installXXXXXXXX</code>

NOTE! 
In the file <code>TReadM.nc</code>, at the top, there is a preprocessor definition <code>#define BASE_STATION</code>.
When installing for the '''Remote station''', comment this line and install as described above. For '''Base Station''', leave it as it is.

== Retrieving the data ==

Extract the TReadSerial.zip file. Here, you will find a C++ class called <code>CSerialCom</code> that can be used for retreiving the data.
 Opens the connection to a serial device
with i.e "/dev/USB0" (Linux)
 <code>int openDevice(const char* pDevice)</code>
 
Closes the connection to the serial device
 <code>void closeDevice(void)</code>
 
Settings for the serial device 
'''IN''': Only type available: <code>TYPE_TMOTE_SKY</code>
 <code>void setOptions(int type)</code>
 
Retreives the data from the serial port if any available. Max waiting 
time for the data retreival is 6s. Where after the return value will be 0. 
'''IN''': <code>pData</code>: where the data should be stored. allocated by the caller 
'''Return''': Nr of bytes allocated in the pData buffer.
 <code>int getData(char* & pData)</code>
 
Sends the to the serial device NOTE! Doesn't work!
 '''IN''': <code>pData</code>: buffer to transmitt
 <code>length</code>: number of bytes to send from the buffer
 <code>int sendData(uint8_t* pData, int length);</code>
 

== Interpretting the data ==

The data is retrived in so called raw format as following:

[[Image:SerialRawStream.png]] B = Byte(s)

'''7E''': The leading and trailing ''framing byte'' <code>0x7E</code> can be ignored. 

'''TYPE''': In this application, <code>0x42</code> Which means no acknowledge is required. 

'''NN''': Number of bytes of data that is sent in this packet

'''RESERVED''': TMote reservation

'''DEST'''. ADDR: Packet destination. In this application: <code>0xFF 0xFF</code>

'''MSG TYPE''': Not used in this application. Always: 0x01

'''GRP ID''': Group ID. Default set to 0x7D

'''DATA''': NN bytes of data sent. Explained further down

'''CRC''': Checksum (ignored)

 '''''DATA''''' 
The encapsulated data is in the following format:

[[Image:SerialData.png]]

LOCAL = Base Station
 REMOTE = Remote Station

'''NOTE!'''
 1. The raw stream is in '''Little Endian''' format
 2. The following escaped are used for maintaing the framing byte protocol
0x7E -> 0x7D 0x5E
0x/D -> 0x7D 0x5D

=== Example ===
The data will be retreived as following (HEX VALUES)

<code>7E 42 08 00 00 00 00 00 7D 5E 00 01 7D 5D XX XX XX XX XX XX XX XX RR (RR) 7E</code> 
After removing the framing bytes and the escape code sequences, the ACTUAL packet is: 
<code>42 08 00 00 00 00 00 7E 00 01 7D XX XX XX XX XX XX XX XX RR (RR)</code> 

TYPE is 42 (NO_ACK). Data length is 8 bytes in the data region.

== Additional ==
The temperature can be calculated with the following C# code. However, it's not tested:

<code>
Calculating Temperature in Engineering Units
/// <summary>
/// Calculates the temperature, in degrees Celsius of the:
///
/// Panasonic ERT-J1VR103J Thermistor
///
/// The formula in the MTS Series User Manual is:
/// 1/T(K) = a + b × ln(Rthr) + c × [ln(Rthr)]^3
///
/// where:
/// Rthr = R1(ADC_FS-ADC)/ADC
/// a = 0.00130705
/// b = 0.000214381
/// c = 0.000000093
/// R1 = 10 kOhm
/// ADC_FS = 1023
/// ADC = output value from mote’s ADC measurement.
///
/// Note that an adjusted temp (adjTemp) is used because the
/// actual temp reading is a 10 bit value that has been compressed
/// into a single byte. As such it must be shifted left 2 bit places.
///
/// The value for _temp is the raw sensor reading from the SurgeMsg.
///
/// </summary>
/// <returns>Temperature in Degrees Celsius as a float.</returns>
float CalculateTempC()
{
int adjTemp = _temp << 2;

// prevent divide by zero.
if(adjTemp == 0)
return 0F;

float temperature, a, b, c, Rthr;
a = 0.001307050F;
b = 0.000214381F;
c = 0.000000093F;
Rthr = 10000 * (1023 - adjTemp) / adjTemp;

temperature = 1 / (float)(a + b * Math.Log(Rthr) + c *
Math.Pow(Math.Log(Rthr),3));
temperature -= 273.15F; // Convert from Kelvin to Celcius

}
</code>

Temperature reading application

2007-04-15T14:01:40Z

Indy: /* EXAMPLE */

This Nesc/TinyOS application is for measuring the temperature with maximum of two sensors. One acts like a '''Base Station''' and has to be connected with the USB connection to the computer. The second acts like a '''Remote Station''' and transmitts its temperature reading via the radio to the '''Base Station'''. At the final stage, the base station transmitts the complete data, both temperature readings, to the computer every second.
In this document it is described how to install the Nesc/TinyOS, how to retreive the the data and how to interpret the data.

It is assumed that the installation of TinyOS 1.x and Nesc is installed with the nessecary components.

== Installation of the application ==

Extract the TRead application in the folder <code>/tinyos-1.x/apps/</code>. Then in the folder xxx/tinyos-1.x/apps, install the application by following line:

<code>make telosb && installXXXXXXXX</code>

NOTE! 
In the file <code>TReadM.nc</code>, at the top, there is a preprocessor definition <code>#define BASE_STATION</code>.
When installing for the '''Remote station''', comment this line and install as described above. For '''Base Station''', leave it as it is.

== Retrieving the data ==

Extract the TReadSerial.zip file. Here, you will find a C++ class called <code>CSerialCom</code> that can be used for retreiving the data.
 Opens the connection to a serial device
with i.e "/dev/USB0" (Linux)
 <code>int openDevice(const char* pDevice)</code>
 
Closes the connection to the serial device
 <code>void closeDevice(void)</code>
 
Settings for the serial device 
'''IN''': Only type available: <code>TYPE_TMOTE_SKY</code>
 <code>void setOptions(int type)</code>
 
Retreives the data from the serial port if any available. Max waiting 
time for the data retreival is 6s. Where after the return value will be 0. 
'''IN''': <code>pData</code>: where the data should be stored. allocated by the caller 
'''Return''': Nr of bytes allocated in the pData buffer.
 <code>int getData(char* & pData)</code>
 
Sends the to the serial device NOTE! Doesn't work!
 '''IN''': <code>pData</code>: buffer to transmitt
 <code>length</code>: number of bytes to send from the buffer
 <code>int sendData(uint8_t* pData, int length);</code>
 

== Interpretting the data ==

The data is retrived in so called raw format as following:

[[Image:SerialRawStream.png]] B = Byte(s)

'''7E''': The leading and trailing ''framing byte'' <code>0x7E</code> can be ignored. 

'''TYPE''': In this application, <code>0x42</code> Which means no acknowledge is required. 

'''NN''': Number of bytes of data that is sent in this packet

'''RESERVED''': TMote reservation

'''DEST'''. ADDR: Packet destination. In this application: <code>0xFF 0xFF</code>

'''MSG TYPE''': Not used in this application. Always: 0x01

'''GRP ID''': Group ID. Default set to 0x7D

'''DATA''': NN bytes of data sent. Explained further down

'''CRC''': Checksum (ignored)

 '''''DATA''''' 
The encapsulated data is in the following format:

[[Image:SerialData.png]]

LOCAL = Base Station
 REMOTE = Remote Station

'''NOTE!'''
 1. The raw stream is in '''Little Endian''' format
 2. The following escaped are used for maintaing the framing byte protocol
0x7E -> 0x7D 0x5E
0x/D -> 0x7D 0x5D

=== EXAMPLE ===
The data will be retreived as following (HEX VALUES)

<code>7E 42 08 00 00 00 00 00 7D 5E 00 01 7D 5D XX XX XX XX XX XX XX XX RR (RR) 7E</code> 
After removing the framing bytes and the escape code sequences, the ACTUAL packet is: 
<code>42 08 00 00 00 00 00 7E 00 01 7D XX XX XX XX XX XX XX XX RR (RR)</code> 

TYPE is 42 (NO_ACK). Data length is 8 bytes in the data region.

== Additional ==
The temperature can be calculated with the following C# code. However, it's not tested:

<code>
Calculating Temperature in Engineering Units
/// <summary>
/// Calculates the temperature, in degrees Celsius of the:
///
/// Panasonic ERT-J1VR103J Thermistor
///
/// The formula in the MTS Series User Manual is:
/// 1/T(K) = a + b × ln(Rthr) + c × [ln(Rthr)]^3
///
/// where:
/// Rthr = R1(ADC_FS-ADC)/ADC
/// a = 0.00130705
/// b = 0.000214381
/// c = 0.000000093
/// R1 = 10 kOhm
/// ADC_FS = 1023
/// ADC = output value from mote’s ADC measurement.
///
/// Note that an adjusted temp (adjTemp) is used because the
/// actual temp reading is a 10 bit value that has been compressed
/// into a single byte. As such it must be shifted left 2 bit places.
///
/// The value for _temp is the raw sensor reading from the SurgeMsg.
///
/// </summary>
/// <returns>Temperature in Degrees Celsius as a float.</returns>
float CalculateTempC()
{
int adjTemp = _temp << 2;

// prevent divide by zero.
if(adjTemp == 0)
return 0F;

float temperature, a, b, c, Rthr;
a = 0.001307050F;
b = 0.000214381F;
c = 0.000000093F;
Rthr = 10000 * (1023 - adjTemp) / adjTemp;

temperature = 1 / (float)(a + b * Math.Log(Rthr) + c *
Math.Pow(Math.Log(Rthr),3));
temperature -= 273.15F; // Convert from Kelvin to Celcius

}
</code>

Temperature reading application

2007-04-15T13:56:34Z

Indy: /* Interpretting the data */

Temperature reading application

2007-04-15T13:49:46Z

Indy: /* Interpretting the data */

Temperature reading application

2007-04-15T13:48:46Z

Indy: /* Interpretting the data */

Temperature reading application

2007-04-15T13:44:55Z

Indy: /* DATA */

Temperature reading application

2007-04-15T13:42:20Z

Indy: /* DATA */

Temperature reading application

2007-04-15T13:41:39Z

Indy: /* Interpretting the data */

Temperature reading application

2007-04-15T13:38:23Z

Indy: /* Interpretting the data */

Temperature reading application

2007-04-15T13:31:31Z

Indy: /* Interpretting the data */

File:SerialData.png

2007-04-15T13:29:25Z

Indy: Encapsulated data within the raw data retreived from the application TRead

Encapsulated data within the raw data retreived from the application TRead

File:SerialRawStream.png

2007-04-15T13:28:09Z

Indy: Raw serial data that is retrevied by the TRead application

Raw serial data that is retrevied by the TRead application

Temperature reading application

2007-04-15T13:22:47Z

Indy: /* Retrieving the data */

Temperature reading application

2007-04-15T13:22:10Z

Indy: /* Retrieving the data */

Temperature reading application

2007-04-15T13:19:51Z

Indy: /* Retrieving the data */

Temperature reading application

2007-04-15T13:19:12Z

Indy: /* Retrieving the data */

Temperature reading application

2007-04-15T13:17:16Z

Indy: /* Retrieving the data */

Temperature reading application

2007-04-15T13:16:26Z

Indy: /* Retrieving the data */

Temperature reading application

2007-04-15T13:15:21Z

Indy: /* Retrieving the data */

Temperature reading application

2007-04-15T13:14:57Z

Indy: /* Retrieving the data */