/**
  ******************************************************************************
  * @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>

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.Timers[nIndex].SV = 0;
	PLCMem.Timers[nIndex].EV = 0;
	PLCMem.Timers[nIndex].LastActTime = GetTick();
	return 0;
}

int StartTimer(int nIndex , int SV)
{
	if (nIndex >= TOTALTIMERS) return -1;	
	if (!PLCMem.Timers[nIndex].bSet)
	{
		PLCMem.Timers[nIndex].SV = SV;
		PLCMem.Timers[nIndex].EV = 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.Timers[nIndex].EV = 0;
		PLCMem.Timers[nIndex].LastActTime = GetTick();		
		PLCMem.Timers[nIndex].bSet = 0;		
	}
	return 0;
}
int ResetTimer(int nIndex)
{
	if (nIndex >= TOTALTIMERS) return -1;
	PLCMem.Timers[nIndex].EV = 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) {StartTimer(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 TimeDiff = GetTick() - PLCMem.Timers[nIndex].LastActTime;
			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 {}
			
			
			if (TimeDiff >= nScale)
			{
				int TimeDiffmS = TimeDiff / nScale;
				unsigned short NextEV = PLCMem.Timers[nIndex].EV + TimeDiffmS;
				PLCMem.Timers[nIndex].LastActTime += TimeDiffmS*nScale;
				
				if (NextEV >= PLCMem.Timers[nIndex].SV) 
				{
					NextEV = PLCMem.Timers[nIndex].SV;
					PLCMem.Timers[nIndex].bTon =1;
				}
				PLCMem.Timers[nIndex].EV = NextEV;
			}
		}
	}else 		//bSet=0;
	{
		if(PLCMem.Timers[nIndex].bTon) 
		{
			PLCMem.Timers[nIndex].bTon =	0;
		}
	}
	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.Timers[nIndex].SV;
//	return 0;	
}
int GetTimerEV(int nIndex)
{
	if (nIndex >= TOTALTIMERS) return 0;
//	ProcessTimer(nIndex);	
	return PLCMem.Timers[nIndex].EV;
//	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 InitAllDFs()
{
	for (int i=0;i<TOTAL_WDFS;i++)
	{
		PLCMem.WDFs[i]=0;
	}
	return TOTAL_WDFS;
}

int IsDF(int nIndex, int bSet)
{
	unsigned short addr1 = (nIndex&0xff0)>>4;
	unsigned char bitAddr=nIndex&0xf;
	
	if (addr1 >= TOTAL_WDFS) return 0;
	if (!GetBitValue( PLCMem.WDFs[addr1],bitAddr) && bSet)
	{
		SetBitValue(&PLCMem.WDFs[addr1],bitAddr,1);
		return 1;
	}else
	{
		SetBitValue(&PLCMem.WDFs[addr1],bitAddr,bSet);
	}
	return 0;
}

int PushInVal(void)
{
	for (int i=TOTAL_CurVAL;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 ANS(int bValue)
{
	return PLCMem.CurVAL;
}
int ORS(int bValue)
{
	return PLCMem.CurVAL;
}

int ST(int nAddr)
{
	return 0;
}

int AN(int nAddr)
{
	return 0;
}

int OR(int nAddr)
{
	return 0;
}

int AN_(int nAddr)
{
	return 0;
}

int OR_(int nAddr)
{
	return 0;
}

stPLCPROG const  prog1[]= //__attribute__((at(0X8008000)))
{
	{OP_ST,Addr_X,0},
	{OP_OR,Addr_Y,0},
	{OP_AN_,Addr_X,1},
	{OP_OUT,Addr_Y,0},
	
	{OP_ST,Addr_X,2},
	{OP_SET,Addr_R,1},
	{OP_ST,Addr_X,3},
	{OP_RESET,Addr_R,1},
	
	{OP_ST,Addr_R,1},
	{OP_PSHS,0,0},	
	{OP_AN_,Addr_Y,1},	
	{OP_TML,5,25},
	{OP_SET,Addr_Y,1},	
	{OP_RESET,Addr_Y,2},	

	{OP_POPS,0,0},
	{OP_AN,Addr_Y,1},
	{OP_TML,6,25},
	{OP_RESET,Addr_Y,1},
	{OP_SET,Addr_Y,2},
	
};

/*

	{OP_ST,Addr_R,1},
	{OP_PSHS,0,0},
	{OP_AN_,Addr_Y,1},
	{OP_TMR,5,200},
	{OP_SET,Addr_Y,1},
	{OP_POPS,0,0},
	{OP_AN,Addr_Y,1},
	{OP_TMR,6,200},
	{OP_RESET,Addr_Y,1},

*/
int nSizeProg1=sizeof(prog1)/sizeof(stPLCPROG);

char * PLCPRG=
{
	"ST X0\n\
	AN X1\n\
	ST Y0\n\
	AN Y1\n\
	ORS\n\
	AN/ X2\n\
	AN/ X3\n\
	OT Y0\n\
	OT Y1\n\
	"
};

int InitPLCPROGStat()
{
	return 0;
}

unsigned char GetAddrValue(unsigned char AddrType, unsigned short Addr)
{
		unsigned char thisValue;
		unsigned short Addr1=(Addr&0xff0)>>4;
		unsigned char bitAddr=Addr&0xf;
		switch(AddrType)
		{
			case Addr_None:
				break;
			case Addr_X:
				thisValue=GetBitValue( KMem.WX[Addr1],bitAddr);
				break;
			case Addr_Y:
				thisValue=GetBitValue( KMem.WY[Addr1],bitAddr);
				break;
			case Addr_R:
				thisValue=GetBitValue( KMem.WR[Addr1],bitAddr);
				break;
			case Addr_T:
				thisValue=PLCMem.Timers[Addr].bTon;
				break;
			case Addr_L:
				break;
			default:
				break;
		}	
		return thisValue;
}
int SetAddrValue(unsigned char AddrType, unsigned short Addr, unsigned char Value)
{
		unsigned short Addr1=(Addr&0xff0)>>4;
		unsigned char bitAddr=Addr&0xf;
		switch(AddrType)
		{
			case Addr_None:
				break;
			case Addr_X:
				SetBitValue(&KMem.WX[Addr1],bitAddr,Value);
				break;
			case Addr_Y:
				SetBitValue(&KMem.WY[Addr1],bitAddr,Value);
			break;
			case Addr_R:
				SetBitValue(&KMem.WR[Addr1],bitAddr,Value);
			break;
			case Addr_T:
				PLCMem.Timers[Addr].bTon=Value;
				break;
			case Addr_L:
				break;
			default:
				break;
		}	
		return Value;
}
int ProcessPLCPROG(const stPLCPROG * prog,int nSize)
{
	for (int i=0;i<nSize;i++)
	{
		unsigned char thisOP=prog[i].OP;
		unsigned char thisAddrType=prog[i].AddrType;
		unsigned short thisAddr=prog[i].Addr;
		switch (thisOP)
		{
			case OP_None:
				break;
			case OP_ST:
				PushInVal();
				PLCMem.CurVAL=GetAddrValue(thisAddrType, thisAddr);
				break;
			case OP_ST_:
				PushInVal();
				PLCMem.CurVAL=!GetAddrValue(thisAddrType, thisAddr);
				break;
			case OP_AN:
			  PLCMem.CurVAL = PLCMem.CurVAL&&GetAddrValue(thisAddrType, thisAddr);
				break;
			case OP_AN_:
				PLCMem.CurVAL = PLCMem.CurVAL && (!GetAddrValue(thisAddrType, thisAddr));
				break;
			case OP_OR:
				PLCMem.CurVAL = PLCMem.CurVAL || GetAddrValue(thisAddrType, thisAddr);
				break;
			case OP_OR_:
				PLCMem.CurVAL = PLCMem.CurVAL || (!GetAddrValue(thisAddrType, thisAddr));
				break;
			case OP_NOT:
				PLCMem.CurVAL = ! PLCMem.CurVAL;
				break;
			case OP_PSHS:
				PushInVal();
				break;
			case OP_POPS:
				PLCMem.CurVAL = PopOutVal();
				break;
			case OP_ANS:
				PLCMem.CurVAL = PLCMem.CurVAL && PopOutVal();
				break;
			case OP_ORS:
				PLCMem.CurVAL = PLCMem.CurVAL || PopOutVal();
				break;

			case OP_OUT:
				SetAddrValue(thisAddrType,thisAddr,PLCMem.CurVAL);
				break;
			case OP_SET:
				if (PLCMem.CurVAL) SetAddrValue(thisAddrType,thisAddr,1);
				break;
			case OP_RESET:
				if (PLCMem.CurVAL) SetAddrValue(thisAddrType,thisAddr,0);
				break;
			case OP_DF:		
				break;
			case OP_TML:
				if (!PLCMem.Timers[thisAddrType].nInited) InitTimer(thisAddrType,0);
				if (PLCMem.CurVAL) StartTimer(thisAddrType,thisAddr);
				else StopTimer(thisAddrType);
				PLCMem.CurVAL = ProcessTimer(thisAddrType);
			
				break;
			case OP_TMR:
				if (!PLCMem.Timers[thisAddrType].nInited) InitTimer(thisAddrType,1);
				if (PLCMem.CurVAL) StartTimer(thisAddrType,thisAddr);
				else StopTimer(thisAddrType);
				PLCMem.CurVAL = ProcessTimer(thisAddrType);
				
				break;
			
			
			default:
				break;
		}
	}
	return 0;
}