www.pudn.com > mod_rssim6.zip > message.cpp
/////////////////////////////////////////////////////////////////////////////
//
// FILE: Message.cpp : file
//
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "mod_rssimDlg.h"
#include "abcommsprocessor.h"
#include "message.h"
// English meanings for Allen-Bradley (Exception) error codes
PCHAR plcErrorLocal[9] = // local STS (low nibble)
{
"No error", // 0x0
"DST node out of buffer space", // 0x1
"Cannot guarantee delivery", // 0x2
"Duplicate token holder detected", // 0x3
"Local port is disconnected", // 0x4
"Application layer timed out waiting for response", // 0x5
"Duplicate node detected", // 0x6
"Station is offline", // 0x7
"Hardware fault" // 0x8
};
PCHAR plcErrorRemote[16] = // remote STS (high nibble)
{
"No error", // 0x00
"Illegal command or format", // 0x10
"Host has a problem and will not comm.", // 0x20
"Remote node host is missing,", // 0x30
"Host could not complete function due to h/w fault", // 0x40
"Addressing problem or memory protect rungs", // 0x50
"Function not allowed due to command protection selection", // 0x60
"Processor is in program mode", // 0x70
"Compatibility mode file missing or comm. zone problem", // 0x80
"Remote node cannot buffer command", // 0x90
"xxxx", // 0xA0
"Remote node problem due to download", // 0xB0
"xxxx", // 0xC0
"unused", // 0xD0
"unused", // 0xE0
"Error code is in EXT-STS" // 0xF0
};
// Global - Global data
BYTE txDLE_STX[SIZEOF_TAIL] =
{
ALLENBRADLEY_DLE,
ALLENBRADLEY_STX
};
BYTE txDLE_ACK[SIZEOF_TAIL] =
{
ALLENBRADLEY_DLE,
ALLENBRADLEY_ACK
};
BYTE txDLE_NAK[SIZEOF_TAIL] =
{
ALLENBRADLEY_DLE,
ALLENBRADLEY_NAK
};
BYTE txDLE_ETX[SIZEOF_TAIL] =
{
ALLENBRADLEY_DLE,
ALLENBRADLEY_ETX
};
BYTE txDLE_ENQ[SIZEOF_TAIL] =
{
ALLENBRADLEY_DLE,
ALLENBRADLEY_ENQ
};
// -------------------------------- CalcBCC ----------------------------
// Calculate Allen-Bradley specified BCC code
// the BCC is a 2'scomp sum of all bytes in the message frame excluding DLE-STX and DLE-ETX
BYTE CalcBCC(BYTE * lrcBuffPtr, // -> pointer to buffer at start of BCC
DWORD buffLen // ->
)
{
BYTE bcc=0;
CalcLRC(lrcBuffPtr, // -> pointer to buffer at start of LRC
buffLen, // ->
FALSE, // -> Calc 2's Compliment also (last call)
&bcc // <->
);
bcc = 256-bcc;
return(bcc);
} // CalcBCC
/////////////////////////////////////////////////////////////////////////////////
// CProtocolMessage implementation
/////////////////////////////////////////////////////////////////////////////////
CProtocolMessage::CProtocolMessage(const BYTE * pMessageRX, DWORD len)
{
}
CProtocolMessage::CProtocolMessage(const CProtocolMessage & oldProtMessage)
{ //copy constructor
}
/////////////////////////////////////////////////////////////////////////////////
// CABMessage implementation
/////////////////////////////////////////////////////////////////////////////////
// ----------------------- constructor -----------------------------------
CABMessage::CABMessage(const BYTE * pMessageRX, DWORD len, BOOL dataLayer)
: CProtocolMessage(pMessageRX, len)
{
BYTE *crcStartPtr = (BYTE*)pMessageRX;
WORD crc = 0;
BYTE bcc;
WORD *crcPtr;
WORD *bccPtr;
DWORD appStartOffset = 2; // data layer telegram
DWORD addressWidth, elementWidth;
transactionID = -1;
transmissionStatus = 0;
transmissionStatusEXT = 0;
if (!dataLayer)
{
appStartOffset=0; // this is an app layer telegram
len+=2;
}
ASSERT(len > 2);
ASSERT(len < sizeof(buffer));
memset(buffer, 0xCD, sizeof(buffer));
memcpy(&buffer[2], &pMessageRX[appStartOffset], len);
// double DLE stripping here
if (dataLayer)
StripDLEs(buffer, &len);
totalLen = (WORD)len;
// at this point we have a data layer message
crcCheckedOK = FALSE;
// break down the msg
count = 0;
if ((len>2) && (dataLayer))
{
if (buffer[0] != ALLENBRADLEY_DLE)
return;
if ((buffer[1] != ALLENBRADLEY_SOH )&&
(buffer[1] != ALLENBRADLEY_STX )&&
(buffer[1] != ALLENBRADLEY_ACK )&&
(buffer[1] != ALLENBRADLEY_NAK )&&
(buffer[1] != ALLENBRADLEY_ENQ )
)
return;
// we seem to have the beginning of the message, parse it
}
if (len > 3)
{
stationIDDest = (BYTE)buffer[AB_SOURCEBYTEOFF]; // Dest addr
stationIDSource = (BYTE)buffer[AB_DESTINATIONBYTEOFF]; // Source addr
}
if (len >4)
command = buffer[AB_COMMANDBYTEOFF]; // may be 0x0F other values are not processed
if (len >5)
transmissionStatus = buffer[AB_STATUSBYTEOFF];
if (len >=7)
{
transactionID = (buffer[6]) + (buffer[7]<<8);
}
if (len >8)
functionCode = buffer[8];
if (len > 9)
count = (BYTE)buffer[9]; // # bytes to be read (/2 to get integers)
if (len > 10)
fileNum = (BYTE)buffer[10];
if (len >11)
fileType = (BYTE)buffer[11];
addressWidth = 1;
elementWidth = 1;
if (len >12)
{
address = (BYTE)buffer[12];
if (address == 0xFF)
{
addressWidth=3;
address = buffer[12+1] + (buffer[13+1]<<8);
address = SwapBytes(address);
}
}
if (len >=(13+addressWidth)) // 14
{
subElement = buffer[12+addressWidth];
if (subElement == 0xFF)
{
elementWidth=3;
subElement = buffer[12+addressWidth+1] + (buffer[13+addressWidth+1]<<8);
subElement = SwapBytes(subElement);
}
}
if (len >=(13+addressWidth+elementWidth)) // 15
dataPtr = (BYTE*)&buffer[12+addressWidth+elementWidth];
if (dataLayer) // app messages will not have a CRC byte anyway
{
//check the CRC at this point
if (pGlobalDialog->m_useBCC)
{
if (len >= 17)
{
bccPtr = (WORD*)&buffer[totalLen-1];//count + 16];
crcStartPtr = (BYTE*)&buffer[2];
bcc = CalcBCC(crcStartPtr, totalLen-6); // Only one buffer to calc crc of
overalLen = count+16 + AB_BCC_LEN;
crcCheckedOK = (bcc==*bccPtr);
}
}
else
{
if (len >= 18)
{
CHAR ETXBuff[2];
crcPtr = (WORD*)&buffer[totalLen-2];//count + 16];
crcStartPtr = (BYTE*)&buffer[2];
crc = 0x0;
CalcCRC(crcStartPtr, totalLen-6, &crc); // Only one buffer to calc crc of
ETXBuff[0] = 0x03;
CalcCRC((BYTE*)&ETXBuff[0], 1, &crc); // include the ETX
overalLen = count+16 + AB_CRC_LEN;
crcCheckedOK = (crc==*crcPtr);
}
}
}
if (!crcCheckedOK)
return;
else
{
crc = 0xffff;
}
} // CABMessage
// --------------------------- CABMessage --------------------------
// PURPOSE: copy constructor used to build responses, does not actually
// copy the message.
CABMessage::CABMessage(const CABMessage & oldABMessage)
: CProtocolMessage(oldABMessage)
{
memset(buffer, 0xCD, sizeof(buffer));
//Copy in common stuff from both messages here!
m_localStationID = oldABMessage.m_localStationID;
stationIDSource = oldABMessage.stationIDSource;
stationIDDest = oldABMessage.stationIDDest;
functionCode = oldABMessage.functionCode;
fileType = oldABMessage.fileType;
address = oldABMessage.address; // where to copy data from
byteCount = oldABMessage.byteCount; // length of data to copy
overalLen = 0; //New message so 0 for now!
dataPtr = (BYTE*)buffer; //Nice a fresh pointer to the beginning!
}
// ------------------------- CalculateReadAheadLength -------------------------
// static function
WORD CABMessage::CalculateReadAheadLength(const BYTE*pBuffer, DWORD length)
{
//if (length < 2)
// return(2); // DLE ACK/NAK or DLE/STX in our case
// look at the rest of the telegram
return(1);
} // CalculateReadAheadLength
// -------------------------------- Status ----------------------------
// static function
BOOL CABMessage::Status(const BYTE*pBuffer, DWORD length)
{
if (length >6)
return(pBuffer[5]); // STS byte
return(FALSE);
} // CalculateReadAheadLength
// ------------------------------- GetValue -------------------------
//
WORD CABMessage::GetValue(WORD wIndex)
{
WORD *pData = (WORD*)dataPtr;
pData+=wIndex;
return(*pData);
}
// ------------------------------- StripDLEs ------------------------
LONG CProtocolMessage::StripDLEs(CHAR *bufferPtr, DWORD *numBytes)
{
char *pSourceData= bufferPtr;
char *pDestData = bufferPtr;
BOOL stripDLE = FALSE;
int count = *numBytes;
int bytesXferred=0;
int dleCount = 0;
//if (*numBytes <= 20)
return(0);
while (count>0)
{
if (*pSourceData == 0x10) // if current byte is a DLE
stripDLE = TRUE; // flag that byte was a DLE
else
stripDLE = FALSE;
// copy current byte
*pDestData++ = *pSourceData++;
bytesXferred++;
if ((stripDLE)&&(*pSourceData == 0x10))
{
*pSourceData++; // skip the byte and clear the flag
dleCount++;
count--;
stripDLE = FALSE;
}
count--;
}
*numBytes = bytesXferred;
return(dleCount);
}
// ------------------------------ BuildMessagePreamble -------------------------
// PURPOSE: Builds the STN,FN and LEN bytes of the telegram.
// on completion dataPtr pointsto where the data must be packed in (if any)
CHAR * CABMessage::BuildMessagePreamble(BOOL error, WORD errorCode)
{
WORD crc = 0;
WORD dataLength=6;
// swap the station IDs
buffer[2] = stationIDSource;
buffer[3] = stationIDDest;
//
buffer[AB_COMMANDBYTEOFF] |= 0x40; // CMD byte
buffer[5] = (BYTE)errorCode; // STS byte
if (error)
{
buffer[8] = (BYTE)(errorCode>>8); //EXT-STS
dataLength++;
}
// byte 6 & 7 contain the sender's TNS value
byteCount = 0;
totalLen = dataLength + 6;//13; 6+6=12 bytes
return(buffer);
} // BuildMessagePreamble
/*
// ------------------------------ BuildMessageEnd -------------------------------
// PURPOSE: glue a CRC onto the end of the message
// totalLen must be = the full telegram length (+CRC) when this is called.
CHAR * CABMessage::BuildMessageEnd()
{
WORD length;
BYTE *pCrcStart = (BYTE*)buffer;
WORD crc = 0xFFFF;
BYTE *crcPtr;
// Add the CRC bytes
length = totalLen - AB_CRC_LEN; //calc the CRC of all bytes but the 2 CRC bytes
CalcCRC(pCrcStart, length, &crc);
crcPtr = (BYTE*)&buffer[length];
*(WORD *)crcPtr = crc;
return (buffer);
} // BuildMessageEnd
*/
// ------------------------------ GetAddressArea --------------------
// Returns: A supported MEM area index for any MOD address class
// Parameter: A modbus command (e.g. 3 =read holding register)
//
WORD CABMessage::GetAddressArea(WORD classCode // modbus command byte
)
{
/*
switch(classCode)
{
// read commands
case MOD_READ_COILS : return(0); break;
case MOD_READ_DIGITALS : return(1); break;
case MOD_READ_REGISTERS : return(2); break;
case MOD_READ_HOLDING : return(3); break;
case MOD_READ_EXTENDED : return(4); break;
// write commands
case MOD_WRITE_HOLDING : return(3); break;
case MOD_WRITE_SINGLEHOLDING : return(3); break;
case MOD_WRITE_SINGLE_COIL : return(0); break;
case MOD_WRITE_MULTIPLE_COILS : return(0); break;
case MOD_WRITE_EXTENDED : return(4); break;
}
*/
return(3); //Default here for now, Should never get here anyways!
} // GetAddressArea