/**
|
******************************************************************************
|
* @file : PLCfunctions.c
|
* @brief : PLC funcstions program body
|
******************************************************************************
|
*/
|
//#include "globaldef.h"
|
#include "PLCfunctions.h"
|
#include "string.h"
|
#include "stm32f0xx_hal.h"
|
#include <core_cmInstr.h>
|
|
#if (ENABLE_PLC)
|
extern __IO uint32_t uwTick;
|
|
//unsigned short WDFs[TOTAL_WDFS];
|
|
inline unsigned int GetTick(void)
|
{
|
// unsigned short Clk1=SysTick->VAL;
|
return uwTick;
|
}
|
|
//unsigned char CurVAL;
|
//unsigned char CurVALs[TOTAL_CurVAL];
|
//stTimer Timers[TOTALTIMERS];
|
|
//unsigned short WX[13];
|
//unsigned short WY[13];
|
//unsigned short WR[64];
|
//unsigned short DT[256];
|
|
//unsigned short SDT[256];
|
|
stPLCMem PLCMem;
|
|
int InitTimer(int nIndex, int nType)
|
{
|
if (nIndex >= TOTALTIMERS) return -1;
|
PLCMem.Timers[nIndex].StatByte = 0x0010 | nType;
|
// Timers[nIndex].nType = 0;
|
PLCMem.SV[nIndex] = 0;
|
PLCMem.EV[nIndex] = 0;
|
PLCMem.Timers[nIndex].LastActTime = GetTick();
|
return 0;
|
}
|
|
int RunTimer(int nIndex , int SV)
|
{
|
if (nIndex >= TOTALTIMERS) return -1;
|
if (!PLCMem.Timers[nIndex].bSet)
|
{
|
PLCMem.SV[nIndex] = SV;
|
PLCMem.EV[nIndex]= 0;
|
PLCMem.Timers[nIndex].LastActTime = GetTick();
|
PLCMem.Timers[nIndex].bSet = 1;
|
}
|
return 0;
|
}
|
|
int StopTimer(int nIndex)
|
{
|
if (nIndex >= TOTALTIMERS) return -1;
|
if (PLCMem.Timers[nIndex].bSet)
|
{
|
PLCMem.EV[nIndex] = 0;
|
PLCMem.Timers[nIndex].LastActTime = GetTick();
|
PLCMem.Timers[nIndex].bSet = 0;
|
}
|
return 0;
|
}
|
int ResetTimer(int nIndex)
|
{
|
if (nIndex >= TOTALTIMERS) return -1;
|
PLCMem.EV[nIndex] = 0;
|
PLCMem.Timers[nIndex].bTon = 0;
|
PLCMem.Timers[nIndex].LastActTime=GetTick();
|
return 0;
|
}
|
|
int SetTimerValue(int nIndex, int bSet, int SV)
|
{
|
if (nIndex >= TOTALTIMERS) return -1;
|
if (bSet) {RunTimer(nIndex, SV);}
|
else {StopTimer(nIndex);}
|
return PLCMem.Timers[nIndex].bTon;
|
}
|
|
int ProcessTimer(int nIndex)
|
{
|
if (nIndex >= TOTALTIMERS) return -1;
|
if (!PLCMem.Timers[nIndex].nInited) return 0;
|
if (PLCMem.Timers[nIndex].bSet) // bSet =1;
|
{
|
if (!PLCMem.Timers[nIndex].bTon)
|
{
|
int nScale = TICK_OF_MS;
|
if (PLCMem.Timers[nIndex].nScale == 0)
|
{nScale = TICK_OF_MS;
|
}else if (PLCMem.Timers[nIndex].nScale == 1)
|
{nScale = TICK_OF_RS;
|
}else if (PLCMem.Timers[nIndex].nScale == 2)
|
{nScale = TICK_OF_XS;
|
}else if (PLCMem.Timers[nIndex].nScale == 3)
|
{nScale = TICK_OF_YS;
|
}else {}
|
|
int TimeDiff = GetTick() - PLCMem.Timers[nIndex].LastActTime;
|
if (TimeDiff < 0) { TimeDiff = nScale;}
|
if (TimeDiff >= nScale)
|
{
|
int TimeDiffmS = TimeDiff / nScale;
|
unsigned short NextEV = PLCMem.EV[nIndex] + TimeDiffmS;
|
PLCMem.Timers[nIndex].LastActTime += TimeDiffmS*nScale;
|
|
if (NextEV >= PLCMem.SV[nIndex])
|
{
|
NextEV = PLCMem.SV[nIndex];
|
PLCMem.Timers[nIndex].bTon =1;
|
}
|
PLCMem.EV[nIndex] = NextEV;
|
}
|
}
|
}else //bSet=0;
|
{
|
if(PLCMem.Timers[nIndex].bTon)
|
{
|
PLCMem.Timers[nIndex].bTon = 0;
|
}
|
}
|
SetCoilValue(KLCoilTypeT, nIndex, PLCMem.Timers[nIndex].bTon);
|
return PLCMem.Timers[nIndex].bTon;
|
}
|
|
int IsTimerOn(int nIndex)
|
{
|
if (nIndex >= TOTALTIMERS) return 0;
|
ProcessTimer(nIndex);
|
return PLCMem.Timers[nIndex].bTon;
|
|
}
|
|
int GetTimerSV(int nIndex)
|
{
|
if (nIndex >= TOTALTIMERS) return 0;
|
// ProcessTimer(nIndex);
|
return PLCMem.SV[nIndex];
|
// return 0;
|
}
|
int GetTimerEV(int nIndex)
|
{
|
if (nIndex >= TOTALTIMERS) return 0;
|
// ProcessTimer(nIndex);
|
return PLCMem.EV[nIndex];
|
// return 0;
|
}
|
|
int PushInVal(void)
|
{
|
for (int i=TOTAL_CurVAL -1 ;i>0;i--)
|
{
|
PLCMem.CurVALs[i]=PLCMem.CurVALs[i-1];
|
}
|
PLCMem.CurVALs[0]=PLCMem.CurVAL;
|
return PLCMem.CurVAL;
|
}
|
|
int PopOutVal(void)
|
{
|
unsigned char theVAL=PLCMem.CurVALs[0];
|
for (int i=0;i<TOTAL_CurVAL-1;i++)
|
{
|
PLCMem.CurVALs[i]=PLCMem.CurVALs[i+1];
|
}
|
return theVAL;
|
}
|
|
|
int InitPLC()
|
{
|
PLCMem.nScanCount=0;
|
for (int i=0;i<256;i++){PLCMem.ProgTrace[i]=0;}
|
for (int i=0;i<16;i++) {
|
KMem.WR[i]=0;
|
}
|
for (int i=0;i<256;i++) {
|
KMem.DT[i]=0;
|
}
|
return 0;
|
}
|
|
int StartPLC()
|
{
|
PLCMem.nScanCount = 0;
|
for (int i=0;i<256;i++){PLCMem.ProgTrace[i]=0;}
|
for (int i=0;i<16;i++) {
|
KMem.WR[i]=0;
|
}
|
for (int i=0;i<256;i++) {
|
KMem.DT[i]=0;
|
}
|
for (int i=0;i<TOTALTIMERS;i++){
|
PLCMem.Timers[i].nInited=0;
|
}
|
|
PLCMem.bPLCRunning=1;
|
KMRunStat.WorkMode2=PLCMem.bPLCRunning;
|
return 0;
|
}
|
|
int StopPLC()
|
{
|
PLCMem.bPLCRunning=0;
|
for (int i=0;i<KLDataWXCount;i++) KMem.WY[i]=0;
|
for (int i=0;i<KLDataWLCount;i++) KMem.WLY[i]=0;
|
KMRunStat.WorkMode2=PLCMem.bPLCRunning;
|
return 0;
|
}
|
|
inline void SetAddrBit(unsigned short * pW, unsigned char bitAddr)
|
{
|
(*pW)|=1<<(bitAddr&0xf);
|
}
|
|
inline void ResetBit(unsigned short * pW, unsigned char bitAddr)
|
{
|
(*pW)&=~(1<<(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&(1<<(bitAddr&0xf))) return 1;
|
else return 0;
|
}
|
|
|
int ProcessPLCBinProg(const stBinInstrcn1 * pBinProg, int nProgSteps)
|
{
|
if (!PLCMem.bPLCRunning) return 0;
|
|
if (PLCMem.nScanCount == 0) {
|
SetCoilValue(KLCoilTypeSR, 0, 0);
|
SetCoilValue(KLCoilTypeSR, 1, 1);
|
SetCoilValue(KLCoilTypeSR, 10, 1);
|
SetCoilValue(KLCoilTypeSR, 11, 0);
|
SetCoilValue(KLCoilTypeSR, 13, 1);
|
}
|
else
|
{
|
SetCoilValue(KLCoilTypeSR, 0, 0);
|
SetCoilValue(KLCoilTypeSR, 1, 1);
|
SetCoilValue(KLCoilTypeSR, 10, 1);
|
SetCoilValue(KLCoilTypeSR, 11, 0);
|
SetCoilValue(KLCoilTypeSR, 13, 0);
|
}
|
for (int i = 0; i < TOTAL_CurVAL; i++) {
|
PLCMem.CurVALs[i] = 0;
|
}
|
int CurPos = 0;
|
// stBinInstrcn1 * pBinInstrcn1;
|
stBinInstrcn15 * pBinInstrcn15;
|
stBinInstrcn2 * pBinInstrcn2;
|
stBinInstrcn3 * pBinInstrcn3;
|
|
int lastScanInputVal = 1;//??????,????????,? ?? ???
|
|
const stBinInstrcn1 * pBinInstrcn = pBinProg;
|
|
while (CurPos < nProgSteps)
|
{
|
unsigned int nNextPos = 1;
|
unsigned int thisOP = pBinInstrcn[CurPos].nOp;
|
// unsigned int nParamCount = 0
|
unsigned char thisAddrType = pBinInstrcn[CurPos].nParamType;
|
unsigned short thisAddr = pBinInstrcn[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:
|
PLCMem.CurVAL = !PLCMem.CurVAL;
|
break;
|
case OP_ANS:
|
PLCMem.CurVAL = PopOutVal() && PLCMem.CurVAL;
|
break;
|
case OP_ORS:
|
PLCMem.CurVAL = PopOutVal() || PLCMem.CurVAL;
|
break;
|
case OP_PSHS:
|
PushInVal();
|
break;
|
case OP_RDS:
|
PLCMem.CurVAL = PLCMem.CurVALs[0] != 0;
|
break;
|
case OP_POPS:
|
PLCMem.CurVAL = PopOutVal();
|
break;
|
case OP_DF:
|
PLCMem.CurVAL = PLCMem.CurVAL && !lastScanInputVal;
|
break;
|
case OP_DF_:
|
PLCMem.CurVAL = !PLCMem.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();
|
PLCMem.CurVAL = GetCoilValue(thisAddrType, thisAddr);
|
break;
|
case OP_ST_:
|
PushInVal();
|
PLCMem.CurVAL = !GetCoilValue(thisAddrType, thisAddr);
|
break;
|
case OP_AN:
|
PLCMem.CurVAL = PLCMem.CurVAL&&GetCoilValue(thisAddrType, thisAddr);
|
break;
|
case OP_AN_:
|
PLCMem.CurVAL = PLCMem.CurVAL && (!GetCoilValue(thisAddrType, thisAddr));
|
break;
|
case OP_OR:
|
PLCMem.CurVAL = PLCMem.CurVAL || GetCoilValue(thisAddrType, thisAddr);
|
break;
|
case OP_OR_:
|
PLCMem.CurVAL = PLCMem.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, PLCMem.CurVAL);
|
break;
|
case OP_SET:
|
if (PLCMem.CurVAL) SetCoilValue(thisAddrType, thisAddr, 1);
|
break;
|
case OP_RESET:
|
if (PLCMem.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:
|
pBinInstrcn2 = (stBinInstrcn2 *)&pBinInstrcn[CurPos];
|
thisAddrType = pBinInstrcn2->nParamType1;
|
|
switch (thisOP)
|
{
|
case OP_ST_EQ:
|
PushInVal();
|
PLCMem.CurVAL = (GetVarData(thisAddrType, thisAddr) == GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_ST_NE:
|
PushInVal();
|
PLCMem.CurVAL = (GetVarData(thisAddrType, thisAddr) != GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_ST_LT:
|
PushInVal();
|
PLCMem.CurVAL = (GetVarData(thisAddrType, thisAddr) < GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_ST_GT:
|
PushInVal();
|
PLCMem.CurVAL = (GetVarData(thisAddrType, thisAddr) > GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_ST_LE:
|
PushInVal();
|
PLCMem.CurVAL = (GetVarData(thisAddrType, thisAddr) <= GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_ST_GE:
|
PushInVal();
|
PLCMem.CurVAL = (GetVarData(thisAddrType, thisAddr) >= GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_AN_EQ:
|
PLCMem.CurVAL = PLCMem.CurVAL && (GetVarData(thisAddrType, thisAddr) == GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_AN_NE:
|
PLCMem.CurVAL = PLCMem.CurVAL && (GetVarData(thisAddrType, thisAddr) != GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_AN_LT:
|
PLCMem.CurVAL = PLCMem.CurVAL && (GetVarData(thisAddrType, thisAddr) < GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_AN_GT:
|
PLCMem.CurVAL = PLCMem.CurVAL && (GetVarData(thisAddrType, thisAddr) > GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_AN_LE:
|
PLCMem.CurVAL = PLCMem.CurVAL && (GetVarData(thisAddrType, thisAddr) <= GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_AN_GE:
|
PLCMem.CurVAL = PLCMem.CurVAL && (GetVarData(thisAddrType, thisAddr) >= GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
|
case OP_OR_EQ:
|
PLCMem.CurVAL = PLCMem.CurVAL || (GetVarData(thisAddrType, thisAddr) == GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_OR_NE:
|
PLCMem.CurVAL = PLCMem.CurVAL || (GetVarData(thisAddrType, thisAddr) != GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_OR_LT:
|
PLCMem.CurVAL = PLCMem.CurVAL || (GetVarData(thisAddrType, thisAddr) < GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_OR_GT:
|
PLCMem.CurVAL = PLCMem.CurVAL || (GetVarData(thisAddrType, thisAddr) > GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_OR_LE:
|
PLCMem.CurVAL = PLCMem.CurVAL || (GetVarData(thisAddrType, thisAddr) <= GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
case OP_OR_GE:
|
PLCMem.CurVAL = PLCMem.CurVAL || (GetVarData(thisAddrType, thisAddr) >= GetVarData(pBinInstrcn2->nParamType2, pBinInstrcn2->nParamAddr2));
|
break;
|
|
default:
|
break;
|
}
|
nNextPos = 2;
|
break;
|
// ???
|
case OP_TML:
|
case OP_TMR:
|
case OP_TMX:
|
case OP_TMY:
|
pBinInstrcn15 = (stBinInstrcn15 *)(&pBinInstrcn[CurPos]);
|
{
|
unsigned char thisNum= pBinInstrcn15->nOpNum;
|
thisAddrType = pBinInstrcn15->nParamType1;
|
thisAddr = pBinInstrcn15->nParamAddr1;
|
switch (thisOP)
|
{
|
case OP_TML:
|
if (!PLCMem.Timers[thisNum].nInited) InitTimer(thisNum, 0);
|
if (PLCMem.CurVAL) RunTimer(thisNum, GetVarData(thisAddrType, thisAddr));
|
else StopTimer(thisNum);
|
PLCMem.CurVAL = ProcessTimer(thisNum);
|
|
break;
|
case OP_TMR:
|
if (!PLCMem.Timers[thisNum].nInited) InitTimer(thisNum, 1);
|
if (PLCMem.CurVAL) RunTimer(thisNum, GetVarData(thisAddrType, thisAddr));
|
else StopTimer(thisNum);
|
PLCMem.CurVAL = ProcessTimer(thisNum);
|
break;
|
case OP_TMX:
|
if (!PLCMem.Timers[thisNum].nInited) InitTimer(thisNum, 2);
|
if (PLCMem.CurVAL) RunTimer(thisNum, GetVarData(thisAddrType, thisAddr));
|
else StopTimer(thisNum);
|
PLCMem.CurVAL = ProcessTimer(thisNum);
|
|
break;
|
case OP_TMY:
|
if (!PLCMem.Timers[thisNum].nInited) InitTimer(thisNum, 3);
|
if (PLCMem.CurVAL) RunTimer(thisNum, GetVarData(thisAddrType, thisAddr));
|
else StopTimer(thisNum);
|
PLCMem.CurVAL = ProcessTimer(thisNum);
|
break;
|
default:
|
break;
|
}
|
|
}
|
nNextPos = 2;
|
break;
|
// 1 ??????
|
case OP_INC:
|
case OP_DEC:
|
pBinInstrcn15 = (stBinInstrcn15 *)(&pBinInstrcn[CurPos]);
|
thisAddrType = pBinInstrcn15->nParamType1;
|
thisAddr = pBinInstrcn15->nParamAddr1;
|
nNextPos = 2;
|
switch (thisOP)
|
{
|
case OP_INC:
|
if (PLCMem.CurVAL) SetVarData(thisAddrType, thisAddr, GetVarData(thisAddrType, thisAddr) + 1);
|
break;
|
case OP_DEC:
|
if (PLCMem.CurVAL) SetVarData(thisAddrType, thisAddr, GetVarData(thisAddrType, thisAddr) - 1);
|
break;
|
|
default:
|
break;
|
}
|
break;
|
// 2??????
|
case OP_MV:
|
case OP_ADD2:
|
case OP_SUB2:
|
pBinInstrcn2 = (stBinInstrcn2 *)(&pBinInstrcn[CurPos]);
|
{
|
int nParamType2, nParamAddr2;
|
thisAddrType = pBinInstrcn2->nParamType1;
|
thisAddr = pBinInstrcn2->nParamAddr1;
|
nParamType2 = pBinInstrcn2->nParamType2;
|
nParamAddr2 = pBinInstrcn2->nParamAddr2;
|
|
switch (thisOP)
|
{
|
case OP_MV:
|
if (PLCMem.CurVAL) SetVarData(nParamType2, nParamAddr2, GetVarData(thisAddrType, thisAddr));
|
break;
|
case OP_ADD2:
|
if (PLCMem.CurVAL) SetVarData(nParamType2, nParamAddr2, GetVarData(thisAddrType, thisAddr) + GetVarData(nParamType2, nParamAddr2));
|
break;
|
case OP_SUB2:
|
if (PLCMem.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:
|
pBinInstrcn3 = (stBinInstrcn3 *)(&pBinInstrcn[CurPos]);
|
int nParamType2, nParamAddr2;
|
int nParamType3, nParamAddr3;
|
thisAddrType = pBinInstrcn3->nParamType1;
|
thisAddr = pBinInstrcn3->nParamAddr1;
|
nParamType2 = pBinInstrcn3->nParamType2;
|
nParamAddr2 = pBinInstrcn3->nParamAddr2;
|
nParamType3 = pBinInstrcn3->nParamType3;
|
nParamAddr3 = pBinInstrcn3->nParamAddr3;
|
switch (thisOP)
|
{
|
case OP_ADD3:
|
if (PLCMem.CurVAL) SetVarData(nParamType3, nParamAddr3, GetVarData(thisAddrType, thisAddr) + GetVarData(nParamType2, nParamAddr2));
|
break;
|
case OP_SUB3:
|
if (PLCMem.CurVAL) SetVarData(nParamType3, nParamAddr3, GetVarData(thisAddrType, thisAddr) - GetVarData(nParamType2, nParamAddr2));
|
break;
|
case OP_MUL:
|
if (PLCMem.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 (PLCMem.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 = GetBitValue( PLCMem.ProgTrace[CurPos>>4],CurPos&0xf); //GetBitValue(PLCMem.WDFs);
|
SetBitValue( &PLCMem.ProgTrace[CurPos>>4],CurPos&0xf, PLCMem.CurVAL);
|
|
// lastScanInputVal = PLCMem.ProgTrace[CurPos]; //GetBitValue(PLCMem.WDFs);
|
// PLCMem.ProgTrace[CurPos] = PLCMem.CurVAL;
|
CurPos += nNextPos;
|
}
|
PLCMem.nScanCount++;
|
return CurPos;
|
}
|
#endif // ENABLE_PLC
|
