www.pudn.com > mod_rssim6.zip > PLCApplication.cpp
/////////////////////////////////////////////////////////////////////////////
//
// FILE: PLCApplication.cpp : implementation file
//
// See "_README.CPP"
//
// implementation of the CPLCApplication class.
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "mod_RSsimdlg.h"
#include "message.h"
#include "ABCommsProcessor.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// CPLCApplication IMPLEMENTATION
//
IMPLEMENT_DYNAMIC( CPLCApplication, CABCommsProcessor);
CPLCApplication::CPLCApplication(LPCTSTR portNameShort,
DWORD baud,
DWORD byteSize,
DWORD parity,
DWORD stopBits,
DWORD rts,
int responseDelay,
BOOL MOSCADchecks,
BOOL modifyThenRespond,
BOOL disableWrites,
BOOL bcc
)
: CABCommsProcessor(portNameShort,
baud,
byteSize,
parity,
stopBits,
rts,
responseDelay,
bcc
)
{
m_TNS = 0;
}
// ------------------------------- SendPLCMessage --------------------------------------
// pAppLayerMsg = buffer pointig to start of the app layer (stationID)
// length = length of the app layer only (before DLE expansion)
//
BOOL CPLCApplication::SendPLCMessage(const BYTE* pAppLayerMsg, DWORD length) // if False, then re-send
{
// call base class
return(CABCommsProcessor::SendPLCMessage(pAppLayerMsg, length));
}
// ----------------------------- SendPLCBlock -------------------------------------
BOOL CPLCApplication::FetchPLCBlock(BYTE sourceStationID,
BYTE destStationID,
WORD TNS,
WORD fileNum,
WORD startRegister,
WORD numRegisters)
{
CString info;
BYTE appMessage[MAX_AB_MESSAGELEN];
BYTE *pHeadderPtr; // work pointer in the headder
DWORD lengthAppMsg=0;
BOOL sendOK;
// Do BASIC range checking
if (numRegisters>234)
return(FALSE);
info.Format("MASTER- Initiate %02X to %02X, READ file %d, registers %d to %d (trans=%04X)",
sourceStationID, destStationID,
fileNum, startRegister, startRegister+ numRegisters, TNS);
RSDataMessage(info);
appMessage[AB_SOURCEBYTEOFF] = sourceStationID;
appMessage[AB_DESTINATIONBYTEOFF] = destStationID;
appMessage[AB_COMMANDBYTEOFF] = ALLENBRADLEY_SLC_CMD; // 0x0F
appMessage[AB_STATUSBYTEOFF] = AB_STS_NOERROR; // 0x00
*(WORD*)&appMessage[AB_TNSBYTEOFF] = TNS;
appMessage[AB_FUNCBYTEOFF] = ALLENBRADLEY_WORD_READ; // 0xA2
// build the rest of the headder
pHeadderPtr = &appMessage[AB_FUNCBYTEOFF+1];
*pHeadderPtr++ = 2*numRegisters; // # bytes to send in the frame
*pHeadderPtr = (BYTE)fileNum;
if (fileNum > 254)
{
*pHeadderPtr++ = 0xFF;
*(WORD*)pHeadderPtr = fileNum;
pHeadderPtr++;
}
pHeadderPtr++;
*pHeadderPtr++ = 0x89; // always INTEGER file
// element#
*pHeadderPtr = (BYTE)startRegister;
if (startRegister > 254)
{
*pHeadderPtr++ = 0xFF;
*(WORD*)pHeadderPtr = startRegister;
pHeadderPtr++;
}
pHeadderPtr++;
// sub-element is always 0
*pHeadderPtr++ = 0x00;
lengthAppMsg = (LONG)pHeadderPtr - (LONG)appMessage; // message pre-amble including STX
//
lengthAppMsg -= 2; // substract the STX
sendOK = SendPLCMessage(&appMessage[2], lengthAppMsg);
// await the response ACK and frame
m_masterWaiting = TRUE;
SetEngineState(ENG_STATE_RECEIVE); // await a read-response
return(sendOK);
}
// ----------------------------- SendPLCBlock -------------------------------------
BOOL CPLCApplication::SendPLCBlock(BYTE sourceStationID,
BYTE destStationID,
WORD TNS,
WORD fileNum,
WORD startRegister,
WORD numRegisters)
{
BYTE appMessage[MAX_AB_MESSAGELEN];
DWORD lengthAppMsg=0;
BYTE *pHeadderPtr; // work pointer in the headder
WORD *pwDataStart;
CString info;
BOOL sendOK;
// Do BASIC range checking
if (numRegisters>234)
return(FALSE);
// initiate a WRITE message to the required PLC, pack in the data and TNS field specified
// use SendPLCMessage() to fire it off, then we will just wait for and do nothing with the response in
// OnMessageReceived() which fires once the PLC responds to us.
info.Format("MASTER- initiate %02X to %02X, SEND file %d, registers %d to %d (trans=%04X)",
sourceStationID, destStationID,
fileNum, startRegister, startRegister+ numRegisters, TNS);
RSDataMessage(info);
//
appMessage[AB_SOURCEBYTEOFF] = sourceStationID;
appMessage[AB_DESTINATIONBYTEOFF] = destStationID;
appMessage[AB_COMMANDBYTEOFF] = ALLENBRADLEY_SLC_CMD; // 0x0F
appMessage[AB_STATUSBYTEOFF] = AB_STS_NOERROR; // 0x00
*(WORD*)&appMessage[AB_TNSBYTEOFF] = TNS;
appMessage[AB_FUNCBYTEOFF] = ALLENBRADLEY_WORD_WRITE; // 0xAA
// build the rest of the headder
pHeadderPtr = &appMessage[AB_FUNCBYTEOFF+1];
*pHeadderPtr++ = 2*numRegisters; // # bytes to send in the frame
*pHeadderPtr = (BYTE)fileNum;
if (fileNum > 254)
{
*pHeadderPtr++ = 0xFF;
*(WORD*)pHeadderPtr = fileNum;
pHeadderPtr++;
}
pHeadderPtr++;
*pHeadderPtr++ = 0x89; // always INTEGER file
// element#
*pHeadderPtr = (BYTE)startRegister;
if (startRegister > 254)
{
*pHeadderPtr++ = 0xFF;
*(WORD*)pHeadderPtr = startRegister;
pHeadderPtr++;
}
pHeadderPtr++;
// sub-element is always 0
*pHeadderPtr++ = 0x00;
// pack in the data
pwDataStart = (WORD*)(pHeadderPtr);
for (int i=0; i < numRegisters; i++)
{
*pwDataStart++ = PLCMemory[fileNum].GetAt(startRegister + i);
}
lengthAppMsg = (LONG)pHeadderPtr - (LONG)appMessage; // message pre-amble including STX
lengthAppMsg += (2*numRegisters);
//lengthAppMsg+= 4; // Add in message-end framing : ETX and CRC fields
lengthAppMsg -= 2; // substract the STX
sendOK = SendPLCMessage(&appMessage[2], lengthAppMsg);
// await the response ACK and frame
m_masterWaiting = TRUE;
SetEngineState(ENG_STATE_FINALACK);
return(sendOK);
}
// ------------------------- OnMessageReceived ---------------------------------
// return false to reject the message
BOOL CPLCApplication::OnMessageReceived(BYTE* pAppLayerMsg, DWORD length)
{
BYTE appMessage[MAX_AB_MESSAGELEN];
DWORD lengthAppMsg=0;
BYTE commandCode;
CABMessage msg(pAppLayerMsg, length, FALSE);
commandCode = msg.command;
if ((commandCode & 0x40)==0x40) // handle command responses for MASTER mode
{
CString debugMess;
// this is a response frame, since the CPU layer already ACKed it before passing it here
// we are done with it unless it is an error message frame
if (msg.transmissionStatus)
{
debugMess.Format("MASTER : Message %04X delivered with STS error:\n", msg.transactionID);
return(FALSE); // re-send frame
}
debugMess.Format("MASTER : Message %04X delivered OK:\n", msg.transactionID);
RSDataMessage(debugMess);
SetEngineState(ENG_STATE_MASTERIDLE);
return(TRUE);
}
// simulate the I/O and network delays of a real PLC
Sleep(m_responseDelay);
if (pGlobalDialog->StationEnabled(msg.stationIDDest))
{
// build up a response
BuildResponse(pAppLayerMsg, length, appMessage, &lengthAppMsg);
SendPLCMessage(appMessage, lengthAppMsg);
RSDataMessage("Await response ACK:");
SetEngineState(ENG_STATE_FINALACK); //and then wait for the ack
return(TRUE);
}
// station not listening
SetEngineState(ENG_STATE_IDLE); //and then wait for the ack
return(FALSE);
}
// --------------------------- BuildResponse ----------------------------------
void CPLCApplication::BuildResponse(const BYTE *inBuffer, DWORD inLength,
BYTE *buffer, DWORD *length)
{
CString diagnoseMsg;
char * dataPtr = NULL;
BOOL ABError = TRUE;
WORD ABErrorCode = 0;
CABMessage msg(inBuffer, inLength, FALSE);
RSDataMessage("Building Response Frame:");
// determine if the request was valid
if (AB_COMMAND_DRIVER == msg.command)
{
switch (msg.functionCode)
{
case (AB_FUNC_WRITE3 | 0x40): // MASTER mode
RSDataMessage("Write response received:");
msg.count =0; // there no data in the response frame
break;
case AB_FUNC_WRITE3: // SLAVE
// build response
{
LONG dataStartOff=14;
if (msg.fileNum >254)
dataStartOff+=2; // 3-byte field was used
if (msg.address >254)
dataStartOff+=2;
msg.BuildMessagePreamble();
dataPtr = &msg.buffer[dataStartOff];
for (int i=0; i < msg.count/2; i++)
{
//CMemWriteLock lk(PLCMemory.GetMutex());
diagnoseMsg.Format("Set File %d:%d = %d\n", msg.fileNum, msg.address + i, *(WORD*)dataPtr);
//RSDataMessage(diagnoseMsg);
PLCMemory[msg.fileNum].SetAt(msg.address + i, *(WORD*)dataPtr, PLCMemory.GetMutex());
dataPtr +=2;
}
ABError = FALSE;
if (pGlobalDialog)
{
int cols = pGlobalDialog->GetListDisplayedWidth();
pGlobalDialog->RedrawListItems(msg.fileNum,
msg.address/(cols),
(msg.address+((msg.count/2)-1))/(cols)
); // repaint only the needed rows
}
RSDataMessage("Write processed OK:");
msg.count =0; // there no data in the response frame
}
break;
case AB_FUNC_READ3: // SLAVE
// build response
{
DWORD linePos=0;
msg.BuildMessagePreamble();
dataPtr = &msg.buffer[8];
diagnoseMsg.Format("Get File %3d:%3d\n", msg.fileNum, msg.address);
//RSDataMessage(diagnoseMsg);
for (int i=0; i < msg.count/2; i++)
{
CMemWriteLock lk(PLCMemory.GetMutex());
diagnoseMsg.Format("%3d = x%04X |", msg.address + i, PLCMemory[msg.fileNum].GetAt(msg.address+i));
linePos+= diagnoseMsg.GetLength();
if (linePos > 79)
{
//RSDataMessage("\n");
linePos = diagnoseMsg.GetLength();
}
//RSDataMessage(diagnoseMsg);
*(WORD*)dataPtr = PLCMemory[msg.fileNum].GetAt(msg.address+i);
dataPtr +=2;
}
RSDataMessage("Read processed OK:");
ABError = FALSE;
}
break;
default:
ABErrorCode = AB_STS_ILLEGALCMD + (AB_EXTSTS_ILLEGALFIELDVALUE << 8);
break;
}
}
else
{
ABErrorCode = AB_STS_ILLEGALCMD + (AB_EXTSTS_CANNOTEXECUTE << 8);
}
if (ABError)
{
msg.BuildMessagePreamble(ABError, ABErrorCode);
//Send(msg.overalLen-8, (BYTE*)&msg.buffer[2], TRUE, NULL);
// send a NAK or error message
}
else
{
*length = msg.count + 6;
memcpy(buffer, (BYTE*)&msg.buffer[2], *length);
}
} //
// --------------------------- SetEmulationParameters -----------------------
void CAB232CommsProcessor::SetEmulationParameters(BOOL moscadChecks,
BOOL modifyThenRespond,
BOOL disableWrites)
{
//m_MOSCADchecks = moscadChecks;
m_modifyThenRespond = modifyThenRespond;
m_disableWrites = disableWrites;
}