#include "pch.h"
|
#include "KMachine.h"
|
|
KMachine::KMachine()
|
{
|
StartTime = GetTimemS();
|
}
|
KMachine::~KMachine()
|
{
|
|
}
|
|
double KMachine::GetTimemS()
|
{
|
LARGE_INTEGER perfreq;
|
LARGE_INTEGER percounter1;
|
QueryPerformanceFrequency(&perfreq);
|
QueryPerformanceCounter(&percounter1);
|
|
double time1 = (double)percounter1.QuadPart / perfreq.QuadPart;
|
return (time1 * 1000);
|
};
|
|
int KMachine::GetTick100uS()
|
{
|
int thistime = int((GetTimemS() - StartTime) * 10);
|
return thistime;
|
}
|
|
int KMachine::Init()
|
{
|
return 0;
|
}
|
|
int KMachine::Download(stBinProg1 * pBinrog, int nBinSteps)
|
{
|
for (int i = 0; i < nBinSteps; i++)
|
{
|
BinProgs[i] = pBinrog[i];
|
}
|
nBinProgSteps = nBinSteps;
|
return 0;
|
}
|
|
int KMachine::ProcPLC()
|
{
|
ProcessPLCBinProg(BinProgs, nBinProgSteps);
|
return 0;
|
}
|
|
int KMachine::StartPLC()
|
{
|
for (int i = 0; i < KLDataWXCount; i++) {
|
KMem.WX[i] = 0;
|
}
|
for (int i = 0; i < KLDataWYCount; i++) {
|
KMem.WY[i] = 0;
|
}
|
for (int i = 0; i < KLDataWRCount; i++) {
|
KMem.WR[i] = 0;
|
}
|
for (int i = 0; i < KLDataDTCount; i++) {
|
KMem.DT[i] = 0;
|
}
|
for (int i = 0; i < TOTALTIMERS; i++) {
|
KMem.Timers[i] = { 0 };
|
}
|
nScanCount = 0;
|
m_bPlcRunning = 1;
|
|
return 0;
|
}
|
|
int KMachine::StopPLC()
|
{
|
m_bPlcRunning = 0;
|
return 0;
|
}
|
|
|
|
|
const unsigned short bitMasks[16] =
|
{
|
0x1 << 0, 0x1 << 1, 0x1 << 2, 0x1 << 3, 0x1 << 4, 0x1 << 5, 0x1 << 6, 0x1 << 7,
|
0x1 << 8, 0x1 << 9, 0x1 << 10, 0x1 << 11, 0x1 << 12, 0x1 << 13, 0x1 << 14, 0x1 << 15,
|
};
|
|
inline void SetAddrBit(unsigned short * pW, unsigned char bitAddr)
|
{
|
(*pW) |= bitMasks[bitAddr & 0xf];
|
}
|
|
inline void ResetBit(unsigned short * pW, unsigned char bitAddr)
|
{
|
(*pW) &= ~bitMasks[bitAddr & 0xf];
|
}
|
|
static inline void SetBitValue(unsigned short * pW, unsigned char bitAddr, unsigned char Value)
|
{
|
if (Value) { SetAddrBit(pW, bitAddr); }
|
else { ResetBit(pW, bitAddr); }
|
}
|
|
static inline unsigned char GetBitValue(unsigned short W, unsigned char bitAddr)
|
{
|
if (W&bitMasks[bitAddr & 0xf]) return 1;
|
else return 0;
|
}
|
|
int KMachine::GetCoilValue(int nCoilType, int nCoilAddr)
|
{
|
// TODO: ÔÚ´Ë´¦Ìí¼ÓʵÏÖ´úÂë.
|
|
int nWordAddr = nCoilAddr >> 4;
|
int nBitAddr = nCoilAddr & 0x0F;
|
|
switch (nCoilType)
|
{
|
case KLCoilTypeX:
|
if (nCoilAddr >= KLCoilXCount) return 0;
|
return GetBitValue(KMem.WX[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeY:
|
if (nCoilAddr >= KLCoilYCount) return 0;
|
return GetBitValue(KMem.WY[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeR:
|
if (nCoilAddr >= KLCoilRCount) return 0;
|
return GetBitValue(KMem.WR[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeLX:
|
if (nCoilAddr >= KLCoilLXCount) return 0;
|
return GetBitValue(KMem.WLX[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeLY:
|
if (nCoilAddr >= KLCoilLYCount) return 0;
|
return GetBitValue(KMem.WLY[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeT:
|
if (nCoilAddr >= KLCoilTCount) return 0;
|
return GetBitValue(KMem.WT[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeC:
|
if (nCoilAddr >= KLCoilCCount) return 0;
|
return GetBitValue(KMem.WC[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeLR:
|
if (nCoilAddr >= KLCoilLRCount) return 0;
|
return GetBitValue(KMem.WLR[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeSR:
|
if (nCoilAddr >= KLCoilSRCount) return 0;
|
return GetBitValue(KMem.WSR[nWordAddr], nBitAddr);
|
break;
|
}
|
return 0;
|
}
|
|
|
int KMachine::SetCoilValue(int nCoilType, int nCoilAddr, int nCoilValue)
|
{
|
// TODO: ÔÚ´Ë´¦Ìí¼ÓʵÏÖ´úÂë.
|
|
int nWordAddr = nCoilAddr >> 4;
|
int nBitAddr = nCoilAddr & 0x0F;
|
|
switch (nCoilType)
|
{
|
case KLCoilTypeX:
|
if (nCoilAddr >= KLCoilXCount) return 0;
|
SetBitValue(&KMem.WX[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeY:
|
if (nCoilAddr >= KLCoilYCount) return 0;
|
SetBitValue(&KMem.WY[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeR:
|
if (nCoilAddr >= KLCoilRCount) return 0;
|
SetBitValue(&KMem.WR[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeLX:
|
if (nCoilAddr >= KLCoilLXCount) return 0;
|
SetBitValue(&KMem.WLX[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeLY:
|
if (nCoilAddr >= KLCoilLYCount) return 0;
|
SetBitValue(&KMem.WLY[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeT:
|
if (nCoilAddr >= KLCoilTCount) return 0;
|
SetBitValue(&KMem.WT[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeC:
|
if (nCoilAddr >= KLCoilCCount) return 0;
|
SetBitValue(&KMem.WC[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeLR:
|
if (nCoilAddr >= KLCoilLRCount) return 0;
|
SetBitValue(&KMem.WLR[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeSR:
|
if (nCoilAddr >= KLCoilSRCount) return 0;
|
SetBitValue(&KMem.WSR[nWordAddr], nBitAddr, nCoilValue);
|
|
break;
|
}
|
return 0;
|
}
|
|
int KMachine::GetVarData(int nDataType, int nDataAddr)
|
{
|
// TODO: ÔÚ´Ë´¦Ìí¼ÓʵÏÖ´úÂë.
|
|
switch (nDataType)
|
{
|
case KLDataTypeDEC:
|
case KLDataTypeHEX:
|
return nDataAddr;
|
break;
|
case KLDataTypeWX:
|
if (nDataAddr >= KLDataWXCount) return 0;
|
return KMem.WX[nDataAddr];
|
break;
|
case KLDataTypeWY:
|
if (nDataAddr >= KLDataWYCount) return 0;
|
return KMem.WY[nDataAddr];
|
break;
|
case KLDataTypeWR:
|
if (nDataAddr >= KLDataWRCount) return 0;
|
return KMem.WR[nDataAddr];
|
break;
|
case KLDataTypeWLX:
|
if (nDataAddr >= KLDataWLCount) return 0;
|
return KMem.WLX[nDataAddr];
|
break;
|
case KLDataTypeWLY:
|
if (nDataAddr >= KLDataWLCount) return 0;
|
return KMem.WLY[nDataAddr];
|
break;
|
case KLDataTypeDT:
|
if (nDataAddr >= KLDataDTCount) return 0;
|
return (signed short)KMem.DT[nDataAddr];
|
break;
|
case KLDataTypeSDT:
|
if (nDataAddr >= KLDataSDTCount) return 0;
|
return KMem.SDT[nDataAddr];
|
break;
|
case KLDataTypeWSR:
|
if (nDataAddr >= KLCoilLRCount) return 0;
|
return KMem.WSR[nDataAddr];
|
break;
|
case KLDataTypeSV:
|
if (nDataAddr >= KLDataSVCount) return 0;
|
return KMem.SV[nDataAddr];
|
break;
|
case KLDataTypeEV:
|
if (nDataAddr >= KLDataEVCount) return 0;
|
return KMem.EV[nDataAddr];
|
break;
|
case KLDataTypeLD:
|
if (nDataAddr >= KLDataLDCount) return 0;
|
return KMem.DT[nDataAddr];
|
break;
|
case KLDataSysCfg:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
return KMem.SDT[nDataAddr];
|
break;
|
case KLDataTypeFlash:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
return KMem.SDT[nDataAddr];
|
break;
|
case KLDataTypeTest:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
return KMem.SDT[nDataAddr];
|
break;
|
}
|
return 0;
|
}
|
|
|
int KMachine::SetVarData(int nDataType, int nDataAddr, int nDataValue)
|
{
|
// TODO: ÔÚ´Ë´¦Ìí¼ÓʵÏÖ´úÂë.
|
|
switch (nDataType)
|
{
|
// case KLDataTypeDEC:
|
// case KLDataTypeHEX:
|
// break;
|
case KLDataTypeWX:
|
if (nDataAddr >= KLDataWXCount) return 0;
|
KMem.WX[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWY:
|
if (nDataAddr >= KLDataWYCount) return 0;
|
KMem.WY[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWR:
|
if (nDataAddr >= KLDataWRCount) return 0;
|
KMem.WR[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWLX:
|
if (nDataAddr >= KLDataWLCount) return 0;
|
KMem.WLX[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWLY:
|
if (nDataAddr >= KLDataWLCount) return 0;
|
KMem.WLY[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeDT:
|
if (nDataAddr >= KLDataDTCount) return 0;
|
KMem.DT[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeSDT:
|
if (nDataAddr >= KLDataSDTCount) return 0;
|
KMem.SDT[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWSR:
|
if (nDataAddr >= KLCoilLRCount) return 0;
|
KMem.WSR[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeSV:
|
if (nDataAddr >= KLDataSVCount) return 0;
|
KMem.SV[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeEV:
|
if (nDataAddr >= KLDataEVCount) return 0;
|
KMem.EV[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeLD:
|
if (nDataAddr >= KLDataLDCount) return 0;
|
KMem.DT[nDataAddr] = nDataValue;
|
break;
|
case KLDataSysCfg:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
KMem.SDT[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeFlash:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
KMem.SDT[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeTest:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
KMem.SDT[nDataAddr] = nDataValue;
|
break;
|
}
|
|
return 0;
|
}
|
|
int KMachine::InitTimer(int nIndex, int nType)
|
{
|
if (nIndex >= TOTALTIMERS) return -1;
|
KMem.Timers[nIndex].StatByte = 0x0010 | nType;
|
// Timers[nIndex].nType = 0;
|
KMem.SV[nIndex] = 0;
|
KMem.EV[nIndex] = 0;
|
KMem.Timers[nIndex].LastActTime = GetTick100uS();
|
return 0;
|
}
|
int KMachine::RunTimer(int nIndex, int SV)
|
{
|
if (nIndex >= TOTALTIMERS) return -1;
|
if (!KMem.Timers[nIndex].bSet)
|
{
|
KMem.SV[nIndex] = SV;
|
KMem.EV[nIndex] = 0;
|
KMem.Timers[nIndex].LastActTime = GetTick100uS();
|
KMem.Timers[nIndex].bSet = 1;
|
}
|
return 0;
|
}
|
int KMachine::StopTimer(int nIndex)
|
{
|
if (nIndex >= TOTALTIMERS) return -1;
|
if (KMem.Timers[nIndex].bSet)
|
{
|
KMem.EV[nIndex] = 0;
|
KMem.Timers[nIndex].LastActTime = GetTick100uS();
|
KMem.Timers[nIndex].bSet = 0;
|
}
|
return 0;
|
}
|
int KMachine::ResetTimer(int nIndex)
|
{
|
if (nIndex >= TOTALTIMERS) return -1;
|
KMem.EV[nIndex] = 0;
|
KMem.Timers[nIndex].bTon = 0;
|
KMem.Timers[nIndex].LastActTime = GetTick100uS();
|
return 0;
|
}
|
int KMachine::SetTimerValue(int nIndex, int bSet, int SV)
|
{
|
if (nIndex >= TOTALTIMERS) return -1;
|
if (bSet) { RunTimer(nIndex, SV); }
|
else { StopTimer(nIndex); }
|
return KMem.Timers[nIndex].bTon;
|
}
|
int KMachine::ProcessTimer(int nIndex)
|
{
|
if (nIndex >= TOTALTIMERS) return -1;
|
if (!KMem.Timers[nIndex].nInited) return 0;
|
if (KMem.Timers[nIndex].bSet) // bSet =1;
|
{
|
if (!KMem.Timers[nIndex].bTon)
|
{
|
int TimeDiff = GetTick100uS() - KMem.Timers[nIndex].LastActTime;
|
int nScale = TICK_OF_MS;
|
if (KMem.Timers[nIndex].nScale == 0)
|
{
|
nScale = TICK_OF_MS;
|
}
|
else if (KMem.Timers[nIndex].nScale == 1)
|
{
|
nScale = TICK_OF_RS;
|
}
|
else if (KMem.Timers[nIndex].nScale == 2)
|
{
|
nScale = TICK_OF_XS;
|
}
|
else if (KMem.Timers[nIndex].nScale == 3)
|
{
|
nScale = TICK_OF_YS;
|
}
|
else {}
|
|
|
//if (TimeDiff >= nScale)
|
{
|
int TimeDiffmS = TimeDiff / nScale;
|
unsigned short NextEV = KMem.EV[nIndex] + TimeDiffmS;
|
KMem.Timers[nIndex].LastActTime += TimeDiffmS * nScale;
|
|
if (NextEV >= KMem.SV[nIndex])
|
{
|
NextEV = KMem.SV[nIndex];
|
KMem.Timers[nIndex].bTon = 1;
|
}
|
KMem.EV[nIndex] = NextEV;
|
}
|
}
|
}
|
else //bSet=0;
|
{
|
if (KMem.Timers[nIndex].bTon)
|
{
|
KMem.Timers[nIndex].bTon = 0;
|
}
|
KMem.EV[nIndex] = 0;
|
}
|
SetCoilValue(KLCoilTypeT, nIndex, KMem.Timers[nIndex].bTon);
|
return KMem.Timers[nIndex].bTon;
|
}
|
int KMachine::IsTimerOn(int nIndex)
|
{
|
if (nIndex >= TOTALTIMERS) return 0;
|
ProcessTimer(nIndex);
|
return KMem.Timers[nIndex].bTon;
|
}
|
int KMachine::GetTimerSV(int nIndex)
|
{
|
if (nIndex >= TOTALTIMERS) return 0;
|
// ProcessTimer(nIndex);
|
return KMem.SV[nIndex];
|
// return 0;
|
}
|
int KMachine::GetTimerEV(int nIndex)
|
{
|
if (nIndex >= TOTALTIMERS) return 0;
|
// ProcessTimer(nIndex);
|
return KMem.EV[nIndex];
|
// return 0;
|
|
}
|
|
|
int KMachine::PushInVal(void)
|
{
|
for (int i = TOTAL_CurVAL - 1; i > 0; i--)
|
{
|
KMem.CurVALs[i] = KMem.CurVALs[i - 1];
|
}
|
KMem.CurVALs[0] = KMem.CurVAL ? '1' : '0';
|
return KMem.CurVAL;
|
}
|
|
int KMachine::PopOutVal(void)
|
{
|
unsigned char theVAL = (KMem.CurVALs[0] == '1');
|
for (int i = 0; i < TOTAL_CurVAL - 1; i++)
|
{
|
KMem.CurVALs[i] = KMem.CurVALs[i + 1];
|
}
|
return theVAL;
|
}
|
|
|
int KMachine::ProcessPLCBinProg(const stBinProg1 * pBinprog, int nProgSteps)
|
{
|
if (nScanCount == 0) {
|
SetCoilValue(KLCoilTypeSR, 13, 1);
|
SetCoilValue(KLCoilTypeSR, 0, 0);
|
SetCoilValue(KLCoilTypeSR, 1, 1);
|
}
|
else
|
{
|
SetCoilValue(KLCoilTypeSR, 13, 0);
|
SetCoilValue(KLCoilTypeSR, 0, 0);
|
SetCoilValue(KLCoilTypeSR, 1, 1);
|
}
|
for (int i = 0; i < TOTAL_CurVAL; i++) {
|
KMem.CurVALs[i] = '0';
|
}
|
int CurPos = 0;
|
// stBinProg1 * pBinProg1;
|
stBinProg15 * pBinProg15;
|
stBinProg2 * pBinProg2;
|
stBinProg3 * pBinProg3;
|
// unsigned int AddrType2 ;
|
// unsigned short Addr2 ;
|
|
// unsigned int AddrType3 ;
|
// unsigned short Addr3 ;
|
// pBinProg15 = (stBinProg15 *)&pBinprog[CurPos];
|
// pBinProg2 = (stBinProg2 *)&pBinprog[CurPos];
|
// pBinProg3 = (stBinProg3 *)&pBinprog[CurPos];
|
|
int lastScanInputVal = 1;//ÉϸöɨÃèÖÜÆÚ£¬µ±Ç°Ö¸ÁîÊäÈë״̬£¬Îª ΢·Ö ×ö²Î¿¼
|
|
while (CurPos < nProgSteps)
|
{
|
unsigned int nNextPos = 1;
|
unsigned int thisOP = pBinprog[CurPos].nOp;
|
// unsigned int nParamCount = 0
|
unsigned char thisAddrType = pBinprog[CurPos].nParamType;
|
unsigned short thisAddr = pBinprog[CurPos].nParamAddr;
|
|
|
switch (thisOP)
|
{
|
case OP_NONE:
|
break;
|
// case OP_NOP:
|
break;
|
//ÎÞ²ÎÊý Ö¸Áî
|
case OP_END:
|
nNextPos = nProgSteps;
|
break;
|
case OP_NOT:
|
case OP_ANS:
|
case OP_ORS:
|
case OP_PSHS:
|
case OP_RDS:
|
case OP_POPS:
|
case OP_DF:
|
case OP_DF_:
|
switch (thisOP)
|
{
|
case OP_NOT:
|
KMem.CurVAL = !KMem.CurVAL;
|
break;
|
case OP_ANS:
|
KMem.CurVAL = PopOutVal() && KMem.CurVAL;
|
break;
|
case OP_ORS:
|
KMem.CurVAL = PopOutVal() || KMem.CurVAL;
|
break;
|
case OP_PSHS:
|
PushInVal();
|
break;
|
case OP_RDS:
|
KMem.CurVAL = KMem.CurVALs[0] == '1';
|
break;
|
case OP_POPS:
|
KMem.CurVAL = PopOutVal();
|
break;
|
case OP_DF:
|
KMem.CurVAL = KMem.CurVAL && !lastScanInputVal;
|
break;
|
case OP_DF_:
|
KMem.CurVAL = !KMem.CurVAL && lastScanInputVal;
|
break;
|
|
default:
|
break;
|
}
|
break;
|
// 1²ÎÊýÖ¸Áî
|
case OP_ST:
|
case OP_ST_:
|
case OP_AN:
|
case OP_AN_:
|
case OP_OR:
|
case OP_OR_:
|
switch (thisOP)
|
{
|
case OP_ST:
|
PushInVal();
|
KMem.CurVAL = GetCoilValue(thisAddrType, thisAddr);
|
break;
|
case OP_ST_:
|
PushInVal();
|
KMem.CurVAL = !GetCoilValue(thisAddrType, thisAddr);
|
break;
|
case OP_AN:
|
KMem.CurVAL = KMem.CurVAL&&GetCoilValue(thisAddrType, thisAddr);
|
break;
|
case OP_AN_:
|
KMem.CurVAL = KMem.CurVAL && (!GetCoilValue(thisAddrType, thisAddr));
|
break;
|
case OP_OR:
|
KMem.CurVAL = KMem.CurVAL || GetCoilValue(thisAddrType, thisAddr);
|
break;
|
case OP_OR_:
|
KMem.CurVAL = KMem.CurVAL || (!GetCoilValue(thisAddrType, thisAddr));
|
break;
|
default:
|
break;
|
}
|
break;
|
// 1 ²ÎÊý Êä³ö
|
case OP_OUT:
|
case OP_SET:
|
case OP_RESET:
|
switch (thisOP)
|
{
|
case OP_OUT:
|
SetCoilValue(thisAddrType, thisAddr, KMem.CurVAL);
|
break;
|
case OP_SET:
|
if (KMem.CurVAL) SetCoilValue(thisAddrType, thisAddr, 1);
|
break;
|
case OP_RESET:
|
if (KMem.CurVAL) SetCoilValue(thisAddrType, thisAddr, 0);
|
break;
|
default:
|
break;
|
}
|
break;
|
// ±È½ÏÖ¸Áî
|
case OP_ST_EQ:
|
case OP_ST_NE:
|
case OP_ST_LT:
|
case OP_ST_GT:
|
case OP_ST_LE:
|
case OP_ST_GE:
|
case OP_AN_EQ:
|
case OP_AN_NE:
|
case OP_AN_LT:
|
case OP_AN_GT:
|
case OP_AN_LE:
|
case OP_AN_GE:
|
case OP_OR_EQ:
|
case OP_OR_NE:
|
case OP_OR_LT:
|
case OP_OR_GT:
|
case OP_OR_LE:
|
case OP_OR_GE:
|
pBinProg2 = (stBinProg2 *)&pBinprog[CurPos];
|
thisAddrType = pBinProg2->nParamType1;
|
|
switch (thisOP)
|
{
|
case OP_ST_EQ:
|
PushInVal();
|
KMem.CurVAL = (GetVarData(thisAddrType, thisAddr) == GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_ST_NE:
|
PushInVal();
|
KMem.CurVAL = (GetVarData(thisAddrType, thisAddr) != GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_ST_LT:
|
PushInVal();
|
KMem.CurVAL = (GetVarData(thisAddrType, thisAddr) < GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_ST_GT:
|
PushInVal();
|
KMem.CurVAL = (GetVarData(thisAddrType, thisAddr) > GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_ST_LE:
|
PushInVal();
|
KMem.CurVAL = (GetVarData(thisAddrType, thisAddr) <= GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_ST_GE:
|
PushInVal();
|
KMem.CurVAL = (GetVarData(thisAddrType, thisAddr) >= GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_AN_EQ:
|
KMem.CurVAL = KMem.CurVAL && (GetVarData(thisAddrType, thisAddr) == GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_AN_NE:
|
KMem.CurVAL = KMem.CurVAL && (GetVarData(thisAddrType, thisAddr) != GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_AN_LT:
|
KMem.CurVAL = KMem.CurVAL && (GetVarData(thisAddrType, thisAddr) < GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_AN_GT:
|
KMem.CurVAL = KMem.CurVAL && (GetVarData(thisAddrType, thisAddr) > GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_AN_LE:
|
KMem.CurVAL = KMem.CurVAL && (GetVarData(thisAddrType, thisAddr) <= GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_AN_GE:
|
KMem.CurVAL = KMem.CurVAL && (GetVarData(thisAddrType, thisAddr) >= GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
|
case OP_OR_EQ:
|
KMem.CurVAL = KMem.CurVAL || (GetVarData(thisAddrType, thisAddr) == GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_OR_NE:
|
KMem.CurVAL = KMem.CurVAL || (GetVarData(thisAddrType, thisAddr) != GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_OR_LT:
|
KMem.CurVAL = KMem.CurVAL || (GetVarData(thisAddrType, thisAddr) < GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_OR_GT:
|
KMem.CurVAL = KMem.CurVAL || (GetVarData(thisAddrType, thisAddr) > GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_OR_LE:
|
KMem.CurVAL = KMem.CurVAL || (GetVarData(thisAddrType, thisAddr) <= GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
case OP_OR_GE:
|
KMem.CurVAL = KMem.CurVAL || (GetVarData(thisAddrType, thisAddr) >= GetVarData(pBinProg2->nParamType2, pBinProg2->nParamAddr2));
|
break;
|
|
default:
|
break;
|
}
|
nNextPos = 2;
|
break;
|
// ¶¨Ê±Æ÷
|
case OP_TML:
|
case OP_TMR:
|
case OP_TMX:
|
case OP_TMY:
|
pBinProg15 = (stBinProg15 *)(&pBinprog[CurPos]);
|
{
|
unsigned char thisNum = pBinProg15->nOpNum;
|
thisAddrType = pBinProg15->nParamType1;
|
thisAddr = pBinProg15->nParamAddr1;
|
switch (thisOP)
|
{
|
case OP_TML:
|
if (!KMem.Timers[thisNum].nInited) InitTimer(thisNum, 0);
|
if (KMem.CurVAL) RunTimer(thisNum, GetVarData(thisAddrType, thisAddr));
|
else StopTimer(thisNum);
|
KMem.CurVAL = ProcessTimer(thisNum);
|
|
break;
|
case OP_TMR:
|
if (!KMem.Timers[thisNum].nInited) InitTimer(thisNum, 1);
|
if (KMem.CurVAL) RunTimer(thisNum, GetVarData(thisAddrType, thisAddr));
|
else StopTimer(thisNum);
|
KMem.CurVAL = ProcessTimer(thisNum);
|
break;
|
case OP_TMX:
|
if (!KMem.Timers[thisNum].nInited) InitTimer(thisNum, 2);
|
if (KMem.CurVAL) RunTimer(thisNum, GetVarData(thisAddrType, thisAddr));
|
else StopTimer(thisNum);
|
KMem.CurVAL = ProcessTimer(thisNum);
|
|
break;
|
case OP_TMY:
|
if (!KMem.Timers[thisNum].nInited) InitTimer(thisNum, 3);
|
if (KMem.CurVAL) RunTimer(thisNum, GetVarData(thisAddrType, thisAddr));
|
else StopTimer(thisNum);
|
KMem.CurVAL = ProcessTimer(thisNum);
|
break;
|
default:
|
break;
|
}
|
|
}
|
nNextPos = 2;
|
break;
|
// 1 ²ÎÊý¸ß¼¶Ö¸Áî
|
case OP_INC:
|
case OP_DEC:
|
pBinProg15 = (stBinProg15 *)(&pBinprog[CurPos]);
|
thisAddrType = pBinProg15->nParamType1;
|
thisAddr = pBinProg15->nParamAddr1;
|
nNextPos = 2;
|
switch (thisOP)
|
{
|
case OP_INC:
|
if (KMem.CurVAL) SetVarData(thisAddrType, thisAddr, GetVarData(thisAddrType, thisAddr) + 1);
|
break;
|
case OP_DEC:
|
if (KMem.CurVAL) SetVarData(thisAddrType, thisAddr, GetVarData(thisAddrType, thisAddr) - 1);
|
break;
|
|
default:
|
break;
|
}
|
break;
|
// 2²ÎÊý¸ß¼¶Ö¸Áî
|
case OP_MV:
|
case OP_ADD2:
|
case OP_SUB2:
|
pBinProg2 = (stBinProg2 *)(&pBinprog[CurPos]);
|
{
|
int nParamType2, nParamAddr2;
|
thisAddrType = pBinProg2->nParamType1;
|
thisAddr = pBinProg2->nParamAddr1;
|
nParamType2 = pBinProg2->nParamType2;
|
nParamAddr2 = pBinProg2->nParamAddr2;
|
|
switch (thisOP)
|
{
|
case OP_MV:
|
if (KMem.CurVAL) SetVarData(nParamType2, nParamAddr2, GetVarData(thisAddrType, thisAddr));
|
break;
|
case OP_ADD2:
|
if (KMem.CurVAL) SetVarData(nParamType2, nParamAddr2, GetVarData(thisAddrType, thisAddr) + GetVarData(nParamType2, nParamAddr2));
|
break;
|
case OP_SUB2:
|
if (KMem.CurVAL) SetVarData(nParamType2, nParamAddr2, GetVarData(nParamType2, nParamAddr2) - GetVarData(thisAddrType, thisAddr));
|
break;
|
|
default:
|
break;
|
}
|
|
}
|
nNextPos = 2;
|
break;
|
// 3 ²ÎÊý¸ß¼¶Ö¸Áî
|
case OP_ADD3:
|
case OP_SUB3:
|
case OP_MUL:
|
case OP_DIV:
|
pBinProg3 = (stBinProg3 *)(&pBinprog[CurPos]);
|
int nParamType2, nParamAddr2;
|
int nParamType3, nParamAddr3;
|
thisAddrType = pBinProg3->nParamType1;
|
thisAddr = pBinProg3->nParamAddr1;
|
nParamType2 = pBinProg3->nParamType2;
|
nParamAddr2 = pBinProg3->nParamAddr2;
|
nParamType3 = pBinProg3->nParamType3;
|
nParamAddr3 = pBinProg3->nParamAddr3;
|
switch (thisOP)
|
{
|
case OP_ADD3:
|
if (KMem.CurVAL) SetVarData(nParamType3, nParamAddr3, GetVarData(thisAddrType, thisAddr) + GetVarData(nParamType2, nParamAddr2));
|
break;
|
case OP_SUB3:
|
if (KMem.CurVAL) SetVarData(nParamType3, nParamAddr3, GetVarData(thisAddrType, thisAddr) - GetVarData(nParamType2, nParamAddr2));
|
break;
|
case OP_MUL:
|
if (KMem.CurVAL) {
|
short multiplicand = GetVarData(thisAddrType, thisAddr);
|
short multiplier = GetVarData(nParamType2, nParamAddr2);
|
int product = multiplicand * multiplier;
|
SetVarData(nParamType3, nParamAddr3, product);
|
SetVarData(nParamType3, nParamAddr3 + 1, product >> 16);
|
}
|
break;
|
case OP_DIV:
|
if (KMem.CurVAL) {
|
short dividend = GetVarData(thisAddrType, thisAddr);
|
short divisor = GetVarData(nParamType2, nParamAddr2);
|
short quotient = dividend / divisor;
|
short remainder = dividend % divisor;
|
SetVarData(nParamType3, nParamAddr3, quotient);
|
SetVarData(nParamType3, nParamAddr3 + 1, remainder);
|
}
|
break;
|
|
default:
|
break;
|
}
|
nNextPos = 3;
|
break;
|
|
default:
|
break;
|
}
|
|
lastScanInputVal = ProgTrace[CurPos];
|
ProgTrace[CurPos] = KMem.CurVAL;
|
CurPos += nNextPos;
|
}
|
nScanCount++;
|
return 0;
|
}
|
|
/*
|
int KMachine::ProcessPLCProg(const stProg * prog, int nSize)
|
{
|
if (nScanCount == 0) {
|
SetCoilValue(KLCoilTypeSR, 13, 1);
|
SetCoilValue(KLCoilTypeSR, 0, 0);
|
SetCoilValue(KLCoilTypeSR, 1, 1);
|
}
|
else
|
{
|
SetCoilValue(KLCoilTypeSR, 13, 0);
|
SetCoilValue(KLCoilTypeSR, 0, 0);
|
SetCoilValue(KLCoilTypeSR, 1, 1);
|
}
|
for (int i = 0; i < TOTAL_CurVAL; i++) {
|
KMem.CurVALs[i] = '0';
|
}
|
int lastScanInputVal = 1;//ÉϸöɨÃèÖÜÆÚ£¬µ±Ç°Ö¸ÁîÊäÈë״̬£¬Îª ΢·Ö ×ö²Î¿¼
|
for (int i = 0; i < nSize; i++)
|
{
|
unsigned int thisOP = prog[i].nOpType1;
|
unsigned int nParamCount = prog[i].nParamCount;
|
unsigned int thisAddrType = prog[i].Params[0].nParamType;
|
unsigned short thisAddr = prog[i].Params[0].nParamAddr;
|
|
unsigned int AddrType2 = prog[i].Params[1].nParamType;
|
unsigned short Addr2 = prog[i].Params[1].nParamAddr;
|
|
unsigned int AddrType3 = prog[i].Params[2].nParamType;
|
unsigned short Addr3 = prog[i].Params[2].nParamAddr;
|
|
switch (thisOP)
|
{
|
case OP_NOP:
|
break;
|
case OP_ST:
|
PushInVal();
|
KMem.CurVAL = GetCoilValue(thisAddrType, thisAddr);
|
break;
|
case OP_ST_:
|
PushInVal();
|
KMem.CurVAL = !GetCoilValue(thisAddrType, thisAddr);
|
break;
|
case OP_AN:
|
KMem.CurVAL = KMem.CurVAL&&GetCoilValue(thisAddrType, thisAddr);
|
break;
|
case OP_AN_:
|
KMem.CurVAL = KMem.CurVAL && (!GetCoilValue(thisAddrType, thisAddr));
|
break;
|
case OP_OR:
|
KMem.CurVAL = KMem.CurVAL || GetCoilValue(thisAddrType, thisAddr);
|
break;
|
case OP_OR_:
|
KMem.CurVAL = KMem.CurVAL || (!GetCoilValue(thisAddrType, thisAddr));
|
break;
|
case OP_NOT:
|
KMem.CurVAL = !KMem.CurVAL;
|
break;
|
case OP_ANS:
|
KMem.CurVAL = PopOutVal() && KMem.CurVAL;
|
break;
|
case OP_ORS:
|
KMem.CurVAL = PopOutVal() || KMem.CurVAL;
|
break;
|
case OP_PSHS:
|
PushInVal();
|
break;
|
case OP_RDS:
|
KMem.CurVAL = KMem.CurVALs[0] == '1';
|
break;
|
case OP_POPS:
|
KMem.CurVAL = PopOutVal();
|
break;
|
case OP_OUT:
|
SetCoilValue(thisAddrType, thisAddr, KMem.CurVAL);
|
break;
|
case OP_SET:
|
if (KMem.CurVAL) SetCoilValue(thisAddrType, thisAddr, 1);
|
break;
|
case OP_RESET:
|
if (KMem.CurVAL) SetCoilValue(thisAddrType, thisAddr, 0);
|
break;
|
case OP_DF:
|
KMem.CurVAL = KMem.CurVAL && !lastScanInputVal;
|
break;
|
case OP_DF_:
|
KMem.CurVAL = !KMem.CurVAL && lastScanInputVal;
|
break;
|
case OP_ST_EQ:
|
PushInVal();
|
KMem.CurVAL = (GetVarData(thisAddrType, thisAddr) == GetVarData(AddrType2, Addr2));
|
break;
|
case OP_ST_NE:
|
PushInVal();
|
KMem.CurVAL = (GetVarData(thisAddrType, thisAddr) != GetVarData(AddrType2, Addr2));
|
break;
|
case OP_ST_LT:
|
PushInVal();
|
KMem.CurVAL = (GetVarData(thisAddrType, thisAddr) < GetVarData(AddrType2, Addr2));
|
break;
|
case OP_ST_GT:
|
PushInVal();
|
KMem.CurVAL = (GetVarData(thisAddrType, thisAddr) > GetVarData(AddrType2, Addr2));
|
break;
|
case OP_ST_LE:
|
PushInVal();
|
KMem.CurVAL = (GetVarData(thisAddrType, thisAddr) <= GetVarData(AddrType2, Addr2));
|
break;
|
case OP_ST_GE:
|
PushInVal();
|
KMem.CurVAL = (GetVarData(thisAddrType, thisAddr) >= GetVarData(AddrType2, Addr2));
|
break;
|
case OP_AN_EQ:
|
KMem.CurVAL = KMem.CurVAL && (GetVarData(thisAddrType, thisAddr) == GetVarData(AddrType2, Addr2));
|
break;
|
case OP_AN_NE:
|
KMem.CurVAL = KMem.CurVAL && (GetVarData(thisAddrType, thisAddr) != GetVarData(AddrType2, Addr2));
|
break;
|
case OP_AN_LT:
|
KMem.CurVAL = KMem.CurVAL && (GetVarData(thisAddrType, thisAddr) < GetVarData(AddrType2, Addr2));
|
break;
|
case OP_AN_GT:
|
KMem.CurVAL = KMem.CurVAL && (GetVarData(thisAddrType, thisAddr) > GetVarData(AddrType2, Addr2));
|
break;
|
case OP_AN_LE:
|
KMem.CurVAL = KMem.CurVAL && (GetVarData(thisAddrType, thisAddr) <= GetVarData(AddrType2, Addr2));
|
break;
|
case OP_AN_GE:
|
KMem.CurVAL = KMem.CurVAL && (GetVarData(thisAddrType, thisAddr) >= GetVarData(AddrType2, Addr2));
|
break;
|
|
case OP_OR_EQ:
|
KMem.CurVAL = KMem.CurVAL || (GetVarData(thisAddrType, thisAddr) == GetVarData(AddrType2, Addr2));
|
break;
|
case OP_OR_NE:
|
KMem.CurVAL = KMem.CurVAL || (GetVarData(thisAddrType, thisAddr) != GetVarData(AddrType2, Addr2));
|
break;
|
case OP_OR_LT:
|
KMem.CurVAL = KMem.CurVAL || (GetVarData(thisAddrType, thisAddr) < GetVarData(AddrType2, Addr2));
|
break;
|
case OP_OR_GT:
|
KMem.CurVAL = KMem.CurVAL || (GetVarData(thisAddrType, thisAddr) > GetVarData(AddrType2, Addr2));
|
break;
|
case OP_OR_LE:
|
KMem.CurVAL = KMem.CurVAL || (GetVarData(thisAddrType, thisAddr) <= GetVarData(AddrType2, Addr2));
|
break;
|
case OP_OR_GE:
|
KMem.CurVAL = KMem.CurVAL || (GetVarData(thisAddrType, thisAddr) >= GetVarData(AddrType2, Addr2));
|
break;
|
|
|
case OP_TML:
|
if (!KMem.Timers[thisAddr].nInited) InitTimer(thisAddr, 0);
|
if (KMem.CurVAL) RunTimer(thisAddr, GetVarData(AddrType2, Addr2));
|
else StopTimer(thisAddr);
|
KMem.CurVAL = ProcessTimer(thisAddr);
|
|
break;
|
case OP_TMR:
|
if (!KMem.Timers[thisAddr].nInited) InitTimer(thisAddr, 1);
|
if (KMem.CurVAL) RunTimer(thisAddr, GetVarData(AddrType2, Addr2));
|
else StopTimer(thisAddr);
|
KMem.CurVAL = ProcessTimer(thisAddr);
|
break;
|
case OP_TMX:
|
if (!KMem.Timers[thisAddr].nInited) InitTimer(thisAddr, 2);
|
if (KMem.CurVAL) RunTimer(thisAddr, GetVarData(AddrType2, Addr2));
|
else StopTimer(thisAddr);
|
KMem.CurVAL = ProcessTimer(thisAddr);
|
|
break;
|
case OP_TMY:
|
if (!KMem.Timers[thisAddr].nInited) InitTimer(thisAddr, 3);
|
if (KMem.CurVAL) RunTimer(thisAddr, GetVarData(AddrType2, Addr2));
|
else StopTimer(thisAddr);
|
KMem.CurVAL = ProcessTimer(thisAddr);
|
break;
|
case OP_MV:
|
if (KMem.CurVAL) SetVarData(AddrType2, Addr2, GetVarData(thisAddrType, thisAddr));
|
break;
|
case OP_INC:
|
if (KMem.CurVAL) SetVarData(thisAddrType, thisAddr, GetVarData(thisAddrType, thisAddr) + 1);
|
break;
|
case OP_DEC:
|
if (KMem.CurVAL) SetVarData(thisAddrType, thisAddr, GetVarData(thisAddrType, thisAddr) - 1);
|
break;
|
case OP_ADD2:
|
if (KMem.CurVAL) SetVarData(AddrType2, Addr2, GetVarData(thisAddrType, thisAddr) + GetVarData(AddrType2, Addr2));
|
break;
|
case OP_SUB2:
|
if (KMem.CurVAL) SetVarData(AddrType2, Addr2, GetVarData(AddrType2, Addr2) - GetVarData(thisAddrType, thisAddr));
|
break;
|
case OP_ADD3:
|
if (KMem.CurVAL) SetVarData(AddrType3, Addr3, GetVarData(thisAddrType, thisAddr) + GetVarData(AddrType2, Addr2));
|
break;
|
case OP_SUB3:
|
if (KMem.CurVAL) SetVarData(AddrType3, Addr3, GetVarData(thisAddrType, thisAddr) - GetVarData(AddrType2, Addr2));
|
break;
|
case OP_MUL:
|
if (KMem.CurVAL) SetVarData(AddrType3, Addr3, GetVarData(thisAddrType, thisAddr) * GetVarData(AddrType2, Addr2));
|
break;
|
case OP_DIV:
|
if (KMem.CurVAL) SetVarData(AddrType3, Addr3, GetVarData(thisAddrType, thisAddr) / GetVarData(AddrType2, Addr2));
|
break;
|
|
|
// OP_BKMV = 60,
|
// OP_COPY = 61,
|
// OP_CLR = 62,
|
|
|
default:
|
break;
|
}
|
lastScanInputVal = ProgTrace[i];
|
ProgTrace[i] = KMem.CurVAL;
|
}
|
nScanCount++;
|
return 0;
|
}
|
|
*/
|
|
