?? lb_cm.c
字號:
/*
***********************************************************************************************************
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;
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -