|
|
#include "log.h"
|
|
|
#include "var.h"
|
|
|
#include "test.h"
|
|
|
#include "manage.h"
|
|
|
#include "config.h"
|
|
|
#include "control.h"
|
|
|
|
|
|
//½áÊø·û
|
|
|
static const char* _endstr = "$";
|
|
|
static const int _endlen = (int)strlen(_endstr);
|
|
|
|
|
|
CTest::CTest()
|
|
|
{
|
|
|
_p = NULL;
|
|
|
_pvar = NULL;
|
|
|
_result = 0;
|
|
|
_csvInfo = "";
|
|
|
_failItems = "";
|
|
|
_testItems = "";
|
|
|
_skt = INVALID_SKT;
|
|
|
_size = MAX_BUF_LEN;
|
|
|
_msg = new char[_size];
|
|
|
memset(_msg, 0, _size);
|
|
|
//_prvstatus = TestNoConn;
|
|
|
_status = SOCKET_DISCONNECTED;
|
|
|
memset(_client, 0, MAX_NAME_LEN);
|
|
|
memset(&_data, 0, sizeof(_data));
|
|
|
memset(_daypath, 0, MAX_NAME_LEN);
|
|
|
_hSend = sys_CreateEvent(FALSE, TRUE, NULL);
|
|
|
_hReply = sys_CreateEvent(TRUE, TRUE, NULL);
|
|
|
_hSection = sys_InitializeCriticalSection();
|
|
|
ClearFlag();
|
|
|
_data.benable = 1; //ĬÈÏÆôÓÃ
|
|
|
_data.yield = 1;
|
|
|
_data.pass = 0;
|
|
|
_data.lastct = TESTCT;
|
|
|
_pCurCmd = NULL;
|
|
|
}
|
|
|
|
|
|
CTest::~CTest()
|
|
|
{
|
|
|
Close();
|
|
|
delete _msg;
|
|
|
sys_CloseHandle(_hSend);
|
|
|
sys_CloseHandle(_hReply);
|
|
|
sys_DeleteCriticalSection(_hSection);
|
|
|
}
|
|
|
|
|
|
void CTest::ClearFlag()
|
|
|
{
|
|
|
_len = 0;
|
|
|
_index = 0;
|
|
|
_regtm = 0;
|
|
|
_socket = 0;
|
|
|
_qstart = 0;
|
|
|
_qstatus = 0;
|
|
|
_startct = 0;
|
|
|
_cmdres = 0;
|
|
|
_notest = false;
|
|
|
_btesting = false;
|
|
|
//_pass = 0;
|
|
|
//_data.total = 0;
|
|
|
//_data.yield = 1;
|
|
|
unlock();
|
|
|
setReply();
|
|
|
}
|
|
|
|
|
|
void CTest::loadCounter()
|
|
|
{
|
|
|
char buff[64] = { 0 };
|
|
|
sprintf(buff, "test_%s", _data.ate);
|
|
|
_data.pass = get_cfg_int(buff, "pass");
|
|
|
_data.total = get_cfg_int(buff, "total");
|
|
|
_data.yield = _data.total > 0 ? ((float)_data.pass / _data.total) : 1;
|
|
|
}
|
|
|
|
|
|
void CTest::saveCounter()
|
|
|
{
|
|
|
char buff[64] = { 0 };
|
|
|
sprintf(buff, "test_%s", _data.ate);
|
|
|
modify_cfg_int(buff, "pass", _data.pass);
|
|
|
modify_cfg_int(buff, "total", _data.total);
|
|
|
}
|
|
|
|
|
|
void CTest::resetCounter()
|
|
|
{
|
|
|
_data.pass = 0;
|
|
|
_data.total = 0;
|
|
|
_data.yield = 1;
|
|
|
saveCounter();
|
|
|
}
|
|
|
|
|
|
void CTest::operator =(CTest &r)
|
|
|
{
|
|
|
if (INVALID_SKT != _skt) skt_close(_skt);
|
|
|
_len = 0;
|
|
|
_skt = r._skt;
|
|
|
_index = r._index;
|
|
|
_status = r._status;
|
|
|
_socket = r._socket;
|
|
|
_qstatus = r._qstatus;
|
|
|
_startct = r._startct;
|
|
|
memset(_msg, 0, _size);
|
|
|
_csvTitle = r._csvTitle;
|
|
|
strcpy(_client, r._client);
|
|
|
_data.pass = r._data.pass;
|
|
|
_data.total = r._data.total;
|
|
|
_data.yield = r._data.yield;
|
|
|
//strcpy(_data.sn, r._data.sn);
|
|
|
_data.status = r._data.status;
|
|
|
strcpy(_data.ate, r._data.ate);
|
|
|
r.ClearFlag();
|
|
|
r._skt = INVALID_SKT; //°ÑÁ¬½Ó¸³Öµµ½Ð¶ÔÏó
|
|
|
r._status = SOCKET_DISCONNECTED;
|
|
|
r._data.status = TestNoConn;
|
|
|
r._csvTitle = "";
|
|
|
//memset(r._data.sn, 0, MAX_NAME_LEN);
|
|
|
memset(r._data.ate, 0, MAX_NAME_LEN); //Çå¿Õ»úÆ÷±àÂë
|
|
|
}
|
|
|
|
|
|
void CTest::Open(const char* pszip)
|
|
|
{
|
|
|
static bool bhintOk = false;
|
|
|
static bool bhintFail = false;
|
|
|
|
|
|
ClearFlag();
|
|
|
_status = SOCKET_DISCONNECTED;
|
|
|
_skt = skt_server(pszip, 6050);
|
|
|
if (!bhintFail && INVALID_SKT == _skt)
|
|
|
{//Ìáʾʧ°Ü
|
|
|
bhintOk = false;
|
|
|
bhintFail = true;
|
|
|
REPORT("Öξ߷þÎñ¶Ë´´½¨Ê§°Ü£¬Çë¼ì²é¶Ë¿ÚÊÇ·ñ±»Õ¼ÓÃ");
|
|
|
}
|
|
|
else if (!bhintOk && INVALID_SKT != _skt)
|
|
|
{//Ìáʾok
|
|
|
bhintOk = true;
|
|
|
bhintFail = false;
|
|
|
REPORT("Öξ߷þÎñ¶Ë´´½¨³É¹¦£¬µÈ´ýÁ¬½Ó...");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CTest::Close()
|
|
|
{
|
|
|
ZERO_CHK(IsOpen());
|
|
|
|
|
|
skt_close(_skt);
|
|
|
_skt = INVALID_SKT;
|
|
|
UpdateStatus(TestNoConn);
|
|
|
_status = SOCKET_DISCONNECTED;
|
|
|
ClearFlag();
|
|
|
}
|
|
|
|
|
|
int CTest::SetVarStatus(const char* szvar)
|
|
|
{
|
|
|
ipvar* p = get_ipvars(szvar);
|
|
|
|
|
|
RETURN_CHK_NOPRT(p != _pvar, ERR_INPUT_PARAM);
|
|
|
|
|
|
_pvar = p;
|
|
|
if (p) p->seti(getStatus());
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
cstr GetTestMode(cstr p)
|
|
|
{//¸ù¾ÝÓû§»ñÈ¡²âÊÔģʽ
|
|
|
if (0 == *p) return "Production";
|
|
|
if (!stricmp(p, "PM")) return "Audit";
|
|
|
if (!stricmp(p, "ADMIN")) return "Audit";
|
|
|
if (!stricmp(p, "ENG_MI")) return "Audit";
|
|
|
if (!stricmp(p, "ENGINEER")) return "Audit";
|
|
|
if (!stricmp(p, "ENG_VENDOR")) return "Audit";
|
|
|
if (!stricmp(p, "OP")) return "Production";
|
|
|
if (!stricmp(p, "DualTest")) return "Production";
|
|
|
if (!stricmp(p, "OPERATOR")) return "Production";
|
|
|
return p;
|
|
|
}
|
|
|
|
|
|
void CTest::PutProduct(CProduct* p)
|
|
|
{//½«²úÆ·Êý¾ÝÒÆÈëÖξß
|
|
|
ZERO_CHK(p != _p); //ÅжϿÕ
|
|
|
|
|
|
_p = p; //¸³Öµ
|
|
|
p->data.index = _index;
|
|
|
p->data.pos = LocationTest;
|
|
|
}
|
|
|
|
|
|
//ÕâÀïp¿ÉÄÜΪNULL
|
|
|
//StartTest#SN#Machine#User#Config#Lot#Mode#SiteID#ProjectID#RetryMode#Mes#Mtcp$
|
|
|
int CTest::StartTest(CProduct* p, const char* machine, const char* pszcfg, const char* pszcfg2,
|
|
|
const char* site, const char* project, int bmes, int bmtcp, int bdualmode,const char* sublotname,int bupnoise)
|
|
|
{//֪ͨÖξ߿ªÊ¼²âÊÔ£¬ÐèÒª×é°üͨÐÅ
|
|
|
RETURN_CHK_NOPRT(p || _p, ERR_NO_PRODUCT);
|
|
|
|
|
|
if (!p) p = _p; //Èô´«Èë¿Õ£¬ÔòʹÓñ¾µØ
|
|
|
|
|
|
if (_notest)
|
|
|
{//½ö×÷Ϊ»º´æÓà -- ½öÒ»´ÎÓÐЧ
|
|
|
PutProduct(p);
|
|
|
_notest = false;
|
|
|
return 0;
|
|
|
}
|
|
|
ins->WriteLog("manager.txt", "%s->%s", this->getAte(), "StartTest");
|
|
|
RETURN_CHK_NOPRT(IsReady(), ERR_NOREADY);
|
|
|
RETURN_CHK_NOPRT(lock(), ERR_NOREADY);
|
|
|
|
|
|
_qstart = 0; //×Ô¶¯Åж¨³¬Ê±±êʶ
|
|
|
resetReply();
|
|
|
_pCurCmd = START;
|
|
|
_cmdres = ERR_TIMEOUT;
|
|
|
cstr pszuser = get_cur_user();
|
|
|
if (!pszuser) pszuser = "OP";
|
|
|
if (!strcmp("DualTest", pszuser)) bdualmode = 1; //˫ģʽ
|
|
|
char rowcol[32] = {0};
|
|
|
CalcRowColumn(p->data.takeIndex, rowcol);
|
|
|
SendMsg("%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%d#%d#%s#%d#%s#%s#%d", START, p->data.sn, machine,
|
|
|
pszuser, pszcfg, p->data.lot, GetTestMode(pszuser),
|
|
|
site, project, p->getRetryModelS(), bmes, bmtcp, pszcfg2, bdualmode, rowcol, sublotname, bupnoise);
|
|
|
if (!waitReply())
|
|
|
{//Ö¸Áîδ»Ø¸´
|
|
|
unlock(); //ÊÍ·Å
|
|
|
REPORT("%s Æô¶¯²âÊÔÖ¸Áî·µ»Ø³¬Ê±.", _data.ate);
|
|
|
return ERR_TIMEOUT;
|
|
|
}
|
|
|
|
|
|
unlock(); //ÊÍ·Å
|
|
|
if (!IsRunning())
|
|
|
{//Ö¸Áîδ»Ø¸´£¬»òÕßδÆô¶¯²âÊÔ
|
|
|
REPORT("%s Æô¶¯²âÊÔʧ°Ü.", _data.ate);
|
|
|
return ERR_NOREADY;
|
|
|
}
|
|
|
|
|
|
ulong ct = sys_GetTickCount() - _qstart;
|
|
|
if (ct > 0) REPORT("test start command reply: %dms", ct);
|
|
|
PutProduct(p); //¸³Öµ
|
|
|
p->data.count++; //²âÊÔ´ÎÊý+1
|
|
|
p->SetIndex(_index);
|
|
|
p->data.failItems[0] = 0; //Çå¿Õ
|
|
|
strcpy(p->Ate(), _data.ate);
|
|
|
_startct = sys_GetTickCount();
|
|
|
|
|
|
char buff[MAX_NAME_LEN] = { 0 };
|
|
|
//sprintf(buff, "Fixture%d Start Test", _index);
|
|
|
//ins->EventTracker(pszuser, 0, "", buff);
|
|
|
sprintf(buff, "Fixture%d ", _index);
|
|
|
ins->BreakdownLog(buff, "Test Start");
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CTest::Home()
|
|
|
{
|
|
|
RETURN_CHK_NOPRT(IsReady(), ERR_NOREADY);
|
|
|
RETURN_CHK_NOPRT(lock(), ERR_NOREADY);
|
|
|
|
|
|
_qstart = 0;
|
|
|
resetReply();
|
|
|
_pCurCmd = HOME;
|
|
|
_cmdres = ERR_TIMEOUT;
|
|
|
SendMsg("%s", HOME);
|
|
|
if (!waitReply())
|
|
|
{//Ö¸Áîδ»Ø¸´
|
|
|
unlock(); //ÊÍ·Å
|
|
|
REPORT("%s %s Ö¸Áî·µ»Ø³¬Ê±.", _data.ate, HOME);
|
|
|
return ERR_TIMEOUT;
|
|
|
}
|
|
|
|
|
|
unlock(); //ÊÍ·Å
|
|
|
return _cmdres;
|
|
|
}
|
|
|
|
|
|
int CTest::Reset()
|
|
|
{
|
|
|
RETURN_CHK_NOPRT(IsNormal(), ERR_NOREADY);
|
|
|
RETURN_CHK_NOPRT(lock(), ERR_NOREADY);
|
|
|
|
|
|
_qstart = 0;
|
|
|
resetReply();
|
|
|
_pCurCmd = RESET;
|
|
|
_cmdres = ERR_TIMEOUT;
|
|
|
SendMsg("%s", RESET);
|
|
|
if (!waitReply())
|
|
|
{//Ö¸Áîδ»Ø¸´
|
|
|
unlock(); //ÊÍ·Å
|
|
|
REPORT("%s %s Ö¸Áî·µ»Ø³¬Ê±.", _data.ate, RESET);
|
|
|
return ERR_TIMEOUT;
|
|
|
}
|
|
|
|
|
|
unlock(); //ÊÍ·Å
|
|
|
return _cmdres;
|
|
|
}
|
|
|
|
|
|
int CTest::Pause(int bpause/* = 1*/)
|
|
|
{//֪ͨÖξßÔÝÍ£
|
|
|
RETURN_CHK_NOPRT(IsNormal(), ERR_NOREADY);
|
|
|
RETURN_CHK_NOPRT(lock(), ERR_NOREADY);
|
|
|
|
|
|
_qstart = 0;
|
|
|
resetReply();
|
|
|
_pCurCmd = PAUSE;
|
|
|
_cmdres = ERR_TIMEOUT;
|
|
|
SendMsg("%s#%d", PAUSE, bpause);
|
|
|
if (!waitReply())
|
|
|
{//Ö¸Áîδ»Ø¸´
|
|
|
unlock(); //ÊÍ·Å
|
|
|
REPORT("%s %s Ö¸Áî·µ»Ø³¬Ê±.", _data.ate, PAUSE);
|
|
|
return ERR_TIMEOUT;
|
|
|
}
|
|
|
|
|
|
unlock(); //ÊÍ·Å
|
|
|
return _cmdres;
|
|
|
}
|
|
|
|
|
|
int CTest::EnableGrip(int benable/* = 1*/)
|
|
|
{//¿ØÖƼÐצ´ò¿ª»ò¹Ø±Õ 1¼Ð½ô 0ËÉ¿ª
|
|
|
RETURN_CHK_NOPRT(IsReady(), ERR_NOREADY);
|
|
|
RETURN_CHK_NOPRT(lock(), ERR_NOREADY);
|
|
|
|
|
|
_qstart = 0;
|
|
|
resetReply();
|
|
|
_pCurCmd = GRIP;
|
|
|
_cmdres = ERR_TIMEOUT;
|
|
|
SendMsg("%s#%d", GRIP, benable);
|
|
|
if (!waitReply())
|
|
|
{//Ö¸Áîδ»Ø¸´
|
|
|
unlock(); //ÊÍ·Å
|
|
|
REPORT("%s ¿ØÖƼÐצָÁî·µ»Ø³¬Ê±.", _data.ate);
|
|
|
return ERR_TIMEOUT;
|
|
|
}
|
|
|
|
|
|
unlock(); //ÊÍ·Å
|
|
|
return _cmdres;
|
|
|
}
|
|
|
|
|
|
int CTest::SendGR(const char* s)
|
|
|
{//·¢ËÍGRÏûÏ¢¸øÖξß
|
|
|
int ret = 0;
|
|
|
|
|
|
RETURN_CHK_NOPRT(s && *s, ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(IsNormal(), ERR_NOREADY);
|
|
|
RETURN_CHK_NOPRT(lock(), ERR_NOREADY);
|
|
|
|
|
|
_qstart = 0;
|
|
|
_cmdres = ERR_TIMEOUT;
|
|
|
ret = SendMsg("%s#%s", GR, s);
|
|
|
unlock(); //ÊÍ·Å
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CTest::GetResultCsvInfo(char* pbuffer/* = 0*/, int nsize/* = 0*/)
|
|
|
{
|
|
|
int nlen = (int)_csvInfo.length();
|
|
|
|
|
|
RETURN_CHK_NOPRT(pbuffer, nlen);
|
|
|
|
|
|
if (nsize < nlen) nlen = nsize;
|
|
|
comm_strncpy(pbuffer, _csvInfo.c_str(), nlen);
|
|
|
return nlen;
|
|
|
}
|
|
|
|
|
|
int CTest::GetResultFailInfo(char* pbuffer/* = 0*/, int nsize/* = 0*/)
|
|
|
{
|
|
|
int nlen = (int)_failItems.length();
|
|
|
|
|
|
RETURN_CHK_NOPRT(pbuffer, nlen);
|
|
|
|
|
|
if (nsize < nlen) nlen = nsize;
|
|
|
comm_strncpy(pbuffer, _failItems.c_str(), nlen);
|
|
|
return nlen;
|
|
|
}
|
|
|
|
|
|
int CTest::GetResultTestInfo(char* pbuffer/* = 0*/, int nsize/* = 0*/)
|
|
|
{
|
|
|
int nlen = (int)_testItems.length();
|
|
|
|
|
|
RETURN_CHK_NOPRT(pbuffer, nlen);
|
|
|
|
|
|
if (nsize < nlen) nlen = nsize;
|
|
|
comm_strncpy(pbuffer, _testItems.c_str(), nlen);
|
|
|
return nlen;
|
|
|
}
|
|
|
|
|
|
static const char* _pszst[] = {"¶Ï¿ªÁ¬½Ó", "²âÊÔÖÐ", "¾ÍÐ÷", "±¨¾¯", "»ØÔÖÐ" };
|
|
|
|
|
|
void CTest::UpdateStatus(TestStatus status)
|
|
|
{//¸üÐÂÖξß״̬
|
|
|
ZERO_CHK(status != _data.status);
|
|
|
|
|
|
REPORT("%s:%s", _data.ate, _pszst[status]);
|
|
|
_data.status = status; //×îºó¸üÐÂ״̬
|
|
|
if (_pvar) _pvar->seti(status);
|
|
|
}
|
|
|
|
|
|
void CTest::Connect()
|
|
|
{//µÈ´ýÁ¬½Ó
|
|
|
ushort port = 0;
|
|
|
char ip[MAX_IP_LEN] = {0};
|
|
|
|
|
|
ZERO_CHK(IsOpen());
|
|
|
ZERO_CHK(SOCKET_CONNECTED != _status);
|
|
|
ZERO_CHK(SOCKET_CONNECTED == skt_status(_skt));
|
|
|
|
|
|
ClearFlag();
|
|
|
_status = SOCKET_CONNECTED;
|
|
|
_regtm = sys_GetTickCount();
|
|
|
skt_get_addr(_skt, ip, &port);
|
|
|
_socket = skt_get_socket(_skt);
|
|
|
sprintf(_client, "%s:%d", ip, port);
|
|
|
REPORT("%s ÒÑÁ¬½Ó,µÈ´ý×¢²á.", _client);
|
|
|
}
|
|
|
|
|
|
void CTest::Process()
|
|
|
{//ÆäËü´¦Àí -- ÓÉÏß³ÌÖ´ÐÐ
|
|
|
//sys_EnterCriticalSection(_hSection);
|
|
|
ChkRegist();
|
|
|
QueryStatus();
|
|
|
ChkReplyTimeout();
|
|
|
//sys_LeaveCriticalSection(_hSection);
|
|
|
}
|
|
|
|
|
|
void CTest::ChkRegist()
|
|
|
{//¼ì²â×¢²á³¬Ê±
|
|
|
ZERO_CHK(IsConn() && !IsRegOk());
|
|
|
|
|
|
if (sys_GetTickCount() - _regtm > 2000)
|
|
|
{//³¬Ê±ÁË,³¬¹ý2sδע²á
|
|
|
Close();
|
|
|
REPORT("%s ³¬¹ý2sδע²á£¬¶Ï¿ªÁ¬½Ó.", _client);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CTest::QueryStatus()
|
|
|
{//²éѯÖξß״̬
|
|
|
uint ct = 0;
|
|
|
|
|
|
ZERO_CHK(IsNormal());
|
|
|
|
|
|
ct = sys_GetTickCount();
|
|
|
|
|
|
ZERO_CHK(ct - _qstatus > 500); //¼ÆËã¼ä¸ô
|
|
|
ZERO_CHK(trylock()); //³¢ÊÔËø¶¨
|
|
|
|
|
|
SendMsg(STATUS);
|
|
|
_pCurCmd = STATUS;
|
|
|
_qstatus = _qstart = ct;
|
|
|
}
|
|
|
|
|
|
void CTest::ChkReplyTimeout()
|
|
|
{//¼ì²â»Ø¸´³¬Ê±
|
|
|
ulong ct = 0;
|
|
|
|
|
|
ZERO_CHK(IsNormal() && _qstart);
|
|
|
|
|
|
ct = sys_GetTickCount();
|
|
|
if (ct > _qstart + 2000)
|
|
|
{//δ»Ø¸´£¬²¢ÇÒ³¬¹ý2s
|
|
|
//Close();
|
|
|
_qstart = 0;
|
|
|
UpdateStatus(TestWarn);
|
|
|
REPORT("%s ³¬¹ý2sδ»Ø¸´ %s", _data.ate, _pCurCmd ? _pCurCmd : "");
|
|
|
_pCurCmd = NULL;
|
|
|
unlock(); //½âËø
|
|
|
}
|
|
|
}
|
|
|
|
|
|
int CTest::SendMsg(const char *pszFormat, ...)
|
|
|
{
|
|
|
int len = 0;
|
|
|
int ret = 0;
|
|
|
va_list args;
|
|
|
char buff[1024] = {0};
|
|
|
|
|
|
va_start(args, pszFormat);
|
|
|
len = vsnprintf(buff, 1023, pszFormat, args);
|
|
|
va_end(args);
|
|
|
|
|
|
RETURN_CHK_NOPRT(len > 0, ERR_INPUT_PARAM);
|
|
|
|
|
|
len += sprintf(buff + len, "%s", _endstr); //Ôö¼Ó½áÊø·û
|
|
|
if (!strstr(buff, "Status") && !strstr(buff, "Register") && !strstr(buff, "ErrorCode") && !strstr(buff, "Vlog"))
|
|
|
{
|
|
|
ins->WriteLog("manager.txt", "%s->send to test before %s",getAte(), buff);
|
|
|
}
|
|
|
ret = skt_send(_skt, buff, len);
|
|
|
if (!strstr(buff, "Status") && !strstr(buff, "Register") && !strstr(buff, "ErrorCode") && !strstr(buff, "Vlog"))
|
|
|
{
|
|
|
ins->WriteLog("manager.txt", "%s->send to test after ret=%d", getAte(), ret);
|
|
|
}
|
|
|
if (ret <= 0)
|
|
|
{
|
|
|
ret = skt_send(_skt, buff, len);
|
|
|
if (!strstr(buff, "Status") && !strstr(buff, "Register") && !strstr(buff, "ErrorCode") && !strstr(buff, "Vlog"))
|
|
|
{
|
|
|
ins->WriteLog("manager.txt", "µÚ¶þ´Î·¢ËÍÊý¾Ý %s->send to test after ret=%d", getAte(), ret);
|
|
|
}
|
|
|
}
|
|
|
if (ERR_NO_CONNECT == ret)
|
|
|
{//ÒѾ¶Ï¿ª
|
|
|
Close();
|
|
|
ins->WriteLog("manager.txt", "%s ÒѶϿªÁ¬½Ó", _data.ate);
|
|
|
REPORT("%s ÒѶϿªÁ¬½Ó", _data.ate);
|
|
|
return ret;
|
|
|
}
|
|
|
if (ins->testLog())
|
|
|
{
|
|
|
LOG_INF1("send->%s: %s", _data.ate, buff);
|
|
|
if (ins->getCommunicationmsgcallback() != NULL)
|
|
|
{
|
|
|
ins->getCommunicationmsgcallback()(1, getIndex(), buff, 0);
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CTest::FindEnd(char* pszmsg)
|
|
|
{
|
|
|
char* ptmp = NULL;
|
|
|
ptmp = strstr(pszmsg, _endstr);
|
|
|
if (!ptmp) return -1;
|
|
|
*ptmp = 0;
|
|
|
return (int)(ptmp - pszmsg);
|
|
|
}
|
|
|
|
|
|
void CTest::RecvMsg()
|
|
|
{//½ÓÊÕÏûÏ¢
|
|
|
int len = 0;
|
|
|
char* pdest = NULL;
|
|
|
|
|
|
//ZERO_CHK(IsConn());
|
|
|
|
|
|
//len = skt_recv(_skt, _msg + _len, _size - 1 - _len, 0);
|
|
|
len = sys_Recv(_socket, _msg + _len, _size - 1 - _len);
|
|
|
if (ERR_NO_CONNECT == len)
|
|
|
{//ÒѾ¶Ï¿ª
|
|
|
Close();
|
|
|
REPORT("%s ÒѶϿªÁ¬½Ó", _client);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
ZERO_CHK(len > 0); //error
|
|
|
|
|
|
pdest = _msg + _len;
|
|
|
_len += len; //ÏûÏ¢³¤¶È
|
|
|
pdest[len] = 0;
|
|
|
|
|
|
if (ins->testLog())
|
|
|
{
|
|
|
LOG_INF1("%s[%s] recv: %s", _client, _data.ate, pdest);
|
|
|
if (ins->getCommunicationmsgcallback() != NULL)
|
|
|
{
|
|
|
ins->getCommunicationmsgcallback()(1, getIndex(), pdest, 1);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (_size - 1 == _len)
|
|
|
{//»º³åÇø²»¹»ÁË +´ó
|
|
|
_size += MAX_BUF_LEN;
|
|
|
pdest = new char[_size];
|
|
|
memset(pdest, 0, _size);
|
|
|
memcpy(pdest, _msg, _len);
|
|
|
delete _msg;
|
|
|
_msg = pdest;
|
|
|
}
|
|
|
|
|
|
pdest = _msg;
|
|
|
while(_len > 0)
|
|
|
{
|
|
|
len = FindEnd(pdest); //²éÕÒ½áÊø·û
|
|
|
if (len < 0)
|
|
|
{//δÕÒµ½½áÊø·û
|
|
|
if (pdest != _msg)
|
|
|
{//²»µÈ£¬±êʶǰÃæÒѾ½âÎö¹ýÏûÏ¢£¬ºóÃæÊ£ÓàÏûÏ¢ÐèҪǰÒÆ
|
|
|
mem_forward(pdest, _len + 1, (uint)(pdest - _msg));
|
|
|
}
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
//ÐÂÏûÏ¢
|
|
|
ParseMsg(pdest);
|
|
|
len += _endlen; //¼ÓÉϽáÊø·û³¤¶È
|
|
|
_len -= len;
|
|
|
pdest += len;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CTest::ParseMsg(char* pszmsg)
|
|
|
{
|
|
|
char* ptmp = NULL;
|
|
|
|
|
|
ZERO_CHK(pszmsg);
|
|
|
|
|
|
//LOG_INF1("%s[%s] parse msg: %s", _client, _data.ate, pszmsg);
|
|
|
|
|
|
ptmp = sys_strtok(NULL, SPLIT, &pszmsg);
|
|
|
|
|
|
ZERO_CHK(ptmp && *ptmp);
|
|
|
|
|
|
if (!strcmp(ptmp, REG))
|
|
|
{//×¢²áÏûÏ¢
|
|
|
return ParseRegister(pszmsg);
|
|
|
}
|
|
|
|
|
|
if (!strcmp(ptmp, VLOG))
|
|
|
{//ÉÏ´«ÈÕÖ¾
|
|
|
return ParseWriteLog(pszmsg);
|
|
|
}
|
|
|
|
|
|
if (!strcmp(ptmp, GR))
|
|
|
{//²àÏà»úÊÓ¾õ´¦ÀíÇëÇó
|
|
|
return ParseGR(pszmsg);
|
|
|
}
|
|
|
|
|
|
if (!strcmp(ptmp, RIO))
|
|
|
{//¶ÁÈ¡±¾µØIO
|
|
|
return ParseRIO(pszmsg);
|
|
|
}
|
|
|
|
|
|
if (!strcmp(ptmp, WIO))
|
|
|
{//дÈë±¾µØIO
|
|
|
return ParseWIO(pszmsg);
|
|
|
}
|
|
|
|
|
|
//------------------//
|
|
|
//ÕâÀïÒÔ϶¼Êǻظ´ÏûÏ¢£¬±ØÐë¼ì²é·¢³öµÄÖ¸ÁîºÍ½ÓÊÕµ½µÄÊÇ·ñÒ»Ö£¬·ñÔò¶ªÆú¸ÃÏûÏ¢
|
|
|
//-
|
|
|
if (!_pCurCmd || strcmp(ptmp, _pCurCmd))
|
|
|
{//±ØÐëÊǵ±Ç°Ö¸Áî»Ø¸´²ÅÐÐ
|
|
|
REPORT("%s ´íÎó»Ø¸´Ö¸Áî:%s", _data.ate, ptmp);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
_pCurCmd = NULL; //ÖØÖÃ
|
|
|
if (!strcmp(ptmp, STATUS))
|
|
|
{//Öξß״̬»Ø¸´
|
|
|
return ParseStatusReply(pszmsg);
|
|
|
}
|
|
|
|
|
|
if (!strcmp(ptmp, START))
|
|
|
{//Æô¶¯²âÊԻظ´
|
|
|
return ParseStartReply(pszmsg);
|
|
|
}
|
|
|
|
|
|
if (!strcmp(ptmp, RES))
|
|
|
{//ѯÎʽá¹û»Ø¸´
|
|
|
return ParseResultReply(pszmsg);
|
|
|
}
|
|
|
|
|
|
if (!strcmp(ptmp, ERR))
|
|
|
{//´íÎó´úÂë»Ø¸´
|
|
|
return ParseErrorReply(pszmsg);
|
|
|
}
|
|
|
|
|
|
if (!strcmp(ptmp, HOME))
|
|
|
{//»ØÔÖ¸Áî»Ø¸´
|
|
|
return ParseIntReply(pszmsg);
|
|
|
}
|
|
|
|
|
|
if (!strcmp(ptmp, RESET))
|
|
|
{//ÖØÖÃÖ¸Áî»Ø¸´
|
|
|
return ParseIntReply(pszmsg);
|
|
|
}
|
|
|
|
|
|
if (!strcmp(ptmp, GRIP))
|
|
|
{//¿ØÖƼÐצ»Ø¸´
|
|
|
return ParseIntReply(pszmsg);
|
|
|
}
|
|
|
|
|
|
if (!strcmp(ptmp, PAUSE))
|
|
|
{//ÔÝÍ£»Ø¸´
|
|
|
return ParseIntReply(pszmsg);
|
|
|
}
|
|
|
|
|
|
REPORT("%s Òì³£Ö¸Áî: %s", _client, ptmp);
|
|
|
}
|
|
|
|
|
|
void CTest::ParseRegister(char* pszcmd)
|
|
|
{//½âÎö×¢²áÏûÏ¢
|
|
|
int index = 0;
|
|
|
char* ptmp = NULL;
|
|
|
char ate[MAX_NAME_LEN] = {0};
|
|
|
|
|
|
if (0 == _regtm)
|
|
|
{
|
|
|
SendMsg("%s#0", REG);
|
|
|
REPORT("%s Öظ´×¢²á»ò²»ÔÚÏÞÖÆʱ¼äÄÚ×¢²á.", _client);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
ptmp = sys_strtok(NULL, SPLIT, &pszcmd);
|
|
|
if ((0 == ptmp || 0 == *ptmp || strlen(ptmp) >= MAX_NAME_LEN))
|
|
|
{//¸ñʽ²»¶Ô
|
|
|
SendMsg("%s#0", REG);
|
|
|
LOG_WARN("%s ×¢²á¸ñʽ´íÎó.", _client);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
strcpy(ate, ptmp); //ate
|
|
|
ptmp = sys_strtok(NULL, SPLIT, &pszcmd);
|
|
|
if (EMSTR_INT != get_str_type(ptmp))
|
|
|
{//¸ñʽ²»¶Ô
|
|
|
SendMsg("%s#0", REG);
|
|
|
LOG_WARN("%s ×¢²á¸ñʽ´íÎó.", _client);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
index = atoi(ptmp);
|
|
|
if (index <= 0 || index > TESTCNT)
|
|
|
{//ÐòºÅ²»¶Ô
|
|
|
SendMsg("%s#0", REG);
|
|
|
LOG_WARN("%s ×¢²á»ų́ÐòºÅ´íÎó:%d", _client, index);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (!ins->ChkAteValid(index, ate))
|
|
|
{//±àÂëÖظ´ÁË
|
|
|
SendMsg("%s#0", REG);
|
|
|
LOG_WARN("%s Öξ߱àÂëÖظ´:%s", _client, ate);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
//ÅжÏÊÇ·ñ´øÓбêÌâ
|
|
|
_csvTitle = pszcmd ? pszcmd : "";
|
|
|
_csvTitle += "\n"; //Ôö¼Ó»»Ðзû
|
|
|
|
|
|
_regtm = 0; //ÖØÖñêʶ
|
|
|
_index = index; //ÐòºÅ
|
|
|
strcpy(_data.ate, ate); //ate
|
|
|
loadCounter(); //¼ÓÔؼÆÊý
|
|
|
SendMsg("%s#1", REG);
|
|
|
UpdateStatus(TestWarn);
|
|
|
}
|
|
|
|
|
|
void CTest::ParseStatusReply(char* pszcmd)
|
|
|
{//Öξß״̬»Ø¸´
|
|
|
int status = 0;
|
|
|
|
|
|
if (EMSTR_INT != get_str_type(pszcmd))
|
|
|
{//¸ñʽ²»¶Ô
|
|
|
LOG_WARN("%s ״̬·µ»Ø´íÎó :%s.", _data.ate, pszcmd);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
status = atoi(pszcmd);
|
|
|
if (status != 0 && status != 1 && status != 2)
|
|
|
{//±ØÐëÊÇ1ºÍ0
|
|
|
LOG_WARN("%s ״̬·µ»Ø´íÎó :%s.", _data.ate, pszcmd);
|
|
|
}
|
|
|
|
|
|
if (0 == status)
|
|
|
{//²âÊÔÖÐ
|
|
|
SendMsg(ERR);
|
|
|
_pCurCmd = ERR;
|
|
|
_qstart = sys_GetTickCount();
|
|
|
}
|
|
|
else if (2 == status)
|
|
|
{
|
|
|
unlock();
|
|
|
UpdateStatus(TestHoming);
|
|
|
}
|
|
|
else if (_p && /*IsRunning()*/_btesting)
|
|
|
{//ÓвúÆ·ÇÒ²âÊÔÖÐ->¾ÍÐ÷
|
|
|
SendMsg(RES);
|
|
|
_pCurCmd = RES;
|
|
|
_qstart = sys_GetTickCount();
|
|
|
_data.lastct = (int)(_qstart - _startct);
|
|
|
}
|
|
|
else
|
|
|
{//״̬¾ÍÐ÷
|
|
|
unlock();
|
|
|
_qstart = 0; //ÖØÖÃ
|
|
|
UpdateStatus(TestIdle);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CTest::ParseErrorReply(char* pszcmd)
|
|
|
{//´íÎó´úÂë»Ø¸´
|
|
|
int err = 0;
|
|
|
char* ptmp = NULL;
|
|
|
|
|
|
ptmp = sys_strtok(NULL, SPLIT, &pszcmd);
|
|
|
if (EMSTR_INT != get_str_type(ptmp))
|
|
|
{//¸ñʽ²»¶Ô
|
|
|
LOG_WARN("%s ²éѯ´íÎ󷵻ظñʽ´íÎó :%s.", _data.ate, pszcmd);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
_pCurCmd = NULL;
|
|
|
err = atoi(ptmp);
|
|
|
if (0 == err)
|
|
|
{//ÎÞ´íÎó
|
|
|
//if (TestWarn == getStatus()) UpdateStatus(TestIdle);
|
|
|
}
|
|
|
else if (TestWarn != getStatus())
|
|
|
{//ÓдíÎó
|
|
|
UpdateStatus(TestWarn);
|
|
|
REPORT("%s ±¨¾¯ %d:%s", _data.ate, err, pszcmd ? pszcmd : "");
|
|
|
ins->PostWarn("%s ±¨¾¯ %d:%s", _data.ate, err, pszcmd ? pszcmd : "");
|
|
|
}
|
|
|
unlock();
|
|
|
}
|
|
|
|
|
|
void CTest::ParseWriteLog(char* pszcmd)
|
|
|
{
|
|
|
char* ptmp = NULL;
|
|
|
|
|
|
ptmp = sys_strtok(NULL, SPLIT, &pszcmd);
|
|
|
if (0 == ptmp || 0 == pszcmd)
|
|
|
{//¸ñʽ²»¶Ô
|
|
|
SendMsg("%s#0", VLOG);
|
|
|
LOG_WARN("%s ÉÏ´«ÈÕÖ¾¸ñʽ´íÎó.", _data.ate);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (0 == *ptmp || 0 == *pszcmd || strlen(ptmp) > 256 || strlen(pszcmd) > 256)
|
|
|
{//³¤¶ÈÊÜÏÞ
|
|
|
SendMsg("%s#0", VLOG);
|
|
|
LOG_WARN("%s ÉÏ´«ÈÕÖ¾ÄÚÈݳ¤¶È³¬ÏÞ.", _data.ate);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
ins->BreakdownLog(ptmp, pszcmd);
|
|
|
SendMsg("%s#1", VLOG);
|
|
|
}
|
|
|
|
|
|
void CTest::ParseGR(char* pszcmd)
|
|
|
{
|
|
|
int ret = ins->SendTestGR(_index, pszcmd);
|
|
|
if (ret)
|
|
|
{//fail.
|
|
|
SendMsg("%s#%d", GR, ret);
|
|
|
LOG_WARN("%s ·¢Ë͸øÊÓ¾õʧ°Ü.", _data.ate);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void DelEnter(char * source)
|
|
|
{
|
|
|
char * temp = source;
|
|
|
if (source == NULL)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
while (*source)
|
|
|
{
|
|
|
if (*source != '\r' && *source != '\n')
|
|
|
{
|
|
|
*temp = *source;
|
|
|
temp++;
|
|
|
}
|
|
|
source++;
|
|
|
}
|
|
|
*temp = '\0';
|
|
|
}
|
|
|
|
|
|
void CTest::ParseResult(char* pszcmd)
|
|
|
{
|
|
|
DelEnter(pszcmd);
|
|
|
char* ptmp = NULL;
|
|
|
|
|
|
_csvInfo = "";
|
|
|
_failItems = "";
|
|
|
_testItems = "";
|
|
|
|
|
|
ZERO_CHK(pszcmd);
|
|
|
ptmp = sys_strtok(NULL, SPLIT, &pszcmd);
|
|
|
|
|
|
if (ptmp) _csvInfo = ptmp; //csvinfo
|
|
|
|
|
|
ptmp = NULL;
|
|
|
_csvInfo += ",";
|
|
|
if (pszcmd) ptmp = sys_strtok(NULL, SPLIT, &pszcmd);
|
|
|
if (ptmp)
|
|
|
{//failitems
|
|
|
_failItems = ptmp;
|
|
|
_csvInfo += ptmp;
|
|
|
}
|
|
|
|
|
|
ptmp = NULL;
|
|
|
_csvInfo += ",";
|
|
|
if (pszcmd) ptmp = sys_strtok(NULL, SPLIT, &pszcmd);
|
|
|
if (ptmp)
|
|
|
{//testitems
|
|
|
_testItems = ptmp;
|
|
|
_csvInfo += ptmp;
|
|
|
}
|
|
|
_csvInfo += "\n";
|
|
|
|
|
|
ptmp = NULL;
|
|
|
if (pszcmd) ptmp = sys_strtok(NULL, SPLIT, &pszcmd);
|
|
|
if (_p)
|
|
|
{//bin
|
|
|
if (ptmp) comm_strncpy(_p->data.level, ptmp, MAX_NAME_LEN); //bin
|
|
|
comm_strncpy(_p->data.failItems, _failItems.c_str(), MAX_BUF_LEN);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CTest::ParseResultReply(char* pszcmd)
|
|
|
{//ѯÎʽá¹û»Ø¸´
|
|
|
int ret = 0;
|
|
|
char* ptmp = NULL;
|
|
|
char buff[MAX_NAME_LEN] = { 0 };
|
|
|
|
|
|
ptmp = sys_strtok(NULL, SPLIT, &pszcmd);
|
|
|
if (EMSTR_INT != get_str_type(ptmp))
|
|
|
{//¸ñʽ²»¶Ô
|
|
|
LOG_WARN("%s ²éѯ½á¹û·µ»Ø¸ñʽ´íÎó :%s.", _data.ate, ptmp ? ptmp : "");
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
unlock(); //½âËø
|
|
|
_btesting = false;
|
|
|
UpdateStatus(TestIdle);
|
|
|
ret = atoi(ptmp);
|
|
|
|
|
|
ZERO_CHK(ret == 1);
|
|
|
|
|
|
ptmp = sys_strtok(NULL, SPLIT, &pszcmd);
|
|
|
if (EMSTR_INT != get_str_type(ptmp))
|
|
|
{//¸ñʽ²»¶Ô
|
|
|
LOG_WARN("%s ²éѯ½á¹û·µ»Ø´íÎ󣬲âÊÔ½á¹û:%s", _data.ate, ptmp ? ptmp : "");
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
_result = atoi(ptmp);
|
|
|
if (_p)
|
|
|
{//ÓвúÆ· -- ¼ÆËãÁ¼ÂÊ
|
|
|
_p->data.status = _result;
|
|
|
_data.total++;
|
|
|
if (_result) _data.pass++;
|
|
|
_data.yield = (float)_data.pass / _data.total;
|
|
|
saveCounter();
|
|
|
}
|
|
|
|
|
|
ParseResult(pszcmd); //½âÎöºóÃæµÄ½á¹û
|
|
|
|
|
|
//CalcYield();
|
|
|
ins->SummaryLog(_csvTitle.c_str(), _csvInfo.c_str());
|
|
|
ins->UnitTracker(_p->data.sn, _data.ate, _p->data.lot, _p->data.status, _p->getRetryModelE());
|
|
|
|
|
|
//cstr pszuser = get_cur_user();
|
|
|
//sprintf(buff, "Fixture%d Test OK", _index);
|
|
|
//ins->EventTracker(pszuser ? pszuser : "OP", 0, "", buff);
|
|
|
sprintf(buff, "Fixture %d", _index);
|
|
|
ins->BreakdownLog(buff, " Test End");
|
|
|
}
|
|
|
|
|
|
void CTest::ParseStartReply(char* pszcmd)
|
|
|
{//Æô¶¯²âÊԻظ´
|
|
|
int ret = 0;
|
|
|
|
|
|
if (EMSTR_INT != get_str_type(pszcmd))
|
|
|
{//¸ñʽ²»¶Ô
|
|
|
LOG_WARN("%s Æô¶¯²âÊÔ·µ»Ø´íÎó :%s.", _data.ate, pszcmd);
|
|
|
}
|
|
|
else
|
|
|
{//¸ñʽ¶Ô
|
|
|
ret = atoi(pszcmd);
|
|
|
if (ret != 0 && ret != 1)
|
|
|
{//±ØÐëÊÇ1ºÍ0
|
|
|
LOG_WARN("%s Æô¶¯²âÊÔ·µ»Ø´íÎó :%s.", _data.ate, pszcmd);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (1 == ret)
|
|
|
{//OK
|
|
|
_cmdres = 0;
|
|
|
_btesting = true; //²âÊÔÖÐ
|
|
|
UpdateStatus(TestRunning);
|
|
|
}
|
|
|
setReply();
|
|
|
}
|
|
|
|
|
|
void CTest::ParseIntReply(char* pszcmd)
|
|
|
{//½âÎö·µ»Ø½á¹û£¨ÕûÊý£©
|
|
|
int ret = 0;
|
|
|
|
|
|
if (EMSTR_INT != get_str_type(pszcmd))
|
|
|
{//¸ñʽ²»¶Ô
|
|
|
LOG_WARN("%s Ö¸Áî·µ»Ø´íÎó :%s.", _data.ate, pszcmd);
|
|
|
}
|
|
|
else
|
|
|
{//¸ñʽ¶Ô
|
|
|
ret = atoi(pszcmd);
|
|
|
if (ret != 0 && ret != 1)
|
|
|
{//±ØÐëÊÇ1ºÍ0
|
|
|
LOG_WARN("%s Ö¸Áî·µ»Ø´íÎó :%s.", _data.ate, pszcmd);
|
|
|
}
|
|
|
|
|
|
if (1 == ret)
|
|
|
{//OK
|
|
|
_cmdres = 0;
|
|
|
}
|
|
|
}
|
|
|
setReply();
|
|
|
}
|
|
|
|
|
|
void CTest::ParseRIO(char* pszcmd)
|
|
|
{//ReadIO#name
|
|
|
ZERO_CHK(pszcmd);
|
|
|
|
|
|
if (EMSTR_STRING != get_str_type(pszcmd))
|
|
|
{//¸ñʽ²»¶Ô
|
|
|
LOG_WARN("%s IOÃû³Æ¸ñʽ´íÎó :%s.", _data.ate, pszcmd);
|
|
|
SendMsg("%s#0", RIO);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
SendMsg("%s#%d", RIO, read_by_name(pszcmd));
|
|
|
}
|
|
|
|
|
|
void CTest::ParseWIO(char* pszcmd)
|
|
|
{//WriteIO#name#val
|
|
|
int ret = 0;
|
|
|
cstr ptmp = 0;
|
|
|
|
|
|
ZERO_CHK(pszcmd);
|
|
|
|
|
|
ptmp = sys_strtok(NULL, SPLIT, &pszcmd);
|
|
|
if (EMSTR_STRING != get_str_type(ptmp))
|
|
|
{//¸ñʽ²»¶Ô
|
|
|
LOG_WARN("%s IOÃû³Æ¸ñʽ´íÎó :%s.", _data.ate, pszcmd);
|
|
|
SendMsg("%s#-1", WIO);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (EMSTR_INT != get_str_type(pszcmd))
|
|
|
{//¸ñʽ²»¶Ô
|
|
|
LOG_WARN("%s IOдÈëÖµ¸ñʽ´íÎó :%s.", _data.ate, pszcmd);
|
|
|
SendMsg("%s#-1", WIO);
|
|
|
return;
|
|
|
}
|
|
|
ret = atoi(pszcmd);
|
|
|
SendMsg("%s#%d", WIO, write_by_name(ptmp, ret));
|
|
|
LOG_INF1("%s[%s] write IO: %s = %d", _client, _data.ate, ptmp, ret);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
¸ù¾Ý²úÆ·ÔÚÁÏÅÌÖеÄË÷ÒýÖµ¼ÆËã³ö²úÆ·ÔÚÁÏÅÌÖеÄÐÐÁÐ
|
|
|
*/
|
|
|
void CTest::CalcRowColumn(int takeindex, char* rowcol)
|
|
|
{
|
|
|
int _row, _col;
|
|
|
_row = _col = 0;
|
|
|
if (takeindex % 16 == 0)
|
|
|
{
|
|
|
_row = takeindex / 16;
|
|
|
_col = 16;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
_row = (takeindex / 16) + 1;
|
|
|
_col = takeindex % 16;
|
|
|
}
|
|
|
sprintf(rowcol,"R%dC%d", _row, _col);
|
|
|
} |