BAS_MODBUS_SLAVE.LIB

/*

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

   SATA  			   DB-9

7	GND				9

6	RS485 A 			8	RS232 CTS

5	RS485 B 			7

4	RS232 CTS   	6	RS485 B

3	RS232 RX  		5	GND

2	RS232 TX 		4

1	GND          	3  RS232 TX

						2  RS232 RX

                  1	RS485 A

*/

/*** BeginHeader

*/

#ifndef _BAS_MODBUS_SLAVE_

#define _BAS_MODBUS_SLAVE_

#define MODBUS_DEBUG debug

#define MODBUS_SLAVE_DEBUG debug

//#define MODBUS_DEBUG_PRINT debug

#define USE_MODBUS_CRC

#define MB_SLAVE_485 0

#define MB_GROUP_STATUS		0

#define MB_GROUP_ALARM  	100

#define MB_GROUP_CONFIG 	200

#define MB_GROUP_CONTROL 	300

// Controller Status List

enum

{

AUTH_INPUTS,

TURBINE_OUT,

CV_OUT,

SUMP_SENSOR,

SHUNT_VALVE,

FLOW_SWITCH,

PROD_PRES,

PLC_STATE,

GPH3_PASSED,

PASSED_02,

PASSED_01,

CURRENT_TESTS,

CURRENT_LRS,

DT_LEVEL_TC,

DT_LEVEL_TC_PRECISION,

DT_LEVEL_ACTUAL,

DT_LEVEL_DIRECTION,

DT_VOLUME_TC,

DT_VOLUME_TC_PRECISION,

DT_VOLUME_RATE,

DT_VOLUME_ACTUAL,

DT_ULLAGE,

FUEL_TEMPS,

FILTER_ACTIVE,

MOTORIZED_CV_LS_13,

MOTORIZED_CV_LS_16,

MOTORIZED_CV_LS_17,

BOILER_DISABLE,

STATUS_LEN

};

// Alarm List

enum

{

PRES_ALARMS,

GPH3FAILURES,

SENSOR_OUTS,

PRECISION_TEST_FAILURES,

LRS,

NO_FLOW_AL,

DEAD_TURBINE,

POWER_FAILURE,

RESERVED_ALARM_01,

RESERVED_ALARM_02,

FAILED_TURBINE_CV_WARNING,

GPH3FAILURES_WARNING,

SYSTEM_NOT_CONFIG,

RESERVED_WARNING_02,

DT_NO_FUEL,

DT_LOW_FUEL,

DT_OVERFILL,

ALARM_LEN

};

// Controller Config List

enum

{

UNKNOWN_LIST_1,

UNKNOWN_LIST_2,

UNKNOWN_LIST_3,

CONFIG_WRITE_CONFIRM,

CONTROL_CONFIG_LEN

};

// Control Commands

enum

{

AUTH_REQUESTS,

RESET_ALL_CHANNELS,

RESET_CHANNEL,

PRECISION_TEST_01,

PRECISION_TEST_02,

PRECISION_TEST_ABORT,

TURN_ON_OUTPUTS,

TURN_OFF_OUTPUTS,

DT_LEVEL_RAISE,

DT_LEVEL_LOWER,

DT_TOP_OFF,

ESTOP,

RESERVED_WRITE_2S,

RESERVED_WRITE_3S,

RESERVED_WRITE_4S,

CTL_WRITE_CONFIRM,

CONTROL_COMMAND_LEN

};

int BAS_SLAVE_Init();

/*** EndHeader */

/*** BeginHeader MODBUS_Serial_Init */

#define BINBUFSIZE 			127

#define BOUTBUFSIZE 			127

#define DINBUFSIZE			127

#define DOUTBUFSIZE			127

#define RS485_TX_ENABLE_BIT 2

#define MODBUS_COMM_TO		60

extern int Serial_timeout;

int MODBUS_Serial_Init(void);

#if MB_SLAVE_485

	void ser485Tx(void);

	void ser485Rx(void);

#endif

void 			 SetStatusReg(int idx, int prod, int ch, int val);

unsigned int GetStatusReg(int idx, int prod);

void 			 SetAlarmReg(int idx, int prod, int ch, int val);

unsigned int GetAlarmReg(int idx, int prod);

void 			 SetConfigReg(int idx, int prod, int val);

unsigned int GetConfigReg(int idx, int prod);

void 			 SetRdControlReg(int idx, int prod, int val);

unsigned int GetRdControlReg(int idx, int prod);

void 			 SetWrControlReg(int idx, int prod, int val);

unsigned int GetWrControlReg(int idx, int prod);

/*** EndHeader */

/*** BeginHeader

BAS_SLAVE_Init

SetStatusReg

GetStatusReg

SetAlarmReg

GetAlarmReg

SetConfigReg

GetConfigReg

SetWrControlReg

GetWrControlReg

*/

/*** EndHeader */

//*******************************************************************************************

int MBS_Serial_timeout;

unsigned int readOnlyStatusRegs[N_ISM][STATUS_LEN];

unsigned int readOnlyAlarmRegs[N_ISM][ALARM_LEN];

unsigned int readOnlyConfigReg[N_ISM][CONTROL_CONFIG_LEN];

unsigned int readOnlyControlReg[N_ISM][CONTROL_COMMAND_LEN];

unsigned int readWriteControlReg[N_ISM][CONTROL_COMMAND_LEN];

unsigned int GetStatusReg(int idx, int prod)							{return readOnlyStatusRegs[prod][idx];}

unsigned int GetAlarmReg(int idx, int prod)							{return readOnlyAlarmRegs[prod][idx];}

void 			 SetConfigReg(int idx, int prod, int val)			   {readOnlyConfigReg[prod][idx] = val;}

unsigned int GetConfigReg(int idx, int prod)					    	{return readOnlyConfigReg[prod][idx];}

void 			 SetRdControlReg(int idx, int prod, int val)			{readOnlyControlReg[prod][idx] = val;}

unsigned int GetRdControlReg(int idx, int prod)						{return readOnlyControlReg[prod][idx];}

unsigned int GetWrControlReg(int idx, int prod)						{return readWriteControlReg[prod][idx];}

void SetStatusReg(int idx, int prod, int ch, int val)

{

	if (idx == AUTH_INPUTS ||

       idx == SUMP_SENSOR ||

       idx == SHUNT_VALVE ||

       idx == FLOW_SWITCH)

	{

   	if (val)

   		readOnlyStatusRegs[prod][idx] |= BitToMask(ch);

      else

      	readOnlyStatusRegs[prod][idx] &= ~BitToMask(ch);

   }

   else if (idx == GPH3_PASSED ||

   			idx == PASSED_02 ||

   			idx == PASSED_01)

   {

   	if (val)

      	readOnlyStatusRegs[prod][idx]++;

   }

   else

		readOnlyStatusRegs[prod][idx] = val;

}

void SetAlarmReg(int idx, int prod, int ch, int val)

{

	if (idx == PRES_ALARMS ||

       idx == GPH3FAILURES ||

       idx == SENSOR_OUTS ||

       idx == PRECISION_TEST_FAILURES ||

       idx == NO_FLOW_AL ||

       idx == DEAD_TURBINE ||

       idx == FAILED_TURBINE_CV_WARNING ||

       idx == GPH3FAILURES_WARNING)

   {

      if (val)

   		readOnlyAlarmRegs[prod][idx] |= BitToMask(ch);

      else

      	readOnlyAlarmRegs[prod][idx] &= ~BitToMask(ch);

   }

   else

		readOnlyAlarmRegs[prod][idx] = val;

}

void SetWrControlReg(int idx, int prod, int val)

{

	if (idx == RESET_ALL_CHANNELS ||

       idx == RESET_CHANNEL ||

       idx == PRECISION_TEST_01 ||

       idx == PRECISION_TEST_02 ||

       idx == PRECISION_TEST_ABORT ||

       idx == DT_TOP_OFF)

	{

   	if (val > readOnlyControlReg[prod][idx])

			readWriteControlReg[prod][idx] = 1;

      else

      	readWriteControlReg[prod][idx] = 0;

	}

   else if (idx == CTL_WRITE_CONFIRM)

   {

   	readWriteControlReg[0][idx]++;

   }

   else

   	readWriteControlReg[prod][idx] = val;

}

// *****************************************************************************************************

int BAS_SLAVE_Init()

{

	int result;

   result = 0;

   memset(readOnlyStatusRegs, 0, sizeof(readOnlyStatusRegs));

   memset(readOnlyAlarmRegs, 0, sizeof(readOnlyAlarmRegs));

   memset(readOnlyConfigReg, 0, sizeof(readOnlyConfigReg));

   memset(readOnlyControlReg, 0, sizeof(readOnlyControlReg));

   memset(readWriteControlReg, 0, sizeof(readWriteControlReg));

	MODBUS_Serial_Init();

   Config.ModBus.ActivityTimer = 0;

   return result;

}

#if MB_SLAVE_485

	void ser485Tx() {BitWrPortI(PCDR, &PCDRShadow, 1, RS485_TX_ENABLE_BIT);}

	void ser485Rx() {BitWrPortI(PCDR, &PCDRShadow, 0, RS485_TX_ENABLE_BIT);}

#endif

MODBUS_SLAVE_DEBUG

int MODBUS_Serial_Init ( void )

{	auto float timeout;

	char dummy;

   unsigned long nowtime;

	timeout = 5*11*1000.0/(float)BaudRate[Config.ModBus.Baudidx]; // time for 5 bytes in msec

   MBS_Serial_timeout = (int)(timeout+.5);	// convert to integer

   if ( MBS_Serial_timeout < 2 ) Serial_timeout = 2; // insure minimum delay

   #if MB_SLAVE_485

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

	   //  as Serial Port TxD outupt

	   WrPortI (SDCR, &SDCRShadow, 0x00);    // Configure Rort C bit 1

	   // to use Serial Port RxD for serial input,

	   // async mode, 8 bits, no interrupt

      serDopen(BaudRate[Config.ModBus.Baudidx]);

      printf("Modbus Slave - RS-485\n");

   #else

      BitWrPortI (PDFR, &PDFRShadow, 1, 4); // Configure Port D bit 4

      // as Serial Port ATxB for serial output

      WrPortI (SBCR, &SBCRShadow, 0x10);    // Configure Port D bit 5

	   // to use Serial Port ARxB for serial input

	   // async mode, 8 bits, no interrupt

      serBopen(BaudRate[Config.ModBus.Baudidx]);

   #endif

   #if MB_SLAVE_485

	   ser485Rx();                         // disable the RS485 transmitter

	   serDrdFlush();                      // clear the read FIFO

      while (serDrdUsed() > 0)

   	{

   		serDread(&dummy, 1, 100);

      	nowtime =MS_TIMER;

      	while (MS_TIMER - nowtime < 10) {}

   	}

	#else

      serBrdFlush();                      // clear the read FIFO

      while (serBrdUsed() > 0)

   	{

   		serBread(&dummy, 1, 100);

      	nowtime =MS_TIMER;

      	while (MS_TIMER - nowtime < 10) {}

   	}

   #endif

	MODBUS_flags0 = 0;						// initialize special flags

	return MB_SUCCESS;

} // MODBUS_Serial_Init

/* START FUNCTION DESCRIPTION ********************************************

MODBUS_Serial_Tx			<Modbus_Slave_BL26xx.lib>

SYNTAX:			int MODBUS_Serial_Tx ( char *Packet, int ByteCount );

DESCRIPTION:	Transmit a Modbus packet to a "downstream" device.

					Calculate the CRC and append to the packet.

PARAMETER1:		address of packet - must have two byte pad at end for

					inclusion of CRC word

PARAMETER2:		number of bytes in the packet

RETURN VALUE:	MB_SUCCESS

END DESCRIPTION **********************************************************/

/*** BeginHeader MODBUS_Slave_Serial_Tx */

int MODBUS_Slave_Serial_Tx ( char *Packet, int ByteCount );

/*** EndHeader */

MODBUS_SLAVE_DEBUG

int MODBUS_Slave_Serial_Tx ( char *Packet, int ByteCount )

{	auto int CalcCRC,i;

	Ms txTimeout;

// insert CRC

#ifndef USE_MODBUS_CRC

	CalcCRC = getcrc ( Packet, ByteCount, 0xFFFF );

#else

	CalcCRC = MODBUS_SLAVE_CRC(Packet, ByteCount);

#endif

// Backwards for some reason...

	Packet[ByteCount+1] = CalcCRC;			// store low byte

   Packet[ByteCount] = CalcCRC>>8;	// store high byte

	ByteCount+=2;								// adjust for CRC

#if MODBUS_SLAVE_DEBUG_PRINT & 0x800

	printf ( "Ser Tx:" );

	for ( i=0; i<ByteCount; i++ ) printf ( " %02X", Packet[i] );

	printf ( "\n\r" );

#endif

   #if MB_SLAVE_485

	   ser485Tx();                         // enable the RS485 transmitter

	   serDrdFlush();                      // clear the read FIFO

	   serDwrite ( Packet, ByteCount );    // send the data

	   // This stall if asking for to many points

	   txTimeout = MS_TIMER;

	 	while ( serDrdUsed() != ByteCount && MS_TIMER < txTimeout + 250); // wait for all bytes to be transmitted

	   ser485Rx();                         // disable the RS485 transmitter

	   serDrdFlush();                      // clear the read FIFO

	   return MB_SUCCESS;                  // show success

   #else

	   serBrdFlush();                      // clear the read FIFO

	   serBwrite ( Packet, ByteCount );    // send the data

	   // This stall if asking for to many points

	   txTimeout = MS_TIMER;

	 	while ( serBrdUsed() != ByteCount && MS_TIMER < txTimeout + 250); // wait for all bytes to be transmitted

	   serBrdFlush();                      // clear the read FIFO

	   return MB_SUCCESS;                  // show success

    #endif

} // MODBUS_Serial_Tx

/* START FUNCTION DESCRIPTION *********************************************

MODBUS_Serial_Rx			<Modbus_Slave_BL26xx.lib>

DESCRIPTION:	Receive the response from the Modbus Slave

					Uses the global variable Serial_timeout

					It is the responsibility of the caller to handle

					a timeout if required.

PARAMETER1:		address to put the data

RETURN VALUE:	0 = no message

					+n = number of bytes with valid CRC

               MB_CRC_ERROR = invalid CRC

END DESCRIPTION **********************************************************/

/*** BeginHeader MODBUS_Slave_Serial_Rx */

int MODBUS_Slave_Serial_Rx ( char * DataAddress );

/*** EndHeader */

MODBUS_SLAVE_DEBUG

int MODBUS_Slave_Serial_Rx ( char * DataAddress )

{	auto int RxCRC, CalcCRC;

	auto int ByteCount,i, reg, p1;

   auto int backwards;

   #if MB_SLAVE_485

		ByteCount = serDread( DataAddress, 100, Serial_timeout );

   #else

      ByteCount = serBread( DataAddress, 100, Serial_timeout );

   #endif

   if ( ByteCount )

   {

	#if MODBUS_SLAVE_DEBUG_PRINT & 0x800

		printf ( "\n\rSer Rx:" );

		for ( i=0; i<ByteCount; i++ ) printf ( " %02X", DataAddress[i] );

	#endif

   	ByteCount -= 2;						// adjust for CRC

	#ifndef USE_MODBUS_CRC

		CalcCRC = getcrc ( DataAddress, ByteCount, 0xFFFF );

	#else

		CalcCRC = MODBUS_SLAVE_CRC(DataAddress, ByteCount);

	#endif

   // Why does the modbus master emulator create crc backwards?

   /*

   backwards = CalcCRC & 0xff;

   CalcCRC = (CalcCRC & 0xff00) >> 8;

	CalcCRC |= backwards << 8;

   */

   #if MODBUS_SLAVE_DEBUG_PRINT & 0x400

   	reg = DataAddress[2];

      reg = (reg<<8) + (int)DataAddress[3];

		p1 = DataAddress[4];

      p1 = (p1<<8) + (int)DataAddress[5];

		printf ( "Ser Rx: Addr=%d Function=%2.2X Reg=%4d P1=%4d\n\r",

      	DataAddress[0], DataAddress[1], reg, p1 );

	#endif

		RxCRC = DataAddress[ByteCount+1] & 0x00FF; // LSByte

   	i = DataAddress[ByteCount]<<8;	// MSByte

   	RxCRC = RxCRC | ( i & 0xFF00 );	// MSbyte

	#if MODBUS_SLAVE_DEBUG_PRINT & 0x800

   	printf ( "  Calc CRC=%04X   Rcvd CRC=%04X\n\r", CalcCRC, RxCRC );

	#endif

	   if ( CalcCRC != RxCRC ) ByteCount = MB_CRC_ERROR;

   }

   return ByteCount;

} // MODBUS_Serial_Rx

/* START FUNCTION DESCRIPTION *****************************************

mbsDigOutRd

ModBus function code = 0x01

SYNTAX: 			int mbsDigOutRd ( unsigned OutputNbr, int *pnState )

DESCRIPTION:	read the specified output.  This is slightly different

					than mbDigIn in that this function returns a '1' if the

               output is on (low).  It essentially returns the opposite

               of the mbDigIn function.

PARAMETER1:		output number: 0..15

PARAMETER2:		pointer to destination variable

RETURN VALUE:	MB_SUCCESS = success

					MB_BADADDR = illegal channel

               MB_BADDATA = illegal data value

               MB_DEVNOTSET = I/O not set as output

END DESCRIPTION ******************************************************/

/*** BeginHeader mbsDigOutRd */

int mbsDigOutRd ( unsigned OutputNbr, int *pnState );

/*** EndHeader */

MODBUS_SLAVE_DEBUG

int mbsDigOutRd ( unsigned OutputNbr, int *pnState )

{

/*	if ( OutputNbr > 15 ) return MB_BADADDR;

	//if( __brdInitFlag == FALSE ) return MB_DEVNOTSET;

	//*pnState = 1-digIn ( OutputNbr );

   */

	return MB_SUCCESS;

} // mbsDigOutRd

/* START FUNCTION DESCRIPTION *****************************************

mbsDigIn

ModBus function code = 0x02

SYNTAX:			int mbsDigIn ( unsigned InputNbr, int *pnState )

DESCRIPTION:	read the specified input

PARAMETER1:		input number: 0..31

						Inputs 0..15 are the DIO signals

                  Inputs 16..31 are DIN16..31

PARAMETER2:		pointer to destination variable

						a '1' is returned if the input is high

RETURN VALUE:	MB_SUCCESS = success

					MB_BADADDR = illegal channel

               MB_BADDATA = illegal data value

               MB_DEVNOTSET = I/O not set as output

END DESCRIPTION ******************************************************/

/*** BeginHeader mbsDigIn */

int mbsDigIn ( unsigned InputNbr, int *pnState );

/*** EndHeader */

MODBUS_SLAVE_DEBUG

int mbsDigIn ( unsigned InputNbr, int *pnState )

{

/*	if ( InputNbr > 31 ) return MB_BADADDR;

	if( __brdInitFlag == FALSE ) return MB_DEVNOTSET;

	*pnState = digIn ( InputNbr );

   */

	return MB_SUCCESS;

} // mbsDigIn

/* START FUNCTION DESCRIPTION *****************************************

mbsRegOutRd

ModBus function code = 0x03

SYNTAX:			int mbsRegOutRd ( unsigned OutRegNbr, unsigned *pwValue )

DESCRIPTION:	read an 8 bit output register

PARAMETER1:		register number

						0 = DIO 0..7		read state of pins and invert (0V = 1)

                  1 = DIO 8..15		read state of pins and invert (0V = 1)

                  2 = HOUT 0..3		return state of shadow register

               Special Registers:

               	see mbsRegIn

PARAMETER2:		pointer to destination variable

						for each bit: 0 = output is off, 1 = output is on

RETURN VALUE:	MB_SUCCESS = success

					MB_BADADDR = illegal channel

               MB_BADDATA = illegal data value

               MB_DEVNOTSET = I/O not set as output

END DESCRIPTION ******************************************************/

/*** BeginHeader mbsRegOutRd */

int mbsRegOutRd ( unsigned OutRegNbr, unsigned *pwValue );

/*** EndHeader */

MODBUS_SLAVE_DEBUG

int mbsRegOutRd ( unsigned OutRegNbr, unsigned *pwValue )

{	auto int n;

   int MBProd;

	//if( __brdInitFlag == FALSE ) return MB_DEVNOTSET;

   // OutRegNbr = OutRegNbr - Offset[Config.ModBus.Offsetidx] - Config.ModBus.Address*1000;

   OutRegNbr = OutRegNbr - Offset[Config.ModBus.Offsetidx];  	// Remove offset

   MBProd = (int)(OutRegNbr / 1000);                                  // Calc Product / Tank number

   OutRegNbr = OutRegNbr - MBProd * 1000;                      // Remove Product number

   if (OutRegNbr >= MB_GROUP_STATUS && OutRegNbr < STATUS_LEN)

   {

   	*pwValue = GetStatusReg(OutRegNbr, MBProd);

      return MB_SUCCESS;

   }

   else if (OutRegNbr >= MB_GROUP_ALARM && OutRegNbr < MB_GROUP_ALARM+ALARM_LEN)

   {

   	*pwValue = GetAlarmReg(OutRegNbr - MB_GROUP_ALARM, MBProd);

      return MB_SUCCESS;

   }

   else if (OutRegNbr >= MB_GROUP_CONFIG && OutRegNbr < MB_GROUP_CONFIG+CONTROL_CONFIG_LEN)

   {

   	*pwValue = GetConfigReg(OutRegNbr - MB_GROUP_CONFIG, MBProd);

      return MB_SUCCESS;

   }

   else if (OutRegNbr >= MB_GROUP_CONTROL && OutRegNbr < MB_GROUP_CONTROL+CONTROL_COMMAND_LEN)

   {

   	*pwValue = GetRdControlReg(OutRegNbr - MB_GROUP_CONTROL, MBProd);

      return MB_SUCCESS;

   }

   return MB_BADADDR;

} // mbsRegOutRd

/* START FUNCTION DESCRIPTION *****************************************

mbsRegIn						<Modbus_Slave_BL26xx.LIB>

NOTE: Modbus_Slave_BL26xx.LIB functions are generally not reentrant.

ModBus function code = 0x04

SYNTAX: 			int mbsRegIn ( unsigned InRegNbr, unsigned *pwValue )

DESCRIPTION:	read an input register: read state of pins (0V = 0)

PARAMETER1:		register number

						0 = DIO 0..7

                  1 = DIO 8..15

						2 = IN16 - IN23

						3 = IN24 - IN31

               Special Registers:

               	1000 = DIO 0..15 configuration - see digOutConfig

                  1001 = HOUT 0..3 configuration - see digHoutConfig

						3nnx = Analog Input where nn = A/D channel

                  	3nn0, 3nn1 = floating point volts

                     3nn2 = integer millivolts

                     3003 = integer raw value

                  note: see mbsRegOut for gain code storage

PARAMETER2:		pointer to destination variable

RETURN VALUE:	MB_SUCCESS = success

					MB_BADADDR = illegal channel

               MB_BADDATA = illegal data value

               MB_DEVNOTSET = I/O not set as output

END DESCRIPTION ******************************************************/

/*** BeginHeader mbsRegIn */

int mbsRegIn ( unsigned InRegNbr, unsigned *pwValue );

/*** EndHeader */

MODBUS_SLAVE_DEBUG

int mbsRegIn ( unsigned InRegNbr, unsigned *pwValue )

{	auto int channel;

	//if( __brdInitFlag == FALSE ) return MB_DEVNOTSET;

	return MB_SUCCESS;

} // mbsRegIn

/* START FUNCTION DESCRIPTION ********************************************

mbsDigOut						<Modbus_Slave_BL26xx.LIB>

NOTE: Modbus_Slave_BL26xx.LIB functions are generally not reentrant.

MODBUS command = 0x05, 0x0F

SYNTAX:     	int mbsdigOut ( unsigned OutputNbr, int state );

DESCRIPTION:	turn the specified output on or off

PARAMETER1:		output channel number

						0 <= channel <= 15: DIO.00DIO.15

						16 <= channel <= 19: Hout0-Hout3 (High-Current)

PARAMETER2:		output state

						0 = turn output off

						1 = turn output on

							0 <= channel <= 15

   	      	     		Connects the load to GND

							16 <= channel <= 19

		            	   Sinking:	Connects the load to GND

								Sourcing: Connects the load to +V

RETURN VALUE:	MB_SUCCESS = success

					MB_BADADDR = illegal channel

               MB_BADDATA = illegal data value

               MB_DEVNOTSET = I/O not set as output

SEE ALSO: 		brdInit, digOutConfig

END DESCRIPTION **********************************************************/

/*** BeginHeader mbsDigOut */

int mbsDigOut ( unsigned OutputNbr, int state );

/*** EndHeader */

MODBUS_SLAVE_DEBUG

int mbsDigOut ( unsigned OutputNbr, int state )

{

	if ( OutputNbr > 19 ) return MB_BADADDR;

//	if( __brdInitFlag == FALSE ) return MB_DEVNOTSET;

   return MB_SUCCESS;

} // mbsDigOut

/* START FUNCTION DESCRIPTION *****************************************

mbsRegOut

ModBus function codes = 0x06, 0x10, 0x16 and 0x17,

SYNTAX: 			int mbsRegOut ( unsigned OutRegNbr, unsigned wValue )

DESCRIPTION: 	write to an I/O register

PARAMETER1:		register number

						0 = DIO 0..7

                  1 = DIO 8..15

                  2 = HOUT 0..3

               Special Registers:

               	1000 = DIO 0..15 configuration - see digOutConfig

                  1001 = HOUT 0..3 configuration - see digHoutConfig

                  2nnx = Analog Output where nn = D/A nbr

                  	2nn0, 2nn1 = floating point volts: see anaOutVolts

                     2nn2 = integer millivolts: uses anaOutVolts

                     2nn3 = integer raw value: see anaOut

                     2nn9 = turn on D/A power: see anaOutPwr

						3nnx = Analog Input where nn = A/D channel

							3nn8 = integer operating mode: see anaInConfig

                     			nn = channel pair: 0..3

                     3nn9 = integer range code used for mbsRegIn: 0..7

                  1999 = misc. configuration bits

PARAMETER2:		register value (each bit) for DIO 0..15

						0 = turn output off

                  1 = turn output on

               register values for HOUT 0..3 (4 bits per output)

               		HOUT 0 = bits 0..3, ...

               	0 = both transistors off = Tri-State

                  1 = source (upper transistor on)

                  2 = sink (lower transistor on)

                  rest = illegal

RETURN VALUE:	MB_SUCCESS = success

					MB_BADADDR = illegal channel

               MB_BADDATA = illegal data value

               MB_DEVNOTSET = I/O not set as output

END DESCRIPTION ******************************************************/

/*** BeginHeader mbsRegOut */

int mbsRegOut ( unsigned OutRegNbr, unsigned wValue );

int anaInConfigVal[4];

/*** EndHeader */

// Write Single Register

MODBUS_SLAVE_DEBUG

int mbsRegOut ( unsigned OutRegNbr, unsigned wValue )

{

	int MBProd;

	//	if( __brdInitFlag == FALSE ) return MB_DEVNOTSET;

	OutRegNbr = OutRegNbr - Offset[Config.ModBus.Offsetidx];    // Remove Offset

   MBProd = (int)(OutRegNbr / 1000);                                  // Calc Product / Tank number

   OutRegNbr = OutRegNbr - MBProd * 1000;                      // Remove Product number

   if (OutRegNbr >= MB_GROUP_CONFIG && OutRegNbr < MB_GROUP_CONFIG+CONTROL_CONFIG_LEN)

   {

   	if (wValue != GetConfigReg(OutRegNbr - MB_GROUP_CONFIG, MBProd))

      {

   		SetConfigReg(OutRegNbr - MB_GROUP_CONFIG, MBProd, wValue);

         readOnlyConfigReg[0][CONFIG_WRITE_CONFIRM]++;

      }

      return MB_SUCCESS;

   }

   else if (OutRegNbr >= MB_GROUP_CONTROL && OutRegNbr < MB_GROUP_CONTROL+CONTROL_COMMAND_LEN)

   {

      if (wValue != GetRdControlReg(OutRegNbr - MB_GROUP_CONTROL, MBProd))

   	{

         SetWrControlReg(OutRegNbr - MB_GROUP_CONTROL, MBProd, wValue);

   		SetRdControlReg(OutRegNbr - MB_GROUP_CONTROL, MBProd, wValue);

         readOnlyControlReg[0][CTL_WRITE_CONFIRM]++;

      }

      return MB_SUCCESS;

   }

   return MB_BADADDR;

} // mbsRegOut

/*** BeginHeader mbsStart, mbsDone */

int mbsStart();

int mbsDone();

/*** EndHeader */

int mbsStart() {return MB_SUCCESS;}

int mbsDone () {return MB_SUCCESS;}

/*** BeginHeader

*/

/*** EndHeader */

/*** BeginHeader */

#endif

/*** EndHeader */