plc_485_comm.lib

//$Id: AUTOPAK_RUN_STATE.LIB,v 1.11 2003/10/31 23:42:21 Charles Hand Exp $

/*

  2012/06/20 Charles Hand

  Adapted COMM.LIB from STEPPER.LIB

  2005/08/23 Charles Hand

  New Library

*/

/*

***** Comm Port Pin Out *****

   SATA  		Cables		Printer		DB-9

7	GND		IS SHIELD			9

6	RS485 A 	IS GREEN			8	RS232 CTS

5	RS485 B 	IS WHITE			7

4	RS232 CTS   	PRINTER RED	Pin 3		6	RS485 B

3	RS232 RX  	PRINTER WHITE	Pin 2		5	GND

2	RS232 TX 	PRINTER GREEN	Pin 1		4

1	GND          	PRINTER BLACK	Pin 4		3  	RS232 TX

							2 	RS232 RX

                  					1	RS485 A

*/

/*** BeginHeader */

#ifndef __ISM_485_COMM_

#define __ISM_485_COMM_

// The node addresses

#define TCN_ADDRESS     1

#define GTLC1_ADDRESS   2

#define GTLC2_ADDRESS   3

#define RFS1_ADDRESS    4

// The "Request Status" command

enum {

	COMM_FUNCTION_REQUEST_STATUS = 1,

	COMM_FUNCTION_CV1_RETURN,

	COMM_FUNCTION_CV2_RETURN,

	COMM_FUNCTION_HOUR_TICK

};

#define DINBUFSIZE  255

#define DOUTBUFSIZE 255

/*** EndHeader */

/*** BeginHeader

     InitializeComm,

     CommAuth1,

     CommAuth2,

     CommAuth3,

     CommAuth4,

     CommBoiler,

     CommPolish,

     CommPHi,

     CommPMid,

     CommPLo,

     CommPump1,

     CommPump2,

     CommPump3,

     CommPump4,

     CommShunt,

     CommFOCV1,

     CommFOCV2,

     CommFOCV3,

     CommFOCV4,

     CommDrain,

     CommH2O,

     CommPolisherLevel,

     CommDayTankLevel,

     CommTest,

     CommEstop,

     CommAlarmLowPressure,

     CommAlarmMidPressure,

     CommAlarmNoFuelFlow,

     CommAlarmOperatorOverride,

     CommAlarmOperatorAborted,

     CommAlarmDeadTurbine,

     CommAlarmLowFuel,

     CommAlarmNoFuel,

     CommAlarmOverfill,

     CommAlarmSensorFailure,

     CommSupplyCv,

     CommReturnCv,

     CommRead,

     CommSendStatus,

     CommGetCV1Return,

     CommGetCV2Return,

     CommGetHourTick,

*/

//Global function prototypes **************************************************

void InitializeComm(int address);

int  CommRead();

void CommSendStatus ();

int CommGetCV1Return ();

int CommGetCV2Return ();

long CommGetHourTick ();

int CommAuth1 (int onOff);

int CommAuth2 (int onOff);

int CommAuth3 (int onOff);

int CommAuth4 (int onOff);

int CommBoiler(int onOff);

int CommPolish(int onOff);

int CommPHi   (int onOff);

int CommPMid  (int onOff);

int CommPLo   (int onOff);

int CommPump1 (int onOff);

int CommPump2 (int onOff);

int CommPump3 (int onOff);

int CommPump4 (int onOff);

int CommShunt (int onOff);

int CommFOCV1 (int onOff);

int CommFOCV2 (int onOff);

int CommFOCV3 (int onOff);

int CommFOCV4 (int onOff);

int CommDrain (int onOff);

int CommH2O   (int onOff);

int CommEstop (int onOff);

int CommPolisherLevel(int level);

int CommDayTankLevel(int level);

int CommCVReturn (int onOff);

int CommAlarmLowPressure(int onOff);

int CommAlarmMidPressure(int onOff);

int CommAlarmNoFuelFlow(int onOff);

int CommAlarmOperatorOverride(int onOff);

int CommAlarmOperatorAborted(int onOff);

int CommAlarmDeadTurbine(int onOff);

int CommAlarmLowFuel(int onOff);

int CommAlarmNoFuel(int onOff);

int CommAlarmOverfill(int onOff);

int CommAlarmSensorFailure(int onOff);

int CommTest(int type, char result, float rate, int indexToNoteTable);

int CommSupplyCv(int onOff);

int CommReturnCv(int onOff);

/*** EndHeader */

//Local function prototypes *********************************************

void sendMessage(char *aMessage);

void addIntString(char **ptr, int value, int *spaceLeft, int nDigits);

void addIntStringParameter(char **ptr, int statusCode, int value, int *spaceLeft);

//Constants *******************************************************

#define COMM_BAUD_RATE 38400L

#define RS485_TX_ENABLE_BIT  2

// The send buffer size depends on the maximum number of values

//   that have to be sent. Well, there are 38 values defined now,

//   of course no single node would ever be sending all the values.

//   You need six bytes for each value, plus a few bytes of overhead

//   for the message. Let's pick a ridiculously large number 300

#define SEND_BUFFER_LENGTH 300

#define RECEIVE_PAYLOAD_LENGTH 300

#define RECEIVE_MESSAGE_MAX_LENGTH (RECEIVE_PAYLOAD_LENGTH + 3)

// Our request messages look like this:

// #aa|ff[|nn|vv...];

// Where aa is the node address, ff is the function,

//   nn is a variable name and vv is the variable value.

// It's all in ascii and it's all in decimal.

// For now all fields are exactly two characters long, permitting a maximum value of 99

// Our response messages look like this:

// @aa|ff[|nn|vv...];

//   Same as the request message except the first character is

//   '@' instead of '#'

// Our messages begin with ? and end with !

// Fields are delimited with |

#define MESSAGE_REQUEST_BEGIN_TOKEN '#'

#define MESSAGE_RESPONSE_BEGIN_TOKEN '@'

#define MESSAGE_DELIMITER '|'

#define MESSAGE_END_TOKEN ';'

// The fields in our messages are identified using these macros

enum {

	COMM_STATUS_AUTH1 = 1,

			COMM_STATUS_AUTH2,

			COMM_STATUS_AUTH3,

			COMM_STATUS_AUTH4,

			COMM_STATUS_BOILER,

			COMM_STATUS_POLISH,

			COMM_STATUS_PHI,

			COMM_STATUS_PMID,

			COMM_STATUS_PLO,

    COMM_STATUS_PUMP1, // 10

			COMM_STATUS_PUMP2,

			COMM_STATUS_PUMP3,

			COMM_STATUS_PUMP4,

			COMM_STATUS_SHUNT,

			COMM_STATUS_FOCV1,

			COMM_STATUS_FOCV2,

			COMM_STATUS_FOCV3,

			COMM_STATUS_FOCV4,

			COMM_STATUS_DRAIN,

    COMM_STATUS_H2O, // 20

			COMM_STATUS_POLISHER_LEVEL,

			COMM_STATUS_DAYTANK_LEVEL,

			COMM_TEST_SERIAL_NUMBER,

			COMM_TEST_RESULT,

			COMM_TEST_TYPE,

			COMM_TEST_RATE,

			COMM_TEST_INDEX,

			COMM_STATUS_ESTOP,

			COMM_CV_RETURN,

			COMM_ALARM_LOW_PRESSURE,

    COMM_ALARM_MID_PRESSURE, // 30

			COMM_ALARM_NO_FUEL_FLOW,

			COMM_ALARM_OPERATOR_OVERRIDE,

			COMM_ALARM_OPERATOR_ABORTED,

			COMM_ALARM_LOW_FUEL,

			COMM_ALARM_NO_FUEL,

			COMM_ALARM_OVERFILL,

            COMM_ALARM_SENSOR_FAILURE,

            COMM_STATUS_SUPPLY_CV,

            COMM_STATUS_RETURN_CV,

    COMM_FIRST_POLL, //40

    		COMM_ALARM_DEAD_TURBINE

         } ;

//#define EVENT_QUEUE_LENGTH 10

#define DEFAULT_INT -32767

/*** Local variables ***/

// These are all the values that may get communicated to the display

int auth1;

int auth2;

int auth3;

int auth4;

int boiler;

int polish;

int phi;

int pmid;

int plo;

int pump1;

int pump2;

int pump3;

int pump4;

int shunt;

int focv1;

int focv2;

int focv3;

int focv4;

int drain;

int alarm;

int h2o;

int estop;

int polisherLevel;

int dayTankLevel;

int cvReturn;

int alarmLowPressure;

int alarmMidPressure;

int alarmNoFuelFlow;

int alarmOperatorOverride;

int alarmOperatorAbort;

int alarmDeadTurbine;

int alarmLowFuel;

int alarmNoFuel;

int alarmOverfill;

int alarmSensorFailure;

int testType;

int testResult;

int testRate;

int testIndex;

int supplyCv;

int returnCv;

int functionCV1Return;

int functionCV2Return;

long functionHourTick;

int  commRxFunction;

char commRxMessage[RECEIVE_MESSAGE_MAX_LENGTH];

char commRxMessageTemp[RECEIVE_MESSAGE_MAX_LENGTH];

int  commRxIdx;

char myAddress;              // The unique address of this node

int currentTestSerialNumber;

int firstPoll;

//Code  ************************************************************************

// Initialize the library.

// address is the address of this node

// Make sure the transmit bit is high

// Set the baud rate to COMM_BAUD_RATE

void InitializeComm (int address)

{

    // All these status variables are initialized to -1.

    // If they are never set to any other value, they will never be transmitted

    //   as part of the status response message.

    // That way, TCN_COMM is common to all the nodes, but only the signals

    //   specificically given a value by the node will be sent

    auth1  = DEFAULT_INT;

    auth2  = DEFAULT_INT;

    auth3  = DEFAULT_INT;

    auth4  = DEFAULT_INT;

    boiler = DEFAULT_INT;

    polish = DEFAULT_INT;

    phi    = DEFAULT_INT;

    pmid   = DEFAULT_INT;

    plo    = DEFAULT_INT;

    pump1  = DEFAULT_INT;

    pump2  = DEFAULT_INT;

    pump3  = DEFAULT_INT;

    pump4  = DEFAULT_INT;

    shunt  = DEFAULT_INT;

    focv1  = DEFAULT_INT;

    focv2  = DEFAULT_INT;

    focv3  = DEFAULT_INT;

    focv4  = DEFAULT_INT;

    drain  = DEFAULT_INT;

    alarm  = DEFAULT_INT;

    h2o    = DEFAULT_INT;

    estop  = DEFAULT_INT;

    polisherLevel = DEFAULT_INT;

    dayTankLevel = DEFAULT_INT;

    cvReturn = DEFAULT_INT;

    alarmLowPressure = DEFAULT_INT;

    alarmMidPressure = DEFAULT_INT;

    alarmNoFuelFlow = DEFAULT_INT;

    alarmOperatorOverride = DEFAULT_INT;

    alarmOperatorAbort = DEFAULT_INT;

    alarmDeadTurbine = DEFAULT_INT;

    alarmLowFuel = DEFAULT_INT;

    alarmNoFuel = DEFAULT_INT;

    alarmOverfill = DEFAULT_INT;

    alarmSensorFailure = DEFAULT_INT;

    testType = DEFAULT_INT;

    testResult = DEFAULT_INT;

    testRate = DEFAULT_INT;

    testIndex = DEFAULT_INT;

    supplyCv = DEFAULT_INT;

    returnCv = DEFAULT_INT;

    currentTestSerialNumber = 0;

    firstPoll = 1;

    myAddress = (char)address;

    commRxIdx = 0;

    memset(commRxMessage, 0, sizeof(commRxMessage));

    BitWrPortI(PCDR, &PCDRShadow, 0, RS485_TX_ENABLE_BIT);

    BitWrPortI (PCFR, &PCFRShadow, 1, 0); // Configure Port C bit 0

    //  as Serial Port D outupt

    WrPortI (SDCR, &SDCRShadow, 0x00);    // Set serial port D

    // to use port C for serial input,

    // async mode, 8 bits, no interrupt

    serDopen(COMM_BAUD_RATE);

}

int CommAuth1(int onOff)

{

    auth1 = onOff;

}

int CommAuth2(int onOff)

{

    auth2 = onOff;

}

int CommAuth3(int onOff)

{

    auth3 = onOff;

}

int CommAuth4(int onOff)

{

    auth4 = onOff;

}

int CommBoiler(int onOff)

{

    boiler = onOff;

}

int CommPolish (int onOff)

{

	 polish = onOff;

}

int CommPHi(int onOff)

{

    phi = onOff;

}

int CommPMid (int onOff)

{

    pmid = onOff;

}

int CommPLo(int onOff)

{

    plo = onOff;

}

int CommPump1(int onOff)

{

    pump1 = onOff;

}

int CommPump2(int onOff)

{

    pump2 = onOff;

}

int CommPump3(int onOff)

{

    pump3 = onOff;

}

int CommPump4(int onOff)

{

    pump4 = onOff;

}

int CommShunt(int onOff)

{

    shunt = onOff;

}

int CommFOCV1(int onOff)

{

    focv1 = onOff;

}

int CommFOCV2(int onOff)

{

    focv2 = onOff;

}

int CommFOCV3(int onOff)

{

    focv3 = onOff;

}

int CommFOCV4(int onOff)

{

    focv4 = onOff;

}

int CommDrain(int onOff)

{

    drain = onOff;

}

int CommH2O(int onOff)

{

    h2o = onOff;

}

int CommEstop(int onOff)

{

    estop = onOff;

}

int CommPolisherLevel(int level)

{

    polisherLevel = level;

}

int CommDayTankLevel(int level)

{

    dayTankLevel = level;

}

int CommCVReturn(int onOff)

{

    cvReturn = onOff;

}

int CommSupplyCv(int onOff)

{

    supplyCv = onOff;

}

int CommReturnCv(int onOff)

{

    returnCv = onOff;

}

int CommAlarmLowPressure(int onOff)

{

    alarmLowPressure = onOff;

}

int CommAlarmMidPressure(int onOff)

{

    alarmMidPressure = onOff;

}

int CommAlarmNoFuelFlow(int onOff)

{

    alarmNoFuelFlow = onOff;

}

int CommAlarmOperatorOverride(int onOff)

{

    alarmOperatorOverride = onOff;

}

int CommAlarmOperatorAbort(int onOff)

{

    alarmOperatorAbort = onOff;

}

int CommAlarmDeadTurbine(int onOff)

{

	alarmDeadTurbine = onOff;

}

int CommAlarmLowFuel(int onOff)

{

    alarmLowFuel = onOff;

}

int CommAlarmNoFuel(int onOff)

{

    alarmNoFuel = onOff;

}

int CommAlarmOverfill(int onOff)

{

    alarmOverfill = onOff;

}

int CommAlarmSensorFailure(int onOff)

{

    alarmSensorFailure = onOff;

}

int CommTest(int type, char result, float rate, int indexToNoteTable)

{

	firstPoll = 0;

    currentTestSerialNumber++;

    currentTestSerialNumber &= 0xffff;

    testType = type;

    testResult = result == 'p' ? 1 : 0;

    testRate = (int)(rate * 1000.0 + 0.5);

    testIndex = indexToNoteTable;

    #if ADDRESS == TCN_ADDRESS

		UpdateLog(TEST_LOG, testType, testResult, testRate, testIndex, 1, 1);

    #endif

}

// Copy the serial port D contents to our local buffer, and see if there is

// a message in there. If there is a message, and it is for us, return the

// function code. Otherwise, return zero.

int CommRead()

{

    int nChars;

    char *msgStart;

    char *msgEnd;

    char conv[5];

    int anAdr;

    int aRxChar;

    int result;

    char *p1,*p2;

    msgStart = NULL;

    msgEnd = NULL;

    result = 0;

    memset(conv,0,sizeof(conv));

    // How many characters are there in the Serial Port D buffer?

    nChars = serDrdUsed();

    // OK, read that many characters and add them to the local buffer, commRxMessage

    //   but don't go past the end of the buffer (leaving room for a null terminator)

    while (nChars-- > 0 && commRxIdx < sizeof(commRxMessage) - 1) {

        aRxChar = (char)serDgetc();

        commRxMessage[commRxIdx++] = aRxChar;

        commRxMessage[commRxIdx] = 0; // Whenever we add a character, add a null terminator

    }

    // Search the entire local buffer backwards for a message end token

    // Discard messages which aren't for us, and discard echos of our

    //   own outbound messages.

    // Begin by detecting the oldest end token in the buffer

    while (result == 0 && (msgEnd = strchr(commRxMessage, MESSAGE_END_TOKEN)) != NULL) {

        // Now that we have found an end token,

        //   there ought to be a begin token before the end token

        //   If not, our communications are being scrambled somehow

		msgStart = msgEnd;

		while (msgStart != commRxMessage &&

               *msgStart != MESSAGE_RESPONSE_BEGIN_TOKEN &&

               *msgStart != MESSAGE_REQUEST_BEGIN_TOKEN)

        {

            msgStart--;

        }

      if (*msgStart == MESSAGE_REQUEST_BEGIN_TOKEN) {

      	memset(conv, 0, sizeof(conv));

         conv[0] = msgStart[1];

         conv[1] = msgStart[2];

         anAdr = atoi(conv);

         if (anAdr == myAddress) {

           	 memset(conv, 0, sizeof(conv));

             conv[0] = msgStart[4];

             conv[1] = msgStart[5];

             result = atoi(conv);

         }

         if (result == COMM_FUNCTION_CV1_RETURN) {

            memset(conv, 0, sizeof(conv));

            conv[0] = msgStart[7];

            conv[1] = msgStart[8];

            functionCV1Return = atoi(conv);

         }

         if (result == COMM_FUNCTION_CV2_RETURN) {

            memset(conv, 0, sizeof(conv));

            conv[0] = msgStart[7];

            conv[1] = msgStart[8];

            functionCV2Return = atoi(conv);

         }

        if (result == COMM_FUNCTION_HOUR_TICK) {

            memset(conv, 0, sizeof(conv));

            functionHourTick = atol(conv);

         }

      }

        // Now any time we find an end token,

        //   we will adjust the local buffer by shifting everything starting

        //   with the character after the end token down to the beginning

        //   of the local buffer, and setting the commRxIdx accordingly

        strcpy(commRxMessageTemp, msgEnd+1);

        memset(commRxMessage, 0, sizeof(commRxMessage));

        strcpy(commRxMessage, commRxMessageTemp);

        commRxIdx = strlen(commRxMessage);

    }

    if (msgEnd == NULL && commRxIdx >= sizeof(commRxMessage) - 1) {

        // This is very bad. Our entire local buffer is full, yet we don't find

        //   a single message end token in it. Well, might as well dump the

        //   buffer in hopes that good stuff may yet into the serial port

        memset(commRxMessage, 0, sizeof(commRxMessage));

        commRxIdx = 0;

    }

    return result;

}

int CommGetCV1Return() {

	char message[SEND_BUFFER_LENGTH];

   char *ptr;

   int spaceLeft;

   ptr = message;

   *ptr++ = MESSAGE_RESPONSE_BEGIN_TOKEN;

   spaceLeft = SEND_BUFFER_LENGTH - 2;

   addIntString(&ptr, myAddress, &spaceLeft, 2);

   addIntString(&ptr, COMM_FUNCTION_CV1_RETURN, &spaceLeft, 2);

	if (spaceLeft >= 0) // actually need one, but final pipe character will be overwritten

   {

        ptr--; // Overwrite the last pipe character

        *ptr++ = MESSAGE_END_TOKEN;

        *ptr = 0;

        sendMessage(message);

   }

	return functionCV1Return;

}

int CommGetCV2Return() {

	char message[SEND_BUFFER_LENGTH];

   char *ptr;

   int spaceLeft;

   ptr = message;

   *ptr++ = MESSAGE_RESPONSE_BEGIN_TOKEN;

   spaceLeft = SEND_BUFFER_LENGTH - 2;

   addIntString(&ptr, myAddress, &spaceLeft, 2);

   addIntString(&ptr, COMM_FUNCTION_CV2_RETURN, &spaceLeft, 2);

	if (spaceLeft >= 0) // actually need one, but final pipe character will be overwritten

   {

        ptr--; // Overwrite the last pipe character

        *ptr++ = MESSAGE_END_TOKEN;

        *ptr = 0;

        sendMessage(message);

   }

	return functionCV2Return;

}

long CommGetHourTick() {

	char message[SEND_BUFFER_LENGTH];

   char *ptr;

   int spaceLeft;

   ptr = message;

   *ptr++ = MESSAGE_RESPONSE_BEGIN_TOKEN;

   spaceLeft = SEND_BUFFER_LENGTH - 2;

   addIntString(&ptr, myAddress, &spaceLeft, 2);

   addIntString(&ptr, COMM_FUNCTION_HOUR_TICK, &spaceLeft, 2);

	if (spaceLeft >= 0) // actually need one, but final pipe character will be overwritten

   {

        ptr--; // Overwrite the last pipe character

        *ptr++ = MESSAGE_END_TOKEN;

        *ptr = 0;

        sendMessage(message);

   }

	return functionHourTick;

}

// This should be called in response to a

//   COMM_FUNCTION_REQUEST_STATUS from the master

void CommSendStatus()

{

    char message[SEND_BUFFER_LENGTH]; // A temporary buffer for our message

    char *ptr;

    int spaceLeft;

    int i, intRate;

    ptr = message;

    *ptr++ = MESSAGE_RESPONSE_BEGIN_TOKEN;

    spaceLeft = SEND_BUFFER_LENGTH - 2; // minus one for null terminator, minus one for begin token

    addIntString(&ptr, myAddress, &spaceLeft, 2);

    addIntString(&ptr, COMM_FUNCTION_REQUEST_STATUS, &spaceLeft, 2);

    if (firstPoll)

    {

		addIntStringParameter(&ptr, COMM_FIRST_POLL, 0, &spaceLeft);

	}

    addIntStringParameter(&ptr, COMM_STATUS_AUTH1, auth1, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_AUTH2, auth2, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_AUTH3, auth3, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_AUTH4, auth4, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_BOILER, boiler, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_POLISH, polish, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_PHI, phi, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_PMID, pmid, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_PLO, plo, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_PUMP1, pump1, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_PUMP2, pump2, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_PUMP3, pump3, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_PUMP4, pump4, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_SHUNT, shunt, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_FOCV1, focv1, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_FOCV2, focv2, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_FOCV3, focv3, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_FOCV4, focv4, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_DRAIN, drain, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_H2O, h2o, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_ESTOP, estop, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_POLISHER_LEVEL, polisherLevel, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_DAYTANK_LEVEL, dayTankLevel, &spaceLeft);

    addIntStringParameter(&ptr, COMM_CV_RETURN, cvReturn, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_SUPPLY_CV, supplyCv, &spaceLeft);

    addIntStringParameter(&ptr, COMM_STATUS_RETURN_CV, returnCv, &spaceLeft);

    addIntStringParameter(&ptr, COMM_ALARM_LOW_PRESSURE, alarmLowPressure, &spaceLeft);

    addIntStringParameter(&ptr, COMM_ALARM_MID_PRESSURE, alarmMidPressure, &spaceLeft);

    addIntStringParameter(&ptr, COMM_ALARM_NO_FUEL_FLOW, alarmNoFuelFlow, &spaceLeft);

    addIntStringParameter(&ptr, COMM_ALARM_OPERATOR_OVERRIDE, alarmOperatorOverride, &spaceLeft);

    addIntStringParameter(&ptr, COMM_ALARM_OPERATOR_ABORTED, alarmOperatorAbort, &spaceLeft);

    addIntStringParameter(&ptr, COMM_ALARM_DEAD_TURBINE, alarmDeadTurbine, &spaceLeft);

    addIntStringParameter(&ptr, COMM_ALARM_LOW_FUEL, alarmLowFuel, &spaceLeft);

    addIntStringParameter(&ptr, COMM_ALARM_NO_FUEL, alarmNoFuel, &spaceLeft);

    addIntStringParameter(&ptr, COMM_ALARM_OVERFILL, alarmOverfill, &spaceLeft);

    addIntStringParameter(&ptr, COMM_ALARM_SENSOR_FAILURE, alarmSensorFailure, &spaceLeft);

    if (testType != DEFAULT_INT)

    {

        addIntStringParameter(&ptr, COMM_TEST_SERIAL_NUMBER, currentTestSerialNumber, &spaceLeft);

        addIntStringParameter(&ptr, COMM_TEST_RESULT, testResult, &spaceLeft);

        addIntStringParameter(&ptr, COMM_TEST_TYPE, testType, &spaceLeft);

        addIntStringParameter(&ptr, COMM_TEST_RATE, testRate, &spaceLeft);

        addIntStringParameter(&ptr, COMM_TEST_INDEX, testIndex, &spaceLeft);

    }

    if (spaceLeft >= 0) // actually need one, but final pipe character will be overwritten

    {

        ptr--; // Overwrite the last pipe character

        *ptr++ = MESSAGE_END_TOKEN;

        *ptr = 0;

        sendMessage(message);

    }

}

void sendMessage(char *message) {

    long timeNow;

    BitWrPortI(PCDR, &PCDRShadow, 1, RS485_TX_ENABLE_BIT);

    serDwrite(message, strlen(message));

    while (serDwrUsed() > 0) {}

    // Assuming we're at 38400 buad, the last character will take

    //   26 microseconds to send.

    // The smallest time we can reliably delay is 1 ms by

    //   trying to delay 2 ms

    // And we can't use MsDelay on account of library ordering

    timeNow = MS_TIMER;

    while (MS_TIMER - timeNow <= 2) {}

    BitWrPortI(PCDR, &PCDRShadow, 0, RS485_TX_ENABLE_BIT);

}

void addIntStringParameter(char **ptr, int statusCode, int value, int *spaceLeft)

{

    if (value == DEFAULT_INT) return;

    addIntString(ptr, statusCode, spaceLeft, 2);

    addIntString(ptr, value, spaceLeft, 0);

}

// Write the string representation of an integer to a char pointer.

// spaceLeft is the space left in the buffer (not counting null terminator)

// If the string-converted integer takes more space than spaceLeft, then

//   set spaceLeft to -1. (This function will do nothing when spaceLeft is < 0)

// We always append a MESSAGE_DELIMITER. When the entire message has been

//   built, the final MESSAGE_DELIMITER will be deleted.

void addIntString(char **ptr, int value, int *spaceLeft, int nDigits)

{

    char valueString[10]; // bigger than number of characters in max integer

    int max;

    int len;

    char formatString[10]; // This is a little more than needed

    memset(formatString, 0, sizeof(formatString));

    if (nDigits > 0)

    {

        if (nDigits > 6) nDigits = 6;

        sprintf(formatString, "%%0%dd", nDigits); // e.g. "%02d"

    } else

    {

        strcpy(formatString, "%d");

    }

    formatString[strlen(formatString)] = MESSAGE_DELIMITER;

    max = sizeof(valueString)-1;

    len = snprintf(valueString, max, formatString, value); // Print number followed by pipe character

    if (len <= max && len <= *spaceLeft)

    {

        *spaceLeft -= len;

        strcpy(*ptr, valueString);

        *ptr += len;

    }

    else if (len > *spaceLeft)

    {

        *spaceLeft = -1;

    }

}

/*** BeginHeader */

#endif

/*** EndHeader */