/*
***********************************************************************************************************
													  Amos
										  The Real_Time Operation System
												   Multi Task
								 (c) Copyright 1998-2002, ShangYaoHui, Shenzhen
											  All Right Reserved
												  VERSION 6.01

" By  : 商耀揮(ShangYaoHui)
 create time: 2002-7-1 22:26:27  
***********************************************************************************************************
*/

/************ head file list *************/
#include "envopt.h"        /* environment options */
#include "envdep.h"        /* environment dependent */
#include "envind.h"        /* environment independent */

#include "gen.h"           /* general */
#include "cm5.h"           /* common functions */
#include "ssi.h"           /* system services */

/* header/extern include files (.x) */

#include "gen.x"           /* general */
#include "cm5.x"           /* common functions */
#include "ssi.x"           /* system services */

#include "cm_llist.h"
#include "cm_llist.x"

#ifdef WIN32
	#include "winbase.h"
	#include "winsock2.h"
#endif

#include "rx.h"
#include "rx.x"

#include "rx_msg.h"
#include "rx_msg.x"

#include "lb_cm.h"
#include "lb_cm.x"

#include "lb_recv.h"
#include "lb_recv.x"
#include "lb_xmit.h"
#include "lb_xmit.x"
#include "lb_msg.h"
#include "lb_msg.x"

#include "lb_bdy1.h"
#include "lb_bdy1.x"
#include "lb_bdy2.h"
#include "lb_bdy2.x"
#include "lb_bdy4.h"
#include "lb_bdy3.h"
#include "lb_bdy3.x"
#include "lb_bdy4.h"
#include "lb_bdy4.h"
#include "lb_bdy4.x"
#include "lb_bdy5.h"
#include "lb_bdy5.x"
/************* const define **************/

/******** import variable declare ********/

/******* gloable variable declare ********/

/*********** function declare ************/

/********** function prototype ***********/

static unsigned int crc_table[256] = 
{
	0x0000, 0xc0c1, 0xc181, 0x0140,
	0xc301, 0x03c0, 0x0280, 0xc241,
	0xc601, 0x06c0, 0x0780, 0xc741,
	0x0500, 0xc5c1, 0xc481, 0x0440,
	0xcc01, 0x0cc0, 0x0d80, 0xcd41,
	0x0f00, 0xcfc1, 0xce81, 0x0e40,
	0x0a00, 0xcac1, 0xcb81, 0x0b40,
	0xc901, 0x09c0, 0x0880, 0xc841,
	0xd801, 0x18c0, 0x1980, 0xd941,
	0x1b00, 0xdbc1, 0xda81, 0x1a40,
	0x1e00, 0xdec1, 0xdf81, 0x1f40,
	0xdd01, 0x1dc0, 0x1c80, 0xdc41,
	0x1400, 0xd4c1, 0xd581, 0x1540,
	0xd701, 0x17c0, 0x1680, 0xd641,
	0xd201, 0x12c0, 0x1380, 0xd341,
	0x1100, 0xd1c1, 0xd081, 0x1040,
	0xf001, 0x30c0, 0x3180, 0xf141,
	0x3300, 0xf3c1, 0xf281, 0x3240,
	0x3600, 0xf6c1, 0xf781, 0x3740,
	0xf501, 0x35c0, 0x3480, 0xf441,
	0x3c00, 0xfcc1, 0xfd81, 0x3d40,
	0xff01, 0x3fc0, 0x3e80, 0xfe41,
	0xfa01, 0x3ac0, 0x3b80, 0xfb41,
	0x3900, 0xf9c1, 0xf881, 0x3840,
	0x2800, 0xe8c1, 0xe981, 0x2940,
	0xeb01, 0x2bc0, 0x2a80, 0xea41,
	0xee01, 0x2ec0, 0x2f80, 0xef41,
	0x2d00, 0xedc1, 0xec81, 0x2c40,
	0xe401, 0x24c0, 0x2580, 0xe541,
	0x2700, 0xe7c1, 0xe681, 0x2640,
	0x2200, 0xe2c1, 0xe381, 0x2340,
	0xe101, 0x21c0, 0x2080, 0xe041,
	0xa001, 0x60c0, 0x6180, 0xa141,
	0x6300, 0xa3c1, 0xa281, 0x6240,
	0x6600, 0xa6c1, 0xa781, 0x6740,
	0xa501, 0x65c0, 0x6480, 0xa441,
	0x6c00, 0xacc1, 0xad81, 0x6d40,
	0xaf01, 0x6fc0, 0x6e80, 0xae41,
	0xaa01, 0x6ac0, 0x6b80, 0xab41,
	0x6900, 0xa9c1, 0xa881, 0x6840,
	0x7800, 0xb8c1, 0xb981, 0x7940,
	0xbb01, 0x7bc0, 0x7a80, 0xba41,
	0xbe01, 0x7ec0, 0x7f80, 0xbf41,
	0x7d00, 0xbdc1, 0xbc81, 0x7c40,
	0xb401, 0x74c0, 0x7580, 0xb541,
	0x7700, 0xb7c1, 0xb681, 0x7640,
	0x7200, 0xb2c1, 0xb381, 0x7340,
	0xb101, 0x71c0, 0x7080, 0xb041,
	0x5000, 0x90c1, 0x9181, 0x5140,
	0x9301, 0x53c0, 0x5280, 0x9241,
	0x9601, 0x56c0, 0x5780, 0x9741,
	0x5500, 0x95c1, 0x9481, 0x5440,
	0x9c01, 0x5cc0, 0x5d80, 0x9d41,
	0x5f00, 0x9fc1, 0x9e81, 0x5e40,
	0x5a00, 0x9ac1, 0x9b81, 0x5b40,
	0x9901, 0x59c0, 0x5880, 0x9841,
	0x8801, 0x48c0, 0x4980, 0x8941,
	0x4b00, 0x8bc1, 0x8a81, 0x4a40,
	0x4e00, 0x8ec1, 0x8f81, 0x4f40,
	0x8d01, 0x4dc0, 0x4c80, 0x8c41,
	0x4400, 0x84c1, 0x8581, 0x4540,
	0x8701, 0x47c0, 0x4680, 0x8641,
	0x8201, 0x42c0, 0x4380, 0x8341,
	0x4100, 0x81c1, 0x8081, 0x4040
};
#if 0
U CheckCRC(unsigned char cSerID,unsigned char *cData,unsigned char cData_len)reentrant
{
	unsigned int s;
	unsigned int w;
	signed int c;

	s = 1;
	for(w=0;w<cData_len-2;w++)
	{
		c = *cData++;
		s =( crc_table[(s^c) & 0xFF] ^ (s / 256)) ;
	}/*for*/
	if(cSerID == CHECKSUM)
	{
		*cData =  (unsigned char)(s>>8) & 0x7f;
		*(cData+1) = (unsigned char)(s & 0x00ff) & 0x7f;
		return OBJECT_TRUE;
	}
	else
	{
		if((*cData != ((s>>8) & 0x7f)) || (*(cData+1) != (s & 0x7f)))
		{
			return OBJECT_FALSE;
		}
		else
		{
			return OBJECT_TRUE;
		}
	}
}/*calc_crc*/
#endif

S16 lbChkCrc(Data * data, MsgLen len)
{
	U32 s;
	U32 w;
	S32 c;
	if(data == NULLP || len < 3)
	{
		RXLOGERROR(ENTSC, 0, data , "invalid param");
		RETVALUE(RFAILED);
	}

	s = 1;
	for(w=0;w<(U32)len-2;w++)
	{
		c = *data++;
		s =( crc_table[(s^c) & 0xFF] ^ (s / 256)) ;
	}/*for*/
	if((*data != ((s>>8) & 0x7f)) || (*(data+1) != (s & 0x7f)))
	{
		RETVALUE(RFAILED);
	}
	else
	{
		RETVALUE(ROK);
	}
}

S16 lbFillCrc(Data * data, MsgLen len)
{
	U32 s;
	U32 w;
	S32 c;
	if(data == NULLP || len < 3)
	{
		RXLOGERROR(ENTSC, 0, data , "invalid param");
		RETVALUE(RFAILED);
	}

	s = 1;
	for(w=0;w<(U32)len-2;w++)
	{
		c = *data++;
		s =( crc_table[(s^c) & 0xFF] ^ (s / 256)) ;
	}/*for*/


	*data =  (U8)(s>>8) & 0x7f;
	*(data+1) = (U8)(s & 0xff) & 0x7f;
	RETVALUE(ROK);
}

U32 getMachNum(void)
{
	RETVALUE(CFG_MACH_NUM);
}


ScCommCb_s * createScCommCb(EquCfgEntry_s * equ)
{
	ScCommCb_s * scCommCb;
	DCB dcb;
	COMSTAT commStat;
	S32 err, len, actualLen;


	if(ROK != SGetSBuf(0, 0, (Data **)&scCommCb, sizeof(ScCommCb_s)))
	{
		RXLOGERROR(0, 0, 0, "ERROR");
		RETVALUE(NULLP);
	}

	sprintf(scCommCb->commName, "COM%d", equ->entry.channelId);


	/* modify by shang 2002-7-10 13:47:37 */
#if 0 /* last code */
	scCommCb->comm = CreateFile(scCommCb->commName,
								GENERIC_READ|GENERIC_WRITE,
								0,
								NULLP,OPEN_EXISTING,
								FILE_FLAG_OVERLAPPED,
								NULLP);

#else /* new code */
	scCommCb->comm = CreateFile(scCommCb->commName,
								GENERIC_READ|GENERIC_WRITE,
								0,
								NULLP,OPEN_EXISTING,
								FILE_FLAG_RANDOM_ACCESS,
								NULLP);

#endif /* end modify */

	/* modify by shang is over 2002-7-10 13:47:37*/


	if(scCommCb->comm == INVALID_HANDLE_VALUE)
	{
		SPutSBuf(0, 0, (Data *)scCommCb, sizeof(ScCommCb_s));
		RXLOGERROR(0, 0, 0, "Falte error: can not open comm");
		RETVALUE(NULLP);
	}

	SetCommMask(scCommCb->comm, EV_RXCHAR | EV_TXEMPTY);                         
	SetupComm( scCommCb->comm, 2048, 2048);

	PurgeComm( scCommCb->comm, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR );

	scCommCb->timeOut.ReadIntervalTimeout = -1;
	scCommCb->timeOut.ReadTotalTimeoutConstant = 10000;
	scCommCb->timeOut.ReadTotalTimeoutMultiplier = 1000;
	scCommCb->timeOut.WriteTotalTimeoutConstant = 10000;
	scCommCb->timeOut.WriteTotalTimeoutMultiplier = 1000;
	SetCommTimeouts(scCommCb->comm, &scCommCb->timeOut);

	GetCommState(scCommCb->comm, &dcb);

	dcb.BaudRate = CBR_9600;

	dcb.ByteSize = 8;
	dcb.Parity = NOPARITY;
	dcb.StopBits = ONESTOPBIT ;
	dcb.fBinary = TRUE;
	dcb.fParity = FALSE;

	dcb.fDtrControl = TRUE;
	dcb.fRtsControl = FALSE;

	SetCommState(scCommCb->comm, &dcb);
	scCommCb->equ = equ;
	scCommCb->crrntSide = 0;

	err = ClearCommError(scCommCb->comm, &err, &commStat );
	if(err == 0)
	{
		err = GetLastError();
	}
	len = commStat.cbInQue;

	if(len > 0)
	{
		Data * recvBuf;

		if(ROK != SGetSBuf(0, 0, &recvBuf, len))
		{
			RXLOGERROR(ENTSC, 0, 0, "Error: no buf to recv comm message");
			RETVALUE(NULLP);
		}

		ReadFile(scCommCb->comm, recvBuf, len, &actualLen, NULLP);
		SPutSBuf(0, 0, recvBuf, len);
	}

	RETVALUE(scCommCb);
}

U8 getGunNum(U32 machId)
{
	RETVALUE(3);
}

U8 getOilType(U32 machId, U8 sideId, U8 gunId)
{
	RETVALUE(90);
}

U32 getPrice(U8 oilType)
{
	RETVALUE(200);
}

U8 getSideNum(U32 machId)
{
	RETVALUE(1);
}

S16 lbCmGetCmdNode(TranCb_s * tran, CmdMsg_s ** ret_cmdNode)
{
	CmdMsg_s * cmdNode;

	if(ROK != SGetSBuf(0, 0, (Data **)&cmdNode, sizeof(CmdMsg_s)))
	{
		RXLOGERROR(0, 0, 0, "ERROR");
		RETVALUE(RFAILED);
	}
	memset(cmdNode, 0, sizeof(CmdMsg_s));
	cmLListAdd2Tail(&tran->cmdLst, (CmLList *)cmdNode);
	cmdNode->tran = tran;
	*ret_cmdNode = cmdNode;
	RETVALUE(ROK);
}

S16 lbCmDestroyCmdNode(CmdMsg_s * cmdNode)
{
	if(cmdNode == NULLP)
	{
		RXLOGERROR(0, 0, 0, "ERROR");
		RETVALUE(RFAILED);
	}

	if(cmdNode->msg)
	{
		SPutMsg(cmdNode->msg);
	}

	cmLListDelFrm(&cmdNode->tran->cmdLst, (CmLList *)cmdNode);

	if(cmLListLen(&cmdNode->tran->cmdLst) == 0)
	{
		cmLListDelFrm(&cmdNode->tran->entry->tranList, (CmLList *)cmdNode->tran);
		if(cmLListLen(&cmdNode->tran->entry->tranList) == 0)
		{
			cmLListDelFrm(&rxCb.rqstList, (CmLList *)cmdNode->tran->entry);
			SPutSBuf(0, 0, (Data *)cmdNode->tran->entry, sizeof(RxCmdEntry_s));

		}
		SPutSBuf(0, 0, (Data *)cmdNode->tran, sizeof(TranCb_s));
	}
	SPutSBuf(0, 0, (Data *)cmdNode, sizeof(CmdMsg_s));

	RETVALUE(ROK);
}

TranCb_s * lbCmGetTran(RxCmdEntry_s * entry, EquCfgEntry_s * equ)
{
	TranCb_s * tran;

	if(ROK != SGetSBuf(0, 0, (Data **)&tran, sizeof(TranCb_s)))
	{
		RXLOGERROR(0, 0, 0, "ERROR");
		RETVALUE(NULLP);
	}
	cmLListInit(&tran->cmdLst);
	tran->transStat = ROK;
	tran->equ = equ;
	tran->entry = entry;
	cmLListAdd2Tail(&entry->tranList, (CmLList *)tran);

	RETVALUE(tran);
}


S16 lbCmDestroyTran(TranCb_s * tran)
{
	CmdMsg_s * cmdNode, * tempNode;

	cmdNode = (CmdMsg_s *)cmLListFirst(&tran->cmdLst);
	while(NULLP != cmdNode)
	{
		tempNode = (CmdMsg_s *)cmLListNext(&tran->cmdLst);

		lbCmDestroyCmdNode(cmdNode);
		cmdNode = tempNode;
	}
	cmLListDelFrm(&tran->entry->tranList, (CmLList *)tran);
	if(cmLListLen(&tran->entry->tranList) == 0)
	{
		cmLListDelFrm(&rxCb.rqstList, (CmLList *)tran->entry);
		SPutSBuf(0, 0, (Data *)tran->entry, sizeof(RxCmdEntry_s));
	}
	SPutSBuf(0, 0, (Data *)tran, sizeof(TranCb_s));

	RETVALUE(ROK);
}

S16 lbCmGetCmdEntry(U8 rqstId, U8 type, RxCmdEntry_s ** entry)
{
	RxCmdEntry_s * cmdEntry;

	if(ROK != SGetSBuf(0, 0, (Data **)&cmdEntry, sizeof(RxCmdEntry_s)))
	{
		RXLOGERROR(0, 0, 0, "ERROR");
		RETVALUE(RFAILED);
	}
	cmdEntry->cmdType = type;
	cmdEntry->rqstId = rqstId;
	cmdEntry->errCode = 0;
	cmLListInit(&cmdEntry->tranList);
	cmLListAdd2Tail(&rxCb.rqstList, (CmLList *)cmdEntry);
	*entry = cmdEntry;
	RETVALUE(ROK);
}
S16 lbCmdDestroyCmdEntry(RxCmdEntry_s * rqst)
{
	TranCb_s *tran, * temp;

	tran = (TranCb_s *)cmLListFirst(&rqst->tranList);
	while(NULLP != tran)
	{
		temp = (TranCb_s *)cmLListNext(&rqst->tranList);
		lbCmDestroyTran(tran);
		tran = temp;
	}
	cmLListDelFrm(&rxCb.rqstList, (CmLList *)rqst);

	RETVALUE(ROK);
}



S16 lbCmBuildCmdA(EquCfgEntry_s * equ, TranCb_s * tran, U32 action, U8 cmdCode)
{
	CmdMsg_s * cmdNode;
	MsgA_s cmd;
	ScCommCb_s * scCommCb;
	Buffer * msg;

	scCommCb = equ->scCommCb;

	if(ROK != lbCmGetCmdNode(tran, &cmdNode))
	{
		RXLOGERROR(0, 0, 0, "ERROR");
		RETVALUE(RFAILED);
	}

	if(ROK != SGetMsg(0, 0, &msg))
	{
		SPutSBuf(0, 0, (Data *)cmdNode, sizeof(CmdMsg_s));
		RXLOGERROR(0, 0, 0, "ERROR");
		RETVALUE(RFAILED);
	}


	cmd.hdr.frameStart = 0x55aa;
	cmd.hdr.dataLen = 2;
	cmd.hdr.sideId = equ->entry.sideId;
	cmd.cmd = cmdCode;

	SAddPstMsgMult((Data *)&cmd, (MsgLen)(cmd.hdr.dataLen + 3), msg);

	cmdNode->msg = msg;
	cmdNode->msgCode = cmdCode;
	cmdNode->action = action;
	cmdNode->machId = equ->entry.machId;
	cmdNode->sideId = equ->entry.sideId;
	cmdNode->gunId = equ->entry.pGunId;
	cmdNode->dir = CMD_DIR;
	cmdNode->chId = equ->entry.channelId;
	cmdNode->stat = RDY_SEND;

	cmdNode->timer = 1;
	cmdNode->retry = CMD_RETRY_TIMES;
	cmdNode->loadTimer = CMD_RETRY_TIMEOUT;

	RETVALUE(ROK);

}

S16 lbCmBuildCmdB(EquCfgEntry_s * equ, TranCb_s * tran, U8 val, U32 action, U8 cmdCode)
{
	CmdMsg_s * cmdNode;
	MsgB_s cmd;
	ScCommCb_s * scCommCb;
	Buffer * msg;

	scCommCb = equ->scCommCb;

	if(ROK != lbCmGetCmdNode(tran, &cmdNode))
	{
		RXLOGERROR(0, 0, 0, "ERROR");
		RETVALUE(RFAILED);
	}

	if(ROK != SGetMsg(0, 0, &msg))
	{
		SPutSBuf(0, 0, (Data *)cmdNode, sizeof(CmdMsg_s));
		RXLOGERROR(0, 0, 0, "ERROR");
		RETVALUE(RFAILED);
	}


	cmd.hdr.frameStart = 0x55aa;
	cmd.hdr.dataLen = 3;
	cmd.hdr.sideId = equ->entry.sideId;
	cmd.cmd = cmdCode;
	cmd.val = val;

	SAddPstMsgMult((Data *)&cmd, (MsgLen)(cmd.hdr.dataLen + 3), msg);

	cmdNode->msg = msg;
	cmdNode->msgCode = cmdCode;
	cmdNode->action = action;
	cmdNode->machId = equ->entry.machId;
	cmdNode->sideId = equ->entry.sideId;
	cmdNode->gunId = equ->entry.pGunId;
	cmdNode->dir = CMD_DIR;
	cmdNode->chId = equ->entry.channelId;
	cmdNode->stat = RDY_SEND;
	cmdNode->timer = 1;
	cmdNode->retry = CMD_RETRY_TIMES;
	if(cmdNode->msgCode == 0xda)
	{
		cmdNode->loadTimer = 5;
	}
	else
	{

		cmdNode->loadTimer = CMD_RETRY_TIMEOUT;
	}

	RETVALUE(ROK);

}

S16 lbCmBuildCfmCmd(EquCfgEntry_s * equ, TranCb_s * tran, U32 rqstType, U32 action, U8 cmdCode)
{
	CmdMsg_s * cmdNode;
	MsgB_s cmd;
	ScCommCb_s * scCommCb;
	Buffer * msg;

	scCommCb = equ->scCommCb;

	if(ROK != lbCmGetCmdNode(tran, &cmdNode))
	{
		RXLOGERROR(0, 0, 0, "ERROR");
		RETVALUE(RFAILED);
	}

	if(ROK != SGetMsg(0, 0, &msg))
	{
		SPutSBuf(0, 0, (Data *)cmdNode, sizeof(CmdMsg_s));
		RXLOGERROR(0, 0, 0, "ERROR");
		RETVALUE(RFAILED);
	}


	cmd.hdr.frameStart = 0x55aa;
	cmd.hdr.dataLen = 3;
	cmd.hdr.sideId = equ->entry.sideId;
	cmd.cmd = cmdCode;

	SAddPstMsgMult((Data *)&cmd, (MsgLen)(cmd.hdr.dataLen + 3), msg);

	cmdNode->msg = msg;
	cmdNode->msgCode = cmdCode;
	cmdNode->action = action;
	cmdNode->rqstType = rqstType;
	cmdNode->machId = equ->entry.machId;
	cmdNode->sideId = equ->entry.sideId;
	cmdNode->gunId = equ->entry.pGunId;
	cmdNode->dir = CMD_DIR;
	cmdNode->chId = equ->entry.channelId; 
	cmdNode->stat = RDY_SEND;

	cmdNode->timer = 1;
	cmdNode->retry = CMD_RETRY_TIMES;
	cmdNode->loadTimer = CMD_RETRY_TIMEOUT;