HoHCI-BikeSteering/External/antplus_simulator_src/devices/antplus_bikepower.h

/*
This software is subject to the license described in the License.txt file 
included with this software distribution. You may not use this file except in compliance 
with this license.

Copyright (c) Dynastream Innovations Inc. 2012
All rights reserved.
*/


#pragma once

#define BP_REV				2.0					// Device Profile Revision Number

public ref class BikePower
{

public:
	// Channel Parameters
	static const UCHAR DEVICE_TYPE = 11;
	static const UCHAR TX_TYPE = 5;
	static const USHORT MSG_PERIOD = 8182;	// ~4.049 Hz
	
	// Data Pages
	static const UCHAR PAGE_CALIBRATION = 0x01;
	static const UCHAR PAGE_GET_SET_PARAMETERS = 0x02;
	static const UCHAR PAGE_POWER = 0x10;
	static const UCHAR PAGE_WHEEL_TORQUE = 0x11;
	static const UCHAR PAGE_CRANK_TORQUE = 0x12;
   static const UCHAR PAGE_TEPS = 0x13;
	static const UCHAR PAGE_CTF = 0x20;

	// Subpages
	static const UCHAR SUBPAGE_CRANK_PARAMETERS = 0x01;

	// Calibration Messages
	static const UCHAR CAL_REQUEST = 0xAA;
	static const UCHAR CAL_AUTOZERO_CONFIG = 0xAB;
	static const UCHAR CAL_SUCCESS = 0xAC;
	static const UCHAR CAL_FAIL = 0xAF;
	static const UCHAR CAL_CTF = 0x10;
	static const UCHAR CAL_TORQUE_METER_CAPABILITIES = 0x12;
	static const UCHAR CAL_RAW_TORQUE = 0x13;
	static const UCHAR CTF_OFFSET = 0x01;
	static const UCHAR CTF_SLOPE = 0x02;
	static const UCHAR CTF_SERIAL = 0x03;
	static const UCHAR CTF_ACK = 0xAC;

	// Reserved/invalid values
	static const UCHAR RESERVED = 0xFF;
	static const UCHAR RESERVED_DESCR = 0x00;
	static const SHORT INVALID_TORQUE = -0x7FFF;  // Signed 0xFFFF
	static const UCHAR INVALID_CADENCE = 0xFF;
	static const UCHAR INVALID_CRANK_LENGTH = 0xFF;
   static const UCHAR INVALID_TEPS = 0xFF;
   static const UCHAR COMBINED_PEDAL_SMOOTHNESS = 0xFE;
	static const UCHAR AUTO_CRANK = 0xFE;
	static const UCHAR READ_ONLY = 0x00;
	static const USHORT MIN_SLOPE = 100;
	static const USHORT MAX_SLOPE = 500;
	static const USHORT MIN_OFFSET = 0;
	static const USHORT MAX_OFFSET = 65535;
	static const SHORT MAX_CALDATA = 32767;
	static const SHORT MIN_CALDATA = -32768;
	static const UCHAR MAX_NOEVENT = 12;

	// Interleaving requirements
	static const UCHAR INTERVAL_COMMON_AND_AZ = 121;	// Pages 80, 81 & Auto Zero Support interleaved every 121 messages (~30.25s)
	static const UCHAR INTERVAL_BATTERY = 61;			// Page 82 interleaved every 61 messages (~15.25s)
	static const UCHAR INTERVAL_MIN_POWER = 9;			// Minimum: Interleave basic power every 9th message
	static const UCHAR INTERVAL_POWER = 5;				// Preferred: Interleave basic power every 5th message
   static const UCHAR INTERVAL_TEPS = 5;           // Preferred: Interleave once every 5 messages
	static const UCHAR INTERVAL_MAX_POWER = 2;			// Maximum: Interleave basic power every other page
	static const UCHAR MAX_RETRY_CTF = 40;				// CTF Offset message must be sent for 10 seconds (40 messages at 4Hz)


	enum class AutoZeroStatus : UCHAR
	{
		OFF = 0x00,
		ON = 0x01,
		UNSUPPORTED = 0xFF
	};

	enum class SensorType : UCHAR
	{
		UNKNOWN,
		POWER_ONLY,
		TORQUE_WHEEL,
		TORQUE_CRANK,
		CRANK_TORQUE_FREQ
	};

	enum class UpdateType : UCHAR
	{
		EVENT_SYNCH,
		TIME_SYNCH
	};

	enum class CrankLengthStatus : UCHAR
	{
		LENGTH_INVALID = 0x00,
		DEFAULT_LENGTH_USED = 0x01,
		LENGTH_MANUALLY_SET = 0x02,
		LENGTH_AUTOMATICALLY_SET = 0x03,
	};
	enum class SWMistmatchStatus : UCHAR
	{
		UNDEFINED = 0x00,
		RIGHT_SENSOR_OLDER = 0x01,
		LEFT_SENSOR_OLDER = 0x02,
		SW_SAME = 0x03,
	};
	enum class SensorStatus : UCHAR
	{
		UNDEFINED = 0x00,
		LEFT_PRESENT = 0x01,
		RIGHT_PRESENT = 0x02,
		LEFT_RIGHT_PRESENT = 0x03,
	};
	// Error handling
	// Flags indicate errors causing the exception
	ref class Error : public System::Exception{
	public:
		BOOL	bBadReserved;		// Invalid values on reserved fields
		BOOL	bUndefPage;			// Undefined page
		BOOL	bUndefCalID;		// Undefined calibration message ID
		BOOL	bUndefCTFID;		// Undefined CTF calibration message ID
		BOOL	bUndefCTFAck;		// Undefined CTF Acked message
		BOOL	bUndefAutoZero;		// Undefined auto zero status

		enum class Code : UCHAR		// Error code definitions
		{
			INVALID_RESERVED,		// Invalid value in reserved field
			UNDEF_PAGE,				// Undefined data page
			UNDEF_CAL_ID,			// Undefined calibration message ID
			UNDEF_CTF_ID,			// Undefined CTF calibration message ID
			UNDEF_CTF_ACKED,		// Undefined CTF acked message
			UNDEF_AUTOZERO,			// Invalid auto zero status
		};

		Error()
		{
			ClearFlags();
		}

		Error(Code eCode1_)
		{
			ClearFlags();
			SetFlags(eCode1_);		
		}

		Error(Code eCode1_, Code eCode2_)
		{		
			ClearFlags();
			SetFlags(eCode1_);	
			SetFlags(eCode2_);
		}


	private:
		void ClearFlags()
		{
			bBadReserved = FALSE;
			bUndefPage = FALSE;
			bUndefCalID	= FALSE;
			bUndefCTFID = FALSE;
			bUndefCTFAck = FALSE;
			bUndefAutoZero = FALSE;
		}

		void SetFlags(Code eCode_)
		{
			switch(eCode_)
			{
			case Code::INVALID_RESERVED:
				bBadReserved = TRUE;
				break;
			case Code::UNDEF_PAGE:
				bUndefPage = TRUE;
				break;
			case Code::UNDEF_CAL_ID:
				bUndefCalID = TRUE;
				break;
			case Code::UNDEF_CTF_ID:
				bUndefCTFID = TRUE;
				break;
			case Code::UNDEF_CTF_ACKED:
				bUndefCTFAck = TRUE;
				break;
			case Code::UNDEF_AUTOZERO:
				bUndefAutoZero = TRUE;
				break;
			default:
				break;

			}
		}
	};


public:
	SensorType eType;			// Type of sensor

	// Get/Set Crank Parameters Data Page
	UCHAR ucSubpageNumber;
	UCHAR ucCrankLength;
	UCHAR ucSensorStatus;
	UCHAR ucSensorCapabilities;

	// Standard Power-Only Main Data Page
	UCHAR ucPowEventCount;		// Power event count
	UCHAR ucCadence;			// Instantaneous crank cadence (rpm)
	UCHAR ucPedalPower;			// Pedal power (%)
	USHORT usAcumPower;			// Cumulative power (W)
	USHORT usPower;				// Instantaneous power (W)

	// Standard Wheel Torque Main Data Page
	UCHAR ucWTEventCount;		// Wheel torque event count
	UCHAR ucWheelTicks;			// Wheel revolutions
	USHORT usAcumWheelPeriod2048; // Cumulative wheel period (1/2048 s)
	USHORT usAcumTorque32;		// Cumulative torque (1/32 Nm)

	// Standard Crank Torque Main Data Page
	UCHAR ucCTEventCount;		// Crank torque event count
	UCHAR ucCrankTicks;			// Crank revolutions
	USHORT usAcumCrankPeriod2048;	// Cumulative crank period (1/2048 s)
	
	// Crank Torque Frequency Main Data Page
	UCHAR ucCTFEventCount;		// Rotation event count (pedal revolutions)
	USHORT usSlope10;			// Variation of output frequency (1/10 Hz/Nm)
	USHORT usTime2000;			// Time of most recent rotation event (1/2000 s)
	USHORT usTorqueTicks;		// Count of most recent torque event

   // Torque Effectiveness and Pedal Smoothness Main Data Page
   UCHAR ucLeftTorqueEffectiveness; // Left torque effectiveness (0.5%)
   UCHAR ucRightTorqueEffectiveness; // Right torque effectiveness (0.5%)
   UCHAR ucLeftPedalSmoothness;     // Left pedal smoothness (0.5%)
   UCHAR ucRightPedalSmoothness;    // Right pedal smoothness (0.5%)

	// General Calibration Response Main Data Page
	SHORT sCalibrationData;		// Calibration data (signed, no units)

	// Auto Zero Configuration Main Data Page
	// Torque Sensor Capabilities Main Data Page
	BOOL bAutoZeroEnable;		// Sensor description
	BOOL bAutoZeroOn;			// Auto zero status 
	SHORT sRawTorque;			// Raw torque counts (signed, no units)
	SHORT sOffsetTorque;		// Offset torque (signed, no units)

	// Torque-Frequency Defined Calibration Main Data Pages
	USHORT usCalOffset;			// Offset (100-1000)
	USHORT usCalSlope;			// Slope (100-500)
	USHORT usCalSerialNum;		// Serial number
	UCHAR ucAckedCTFMsg;		// CTF message acknowledged

	// General Calibration
	UCHAR ucRxCalibrationID;	// Calibration Message ID received
	UCHAR ucRxCTFMsgID;			// CTF Calibration Message ID received

	// Error handling
	BOOL bValidation;			// Turns validation on/off

private:
	UCHAR ucPowMsgCount;		// Power message count (to determine sensor type)
	UCHAR ucTorqueMsgCount;		// Torque message count (to determine sensor type)
	UCHAR ucPrevTorqueMsgCount;	// Previous torque message count
	static const UCHAR NUM_MSGS = 4;	// Maximum number of messages before deciding type of sensor


public:
	BikePower()
	{
		bValidation = FALSE;
		eType = SensorType::UNKNOWN;
		ucPowMsgCount = 0;
		ucTorqueMsgCount = 0;
		ucPrevTorqueMsgCount = 0;

		// Set cumulative values to 0
		usAcumTorque32 = 0;
		usAcumWheelPeriod2048 = 0;
		usAcumCrankPeriod2048 = 0;
		usAcumPower = 0;

		// Set event counters to 0
		ucPowEventCount = 0;
		ucWTEventCount = 0;
		ucWheelTicks = 0;
		ucCTEventCount = 0;
		ucCrankTicks = 0;
		ucCTFEventCount = 0;
		usTorqueTicks = 0;
	}

	~BikePower()
	{
	}


public:

/**************************************************************************
 * BikePower::Decode
 * 
 * Decodes all main data pages and calibration pages
 * Exceptions are thrown when dealing with non compliant pages
 *
 * pucRxBuffer_: pointer to the buffer containing the received data
 * 
 * returns: N/A
 *
 **************************************************************************/
	void Decode(UCHAR* pucRxBuffer_)
	{
		switch(pucRxBuffer_[0])
		{
			case PAGE_GET_SET_PARAMETERS:
				ucSubpageNumber = pucRxBuffer_[1];
				ucCrankLength = pucRxBuffer_[4];
				ucSensorStatus = pucRxBuffer_[5];
				ucSensorCapabilities = pucRxBuffer_[6];
				break;
			case PAGE_POWER:
				if(eType == SensorType::UNKNOWN || eType == SensorType::CRANK_TORQUE_FREQ)
				{
					if(++ucPowMsgCount >= NUM_MSGS)
					{
						ucPowMsgCount = 0;
						eType = SensorType::POWER_ONLY;	// After receiving NUM_MSGS successive power messages, determine it is a basic power sensor
					}
				}
				if(eType == SensorType::TORQUE_CRANK || eType == SensorType::TORQUE_WHEEL)
				{
					// If it is a torque sensor, and we stop receiving torque messages, set type to unknown
					if(ucPrevTorqueMsgCount == ucTorqueMsgCount)
					{
						eType = SensorType::UNKNOWN;
						ucPowMsgCount = 0;
						ucTorqueMsgCount = 0;
						ucPrevTorqueMsgCount = 0;
					}
					ucPrevTorqueMsgCount = ucTorqueMsgCount;
				}
				ucPowEventCount = pucRxBuffer_[1];		// Power event count
				ucPedalPower = pucRxBuffer_[2];			// Pedal Power
				ucCadence = pucRxBuffer_[3];			// Cadence
				usAcumPower = pucRxBuffer_[4] | pucRxBuffer_[5] << 8;	// Cumulative power (W)
				usPower = pucRxBuffer_[6] | pucRxBuffer_[7] << 8;		// Instantaneous power (W)
				//if(pucRxBuffer_[2] != RESERVED && bValidation)
					//throw gcnew Error(Error::Code::INVALID_RESERVED);	// Error: Invalid value in reserved field
				break;
			case PAGE_WHEEL_TORQUE:
				if(eType != SensorType::TORQUE_WHEEL)
				{
					eType = SensorType::TORQUE_WHEEL;	// Dealing with wheel torque sensor
					ucTorqueMsgCount = 0;			
					ucPrevTorqueMsgCount = 0;
				}
				ucTorqueMsgCount++;						// Update torque message count
				ucWTEventCount = pucRxBuffer_[1];		// Wheel torque event count
				ucWheelTicks = pucRxBuffer_[2];			// Wheel revolutions
				ucCadence = pucRxBuffer_[3];			// Cadence
				usAcumWheelPeriod2048 = pucRxBuffer_[4] | pucRxBuffer_[5] << 8;	// Cumulative wheel period (1/2048 s)
				usAcumTorque32 = pucRxBuffer_[6] | pucRxBuffer_[7] << 8;	// Cumulative torque (1/32 Nm)
				break;
			case PAGE_CRANK_TORQUE:
				if(eType != SensorType::TORQUE_CRANK)
				{
					eType = SensorType::TORQUE_CRANK;	// Dealing with crank torque sensor
					ucTorqueMsgCount = 0;				
					ucPrevTorqueMsgCount = 0;
				}
				ucTorqueMsgCount++;						// Update torque message count
				ucCTEventCount = pucRxBuffer_[1];		// Crank torque event count
				ucCrankTicks = pucRxBuffer_[2];			// Crank revolutions
				ucCadence = pucRxBuffer_[3];			// Cadence
				usAcumCrankPeriod2048 = pucRxBuffer_[4] | pucRxBuffer_[5] << 8;	// Cumulative crank period (1/2048 s)
				usAcumTorque32 = pucRxBuffer_[6] | pucRxBuffer_[7] << 8;	// Cumulative torque (1/32 Nm)
				break;
         case PAGE_TEPS:
            ucPowEventCount = pucRxBuffer_[1];		// Power event count
            ucLeftTorqueEffectiveness = pucRxBuffer_[2];
            ucRightTorqueEffectiveness = pucRxBuffer_[3];
            ucLeftPedalSmoothness = pucRxBuffer_[4];
            ucRightPedalSmoothness = pucRxBuffer_[5];
            break;
			case PAGE_CTF:
				eType = SensorType::CRANK_TORQUE_FREQ;	// Dealing with crank torque frequency sensor
				ucCTFEventCount = pucRxBuffer_[1];		// Crank torque frequency event count (pedal revolutions)
				usSlope10 = pucRxBuffer_[3] | pucRxBuffer_[2] << 8;		// Variation of output frequency (10 Hz/Nm)
				usTime2000 = pucRxBuffer_[5] | pucRxBuffer_[4] << 8;	// Time of most recent rotation event (1/2000 s)
				usTorqueTicks = pucRxBuffer_[7] | pucRxBuffer_[6] << 8;	// Count of most recent torque event
				break;
			case PAGE_CALIBRATION:
				ucRxCalibrationID = pucRxBuffer_[1];	// Current calibration page received
				switch(ucRxCalibrationID)
				{
					case CAL_TORQUE_METER_CAPABILITIES:
						bAutoZeroEnable = (BOOL) (pucRxBuffer_[2] & 0x01);		// Auto Zero Enabled
						bAutoZeroOn = (BOOL) ((pucRxBuffer_[2] & 0x02) >> 1);	// Auto Zero Status
						sRawTorque = pucRxBuffer_[3] | pucRxBuffer_[4] << 8;	// Raw torque (signed)
						sOffsetTorque = pucRxBuffer_[5] | pucRxBuffer_[6] << 8;	// Offset torque (signed)
						if(bValidation && ((pucRxBuffer_[2] & 0xFC) != RESERVED_DESCR || pucRxBuffer_[7] != RESERVED))
							throw gcnew Error(Error::Code::INVALID_RESERVED);	// Error: Invalid value on reserved field
						break;
					case CAL_REQUEST:
						if(bValidation && (pucRxBuffer_[2] != RESERVED || pucRxBuffer_[3] != RESERVED || pucRxBuffer_[4] != RESERVED || pucRxBuffer_[5] != RESERVED || pucRxBuffer_[6] != RESERVED || pucRxBuffer_[7] != RESERVED))
							throw gcnew Error(Error::Code::INVALID_RESERVED);	// Error: Invalid value on reserved field
						break;
					case CAL_AUTOZERO_CONFIG:
					{
						BOOL bUndefAZ = FALSE;
						switch((AutoZeroStatus) pucRxBuffer_[2])
						{
							case AutoZeroStatus::OFF:
								bAutoZeroEnable = TRUE;
								bAutoZeroOn = FALSE;
								break;
							case AutoZeroStatus::ON:
								bAutoZeroEnable = TRUE;
								bAutoZeroOn = TRUE;
								break;
							case AutoZeroStatus::UNSUPPORTED:
								bAutoZeroEnable = FALSE;
								bAutoZeroOn = FALSE;
								break;
							default:
								bUndefAZ = TRUE;
								break;
						}
						if(bValidation)
						{
							if(pucRxBuffer_[3] != RESERVED || pucRxBuffer_[4] != RESERVED || pucRxBuffer_[5] != RESERVED || pucRxBuffer_[6] != RESERVED || pucRxBuffer_[7] != RESERVED)
							{
								if(bUndefAZ)
									throw gcnew Error(Error::Code::INVALID_RESERVED, Error::Code::UNDEF_AUTOZERO);	// Error: Bad auto zero status and reserved field
								else
									throw gcnew Error(Error::Code::INVALID_RESERVED);	// Error: bad reserved field
							}
							else if(bUndefAZ)
								throw gcnew Error(Error::Code::UNDEF_AUTOZERO);	// Error: undefined auto zero status
						}
						break;
					}
					case CAL_SUCCESS:
					case CAL_FAIL:		// intentional fall thru
					{
						sCalibrationData = pucRxBuffer_[6] | pucRxBuffer_[7] << 8;	// Calibration data (signed)
						BOOL bUndefAZ = FALSE;
						switch((AutoZeroStatus) pucRxBuffer_[2])
						{
							case AutoZeroStatus::OFF:
								bAutoZeroEnable = TRUE;
								bAutoZeroOn = FALSE;
								break;
							case AutoZeroStatus::ON:
								bAutoZeroEnable = TRUE;
								bAutoZeroOn = TRUE;
								break;
							case AutoZeroStatus::UNSUPPORTED:
								bAutoZeroEnable = FALSE;
								bAutoZeroOn = FALSE;
								break;
							default:
								bUndefAZ = TRUE;
								break;
						}
						if(bValidation)
						{
							if(pucRxBuffer_[3] != RESERVED || pucRxBuffer_[4] != RESERVED || pucRxBuffer_[5] != RESERVED)
							{
								if(bUndefAZ)
									throw gcnew Error(Error::Code::INVALID_RESERVED, Error::Code::UNDEF_AUTOZERO);	// Error: Bad auto zero status and reserved field
								else
									throw gcnew Error(Error::Code::INVALID_RESERVED);	// Error: bad reserved field
							}
							else if(bUndefAZ)
								throw gcnew Error(Error::Code::UNDEF_AUTOZERO);	// Error: invalid auto zero status
						}
						break;
					}
					case CAL_CTF:
						ucRxCTFMsgID = pucRxBuffer_[2];
						switch(ucRxCTFMsgID)
						{
						case CTF_OFFSET:
							usCalOffset = pucRxBuffer_[7] | pucRxBuffer_[6] << 8;
							if(bValidation && (pucRxBuffer_[3] != RESERVED || pucRxBuffer_[4] != RESERVED || pucRxBuffer_[5] != RESERVED))
								throw gcnew Error(Error::Code::INVALID_RESERVED); // Error: bad reserved fields
							break;
						case CTF_SLOPE:
							usCalSlope = pucRxBuffer_[7] | pucRxBuffer_[6] << 8;
							if(bValidation && (pucRxBuffer_[3] != RESERVED || pucRxBuffer_[4] != RESERVED || pucRxBuffer_[5] != RESERVED))
								throw gcnew Error(Error::Code::INVALID_RESERVED);	// Error: bad reserved field
							break;
						case CTF_SERIAL:
							usCalSerialNum = pucRxBuffer_[7] | pucRxBuffer_[6] << 8;
							if(bValidation && (pucRxBuffer_[3] != RESERVED || pucRxBuffer_[4] != RESERVED || pucRxBuffer_[5] != RESERVED))
								throw gcnew Error(Error::Code::INVALID_RESERVED);	// Error: bad reserved field
							break;
						case CTF_ACK:
							ucAckedCTFMsg = pucRxBuffer_[3];
							if(bValidation)
							{
								if(pucRxBuffer_[4] != RESERVED || pucRxBuffer_[5] != RESERVED || pucRxBuffer_[6] != RESERVED || pucRxBuffer_[7] != RESERVED)
								{
									if(ucAckedCTFMsg != CTF_SLOPE && ucAckedCTFMsg != CTF_SERIAL)
										throw gcnew Error(Error::Code::INVALID_RESERVED, Error::Code::UNDEF_CTF_ACKED);	// Error: bad reserved field and unsupported acked message
									else
										throw gcnew Error(Error::Code::INVALID_RESERVED);	// Error: bad reserved field
								}
								else if(ucAckedCTFMsg != CTF_SLOPE && ucAckedCTFMsg != CTF_SERIAL)
									throw gcnew Error(Error::Code::UNDEF_CTF_ACKED);	// Error: unsupported acked message
							}
							break;
						default:
							if(bValidation)
								throw gcnew Error(Error::Code::UNDEF_CTF_ID);	// Error: Undefined CTF message
							break;
						}
						break;

					default:
						if(bValidation)
							throw gcnew Error(Error::Code::UNDEF_CAL_ID);	// Error: Undefined calibration message
						break;
				}
				break;

			default:
				if(bValidation)
					throw gcnew Error(Error::Code::UNDEF_PAGE);		// Error: Undefined page
				break;
		}
	}
	

/**************************************************************************
 * BikePower::EncodeMainData
 * 
 * Encodes main bike power data pages:
 * - Basic Power
 * - Wheel Torque
 * - Crank Torque
 * - Crank Torque Frequency
 *
 * Exceptions are thrown when dealing with invalid data
 *
 * ucPageNum_: number of page to encode
 * pucTxBuffer_: pointer to the buffer that will store the encoded data
 * 
 * returns: N/A
 *
 **************************************************************************/
	void EncodeMainData(UCHAR ucPageNum_, UCHAR* pucTxBuffer_)
	{
		switch(ucPageNum_)
		{
			case PAGE_GET_SET_PARAMETERS:
				pucTxBuffer_[0] = ucPageNum_;
				pucTxBuffer_[1] = ucSubpageNumber;
				pucTxBuffer_[2] = RESERVED;
				pucTxBuffer_[3] = RESERVED;
				pucTxBuffer_[4] = ucCrankLength;
				pucTxBuffer_[5] = ucSensorStatus;
				pucTxBuffer_[6] = ucSensorCapabilities;
				pucTxBuffer_[7] = RESERVED;
				break;
			case PAGE_POWER:
				pucTxBuffer_[0] = ucPageNum_;
				pucTxBuffer_[1] = ucPowEventCount;		// Power event count
				pucTxBuffer_[2] = ucPedalPower;			// Pedal Power
				pucTxBuffer_[3] = ucCadence;			// Cadence
				pucTxBuffer_[4] = usAcumPower & 0xFF;	// Cumulative power (W)
				pucTxBuffer_[5] = (usAcumPower >> 8) & 0xFF;
				pucTxBuffer_[6] = usPower & 0xFF;		// Instantaneous power (W)
				pucTxBuffer_[7] = (usPower >> 8) & 0xFF;
				break;
			case PAGE_WHEEL_TORQUE:
				pucTxBuffer_[0] = ucPageNum_;
				pucTxBuffer_[1] = ucWTEventCount;		// Wheel torque event count
				pucTxBuffer_[2] = ucWheelTicks;			// Wheel revolutions
				pucTxBuffer_[3] = ucCadence;			// Cadence
				pucTxBuffer_[4] = usAcumWheelPeriod2048 & 0xFF;  // Cumulative wheel period (1/2048 s)
				pucTxBuffer_[5] = (usAcumWheelPeriod2048 >> 8) & 0xFF;
				pucTxBuffer_[6] = usAcumTorque32 & 0xFF;		// Cumulative torque (1/32 Nm)
				pucTxBuffer_[7] = (usAcumTorque32 >> 8) & 0xFF;
				break;
			case PAGE_CRANK_TORQUE:
				pucTxBuffer_[0] = ucPageNum_;
				pucTxBuffer_[1] = ucCTEventCount;		// Crank torque event count
				pucTxBuffer_[2] = ucCrankTicks;			// Crank revolutions
				pucTxBuffer_[3] = ucCadence;			// Cadence
				pucTxBuffer_[4] = usAcumCrankPeriod2048 & 0xFF;		// Cumulative crank period (1/2048 s)
				pucTxBuffer_[5] = (usAcumCrankPeriod2048 >> 8) & 0xFF;
				pucTxBuffer_[6] = usAcumTorque32 & 0xFF;		// Cumulative torque (1/32 Nm)
				pucTxBuffer_[7] = (usAcumTorque32 >> 8) & 0xFF;
				break;
         case PAGE_TEPS:
            pucTxBuffer_[0] = ucPageNum_;
            pucTxBuffer_[1] = ucPowEventCount;     // tied to event counter in power only page
            pucTxBuffer_[2] = ucLeftTorqueEffectiveness;
            pucTxBuffer_[3] = ucRightTorqueEffectiveness;
            pucTxBuffer_[4] = ucLeftPedalSmoothness;
            pucTxBuffer_[5] = ucRightPedalSmoothness;
            pucTxBuffer_[6] = RESERVED;
            pucTxBuffer_[7] = RESERVED;
            break;
			case PAGE_CTF:
				pucTxBuffer_[0] = ucPageNum_;
				pucTxBuffer_[1] = ucCTFEventCount;		// Crank torque frequency event count (pedal revolutions)
				pucTxBuffer_[2] = (usSlope10 >> 8) & 0xFF;	// Variation of output frequency (10 Hz/Nm)
				pucTxBuffer_[3] = usSlope10 & 0xFF;
				pucTxBuffer_[4] = (usTime2000 >> 8) & 0xFF;	// Time of most recent rotation event (1/2000 s)
				pucTxBuffer_[5] = usTime2000 & 0xFF;
				pucTxBuffer_[6] = (usTorqueTicks >> 8) & 0xFF;	// Count of most recent torque event
				pucTxBuffer_[7] = usTorqueTicks & 0xFF;
				break;
			default:
				if(bValidation)
					throw gcnew Error(Error::Code::UNDEF_PAGE);		// Error: Undefined page
				break;
		}
	}

/**************************************************************************
 * BikePower::EncodeAutoZeroSupport
 * 
 * Encodes the auto zero support (torque meter capabilities) page (0x12)
 *
 * pucTxBuffer_: pointer to the buffer that will store the encoded data
 * 
 * returns: N/A
 *
 **************************************************************************/
	void EncodeAutoZeroSupport(UCHAR* pucTxBuffer_)
	{
		pucTxBuffer_[0] = PAGE_CALIBRATION;
		pucTxBuffer_[1] = CAL_TORQUE_METER_CAPABILITIES;
		pucTxBuffer_[2] = (UCHAR) bAutoZeroEnable;		// Auto Zero Enabled (bit 0)
		pucTxBuffer_[2] |= (UCHAR) bAutoZeroOn  << 1;	// Auto Zero Status (bit 1)
		pucTxBuffer_[3] = sRawTorque & 0xFF;			// Raw torque (LSB)
		pucTxBuffer_[4] = (sRawTorque >> 8) & 0xFF;		// Raw torque (MSB)
		pucTxBuffer_[5] = sOffsetTorque & 0xFF;			// Offset torque (LSB)
		pucTxBuffer_[6] = (sOffsetTorque >> 8) & 0xFF;	// Offset torque (MSB)
		pucTxBuffer_[7] = RESERVED;
	}


/**************************************************************************
 * BikePower::EncodeManualCalibrationRequest
 * 
 * Encodes a manual calibration request (0xAA)
 *
 * pucTxBuffer_: pointer to the buffer that will store the encoded data
 * 
 * returns: N/A
 *
 **************************************************************************/
	void EncodeManualCalibrationRequest(UCHAR* pucTxBuffer_)
	{		
		pucTxBuffer_[0] = PAGE_CALIBRATION;
		pucTxBuffer_[1] = CAL_REQUEST;
		pucTxBuffer_[2] = RESERVED;
		pucTxBuffer_[3] = RESERVED;
		pucTxBuffer_[4] = RESERVED;
		pucTxBuffer_[5] = RESERVED;
		pucTxBuffer_[6] = RESERVED;
		pucTxBuffer_[7] = RESERVED;
	}


/**************************************************************************
 * BikePower::EncodeAZCalibrationRequest
 * 
 * Encodes an auto zero calibration request (0xAB)
 *
 * bAutoZeroEnabled_ = TRUE if AutoZero is supported, FALSE otherwise
 * bAutoZeroOn_ = TRUE if AutoZero is ON, FALSE otherwise
 * pucTxBuffer_: pointer to the buffer that will store the encoded data
 * 
 * returns: N/A
 *
 **************************************************************************/
	void EncodeAZCalibrationRequest(BOOL bAutoZeroEnabled_, BOOL bAutoZeroOn_, UCHAR* pucTxBuffer_)
	{
		pucTxBuffer_[0] = PAGE_CALIBRATION;
		pucTxBuffer_[1] = CAL_AUTOZERO_CONFIG;
		if(!bAutoZeroEnabled_)
			pucTxBuffer_[2] = (UCHAR) AutoZeroStatus::UNSUPPORTED;	 // Encode auto zero status
		else if(bAutoZeroOn_)
			pucTxBuffer_[2] = (UCHAR) AutoZeroStatus::ON;
		else
			pucTxBuffer_[2] = (UCHAR) AutoZeroStatus::OFF;
		pucTxBuffer_[3] = RESERVED;
		pucTxBuffer_[4] = RESERVED;
		pucTxBuffer_[5] = RESERVED;
		pucTxBuffer_[6] = RESERVED;
		pucTxBuffer_[7] = RESERVED;
	}

/**************************************************************************
 * BikePower::EncodeCalibrationResponse
 * 
 * Encodes a calibration response (0xAC or 0xAF)
 *
 * ucCalResponseID_: response to send (either CAL_FAIL or CAL_SUCCESS)
 * bAutoZeroEnabled_ = TRUE if AutoZero is supported, FALSE otherwise
 * bAutoZeroOn_ = TRUE if AutoZero is ON, FALSE otherwise
 * sCalData_ = calibration data to send in response
 * pucTxBuffer_: pointer to the buffer that will store the encoded data
 * 
 * returns: N/A
 *
 **************************************************************************/
	void EncodeCalibrationResponse(UCHAR ucCalResponseID_, BOOL bAutoZeroEnabled_, BOOL bAutoZeroOn_, SHORT sCalData_, UCHAR* pucTxBuffer_)
	{
		pucTxBuffer_[0] = PAGE_CALIBRATION;
		pucTxBuffer_[1] = ucCalResponseID_;
		if(!bAutoZeroEnabled_)
			pucTxBuffer_[2] = (UCHAR) AutoZeroStatus::UNSUPPORTED;	// Encode auto zero status
		else if(bAutoZeroOn_)
			pucTxBuffer_[2] = (UCHAR) AutoZeroStatus::ON;
		else
			pucTxBuffer_[2] = (UCHAR) AutoZeroStatus::OFF;
		pucTxBuffer_[3] = RESERVED;
		pucTxBuffer_[4] = RESERVED;
		pucTxBuffer_[5] = RESERVED;
		pucTxBuffer_[6] = sCalData_ & 0xFF;				// Calibration data, low byte
		pucTxBuffer_[7] = (sCalData_ >> 8) & 0x0FF;		// Calibration data, high byte
	}


/**************************************************************************
 * BikePower::EncodeCTFCalibrationPage
 * 
 * Encodes a CTF calibration page
 *
 * ucCTFMsgID_: ID of CTF defined message; either CTF_OFFSET, CTF_SLOPE or CTF_SERIAL
 * usParam_: parameter to include in page (offset, slope or serial number)
 * pucTxBuffer_: pointer to the buffer that will store the encoded data
 * 
 * returns: N/A
 *
 **************************************************************************/
	void EncodeCTFCalibrationPage(UCHAR ucCTFMsgID_, USHORT usParam_, UCHAR* pucTxBuffer_)
	{
		switch(ucCTFMsgID_)
		{
			case CTF_OFFSET:
			case CTF_SLOPE:
			case CTF_SERIAL:	// Intentional fall thru
				pucTxBuffer_[0] = PAGE_CALIBRATION;
				pucTxBuffer_[1] = CAL_CTF;
				pucTxBuffer_[2] = ucCTFMsgID_;
				pucTxBuffer_[3] = RESERVED;
				pucTxBuffer_[4] = RESERVED;
				pucTxBuffer_[5] = RESERVED;
				pucTxBuffer_[6] = (usParam_ >> 8) & 0xFF;	// CTF parameter (offset, slope, serial number), high byte
				pucTxBuffer_[7] = usParam_ & 0xFF;			// CTF parameter (offset, slope, serial number), low byte
				break;
			case CTF_ACK:
				pucTxBuffer_[0] = PAGE_CALIBRATION;
				pucTxBuffer_[1] = CAL_CTF;
				pucTxBuffer_[2] = ucCTFMsgID_;
				pucTxBuffer_[3] = (UCHAR) usParam_;			// parameter in this case is message code to acknowledge
				pucTxBuffer_[4] = RESERVED;
				pucTxBuffer_[5] = RESERVED;
				pucTxBuffer_[6] = RESERVED;
				pucTxBuffer_[7] = RESERVED;
				break;
			default:
				break;
		}
	}


/**************************************************************************
 * BikePower::IsCadenceInvalid
 * 
 * Checks if the cadence value is invalid
 *
 * ucCadence_: cadence (rpm)
 * 
 * returns: N/A
 *
 **************************************************************************/
	BOOL IsCadenceInvalid(UCHAR ucCadence_)
	{
		if(ucCadence_ == INVALID_CADENCE)
			return TRUE;
		else
			return FALSE;		
	}

/**************************************************************************
 * BikePower::IsSlopeInvalid
 * 
 * Checks if the slope is within the boundaries defined in the device profile
 *
 * usSlope10_: slope (1/10 Nm/Hz)
 * 
 * returns: N/A
 *
 **************************************************************************/
	BOOL IsSlopeInvalid(USHORT usSlope10_)
	{
		if(usSlope10_ < MIN_SLOPE || usSlope10_ > MAX_SLOPE)
			return TRUE;
		else
			return FALSE;
	}


/**************************************************************************
 * BikePower::IsRawTorqueInvalid
 * 
 * Checks if the raw torque is invalid
 *
 * sRawTorque: raw torque
 * 
 * returns: N/A
 *
 **************************************************************************/
	BOOL IsRawTorqueInvalid(SHORT sRawTorque_)
	{
		if(sRawTorque_ == INVALID_TORQUE)
			return TRUE;
		else
			return FALSE;
	}


/**************************************************************************
 * BikePower::IsOffsetTorqueInvalid
 * 
 * Checks if the offset torque is invalid
 *
 * sOffsetTorque_: offset torque
 * 
 * returns: N/A
 *
 **************************************************************************/
	BOOL IsOffsetTorqueInvalid(SHORT sOffsetTorque_)
	{
		if(sOffsetTorque_ == INVALID_TORQUE)
			return TRUE;
		else
			return FALSE;
	}

/**************************************************************************
 * BikePower::IsOffsetInvalid
 * 
 * Checks if the offset is within the boundaries defined in the device profile
 *
 * usCalOffset_: offset
 * 
 * returns: N/A
 *
 **************************************************************************/
	BOOL IsOffsetInvalid(USHORT usCalOffset_)
	{
		if(usCalOffset_ < MIN_OFFSET || usCalOffset_ > MAX_OFFSET)
			return TRUE;
		else
			return FALSE;
	}

};