|
|
#include "manage.h"
|
|
|
#include "log.h"
|
|
|
#include "skt.h"
|
|
|
#include "var.h"
|
|
|
#include "ops.h"
|
|
|
#include "test.h"
|
|
|
#include "config.h"
|
|
|
#include "matrix.h"
|
|
|
#include "user.h"
|
|
|
#include "sysapi.h"
|
|
|
|
|
|
//默认参数
|
|
|
#define CONFIG "C001" //料号
|
|
|
#define LOT "P001" //产品批次/料号
|
|
|
#define MACHINE "MS001" //设备ID
|
|
|
#define SITEL "rs" //厂商
|
|
|
#define PRONA "pr10010" //项目代码
|
|
|
#define BINA "BinA" //BinA
|
|
|
#define SUBLOT "SP001" //子产品批次/料号
|
|
|
|
|
|
CManage* CManage::m_pInstance = NULL;
|
|
|
CManage::CManage(void)
|
|
|
{
|
|
|
char buff[MAX_NAME_LEN] = {0};
|
|
|
|
|
|
m_pv = NULL;
|
|
|
m_pt = NULL;
|
|
|
m_pclear = NULL;
|
|
|
m_pFour = NULL;
|
|
|
m_pntake = NULL;
|
|
|
m_pnput = NULL;
|
|
|
m_pUph = NULL;
|
|
|
m_pAllUph = NULL;
|
|
|
m_pOutput = NULL;
|
|
|
m_pLot = NULL;
|
|
|
m_pEnda = NULL;
|
|
|
m_pPause = NULL;
|
|
|
m_pBin = NULL;
|
|
|
m_pCastoff = NULL;
|
|
|
|
|
|
_logct = 0;
|
|
|
m_prePut = 0;
|
|
|
memset(&m_cfg, 0, sizeof(m_cfg));
|
|
|
|
|
|
//test
|
|
|
m_brun = false;
|
|
|
m_tstRun = false;
|
|
|
m_bupdatevar = false;
|
|
|
m_pconn = new CTest();
|
|
|
m_hThread = INVALID_HANDLE;
|
|
|
for(int i = 0; i < TESTCNT; i++)
|
|
|
{
|
|
|
m_ptest[i] = new CTest();
|
|
|
sprintf(buff, "%d", 76001 + i);
|
|
|
m_psimTest[i] = new CSimTest(i + 1, buff);
|
|
|
}
|
|
|
m_pVisionTest = new CVision();
|
|
|
for (int i = 0; i < EVSize; i++)
|
|
|
{
|
|
|
m_pVision[i] = new CVision();
|
|
|
}
|
|
|
m_vacm_cnt = VACMCNT;
|
|
|
m_vacm_lst = new CProduct*[m_vacm_cnt];
|
|
|
memset(m_lst_index, 0, sizeof(m_lst_index));
|
|
|
memset(m_pvar_vacm, 0, sizeof(m_pvar_vacm));
|
|
|
memset(m_pvar_test, 0, sizeof(m_pvar_test));
|
|
|
memset(m_vacm_lst, 0, sizeof(CProduct*) *m_vacm_cnt);
|
|
|
m_hSection = sys_InitializeCriticalSection();
|
|
|
}
|
|
|
|
|
|
CManage::~CManage(void)
|
|
|
{
|
|
|
Deinit();
|
|
|
delete m_pconn;
|
|
|
delete []m_vacm_lst;
|
|
|
delete m_pVisionTest;
|
|
|
for (int i = 0; i < EVSize; i++)
|
|
|
{//释放视觉组
|
|
|
delete m_pVision[i];
|
|
|
}
|
|
|
for(int i = 0; i < TESTCNT; i++)
|
|
|
{
|
|
|
delete m_ptest[i];
|
|
|
delete m_psimTest[i];
|
|
|
}
|
|
|
sys_DeleteCriticalSection(m_hSection);
|
|
|
}
|
|
|
|
|
|
CManage* CManage::Get_Instance()
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
if (NULL == m_pInstance)
|
|
|
{
|
|
|
m_pInstance = new CManage;
|
|
|
}
|
|
|
}
|
|
|
catch (...)
|
|
|
{
|
|
|
}
|
|
|
return m_pInstance;
|
|
|
}
|
|
|
|
|
|
void CManage::ReleaseInstance()
|
|
|
{
|
|
|
FREE_ANY(m_pInstance);
|
|
|
}
|
|
|
|
|
|
cstr CManage::GetVersion()
|
|
|
{//4\5位版本号转化为字符串
|
|
|
int iver = VERSION;
|
|
|
char buff[16] = { 0 };
|
|
|
static char cver[16] = { 0 };
|
|
|
|
|
|
RETURN_CHK_NOPRT(0 == cver[0], cver);
|
|
|
|
|
|
if (iver > 10000)
|
|
|
{
|
|
|
sprintf(buff, "beta%d", iver % 10);
|
|
|
iver %= 10000;
|
|
|
}
|
|
|
else if (iver <= 0)
|
|
|
{
|
|
|
iver = 1001;
|
|
|
}
|
|
|
sprintf(cver, "%d_%d_%d_%d",
|
|
|
iver / 1000,
|
|
|
(iver / 100) % 10,
|
|
|
(iver / 10) % 10,
|
|
|
iver % 10
|
|
|
);
|
|
|
if (buff[0])
|
|
|
{
|
|
|
strcat(cver, " ");
|
|
|
strcat(cver, buff);
|
|
|
}
|
|
|
return cver;
|
|
|
}
|
|
|
|
|
|
int CManage::Init()
|
|
|
{
|
|
|
/*CreateVar("total1", "治具1测试总数", 0);
|
|
|
CreateVar("OK1", "治具1测试OK数", 0);
|
|
|
CreateVar("total2", "治具2测试总数", 0);
|
|
|
CreateVar("OK2", "治具2测试OK数", 0);
|
|
|
CreateVar("total3", "治具3测试总数", 0);
|
|
|
CreateVar("OK3", "治具3测试OK数", 0);
|
|
|
CreateVar("total4", "治具4测试总数", 0);
|
|
|
CreateVar("OK4", "治具4测试OK数", 0);
|
|
|
CreateVar("total5", "治具5测试总数", 0);
|
|
|
CreateVar("OK5", "治具5测试OK数", 0);
|
|
|
CreateVar("total6", "治具6测试总数", 0);
|
|
|
CreateVar("OK6", "治具6测试OK数", 0);*/
|
|
|
CreateVar("totalall", "测试总数", 1);
|
|
|
CreateVar("OKall", "测试总OK数", 1);
|
|
|
|
|
|
CreateVar("lot", "换料盘自动计数");
|
|
|
|
|
|
getVar("dualtest", "分组测试标识");
|
|
|
m_pv = getVar("v", "当前吸嘴编号", false);
|
|
|
m_pt = getVar("t", "当前治具/料仓编号", false);
|
|
|
m_pFour = getVar("pic", "一次拍几张图片");
|
|
|
m_pclear = getVar("clear", "清料信号");
|
|
|
m_pntake = getVar("ntake", "需要取多少颗料");
|
|
|
m_pnput = getVar("nput", "需要放多少颗料到OK仓");
|
|
|
m_pUph = getVar("uph", "最近5分钟uph");
|
|
|
m_pAllUph = getVar("uphs", "机台平均uph");
|
|
|
m_pOutput = getVar("output", "最近工作产量");
|
|
|
m_pEnda = getVar("enda", "A组结束序号");
|
|
|
m_pPause = getVar("ops_pause", "ops系统信号");
|
|
|
m_pBin = getVar("tlevel", "产品分bin信息");
|
|
|
m_pCastoff = getVar("castoff", "临时取料索引");
|
|
|
m_pCastoff->seti(0);
|
|
|
ReadConfig();
|
|
|
StartRun();
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CManage::Deinit()
|
|
|
{
|
|
|
StopRun();
|
|
|
while (m_tstRun); //等待退出
|
|
|
for (int i = 0; i < TESTCNT; i++)
|
|
|
{//先停线程
|
|
|
m_psimTest[i]->Deinit();
|
|
|
}
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
for (int i = 0; i < EVSize; i++)
|
|
|
{//释放视觉组
|
|
|
m_pVision[i]->Deinit();
|
|
|
}
|
|
|
m_pVisionTest->Deinit();
|
|
|
for(int i = 0; i < TESTCNT; i++)
|
|
|
{
|
|
|
m_ptest[i]->Close();
|
|
|
}
|
|
|
m_pconn->Close();
|
|
|
Release();
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CManage::EventTracker(const char* keyword, int errcode, const char*errmsg, const char*msg)
|
|
|
{
|
|
|
int ret = 0;
|
|
|
SYS_TIME tm;
|
|
|
cstr pszuser = NULL;
|
|
|
char files[KEY_LEN] = { 0 };
|
|
|
const char* title = "VERSION,SITEID,PROJECTID,MACHINEID,DATE,TIME,"
|
|
|
"LOT NAME,LOGIN MODE,KEYWORD,ERROR CODE,ERROR MESSAGE,MESSAGE\n";
|
|
|
|
|
|
sys_GetLocalTime(&tm);
|
|
|
if (IsMakeDir())
|
|
|
{//按日期生成文件夹
|
|
|
sprintf(files, "Break_Event_Summary_Unit\\%04d%02d%02d\\EventTracker_%04d%02d%02d.csv",
|
|
|
tm.wYear, tm.wMonth, tm.wDay, tm.wYear, tm.wMonth, tm.wDay);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
sprintf(files, "Break_Event_Summary_Unit\\EventTracker_%04d%02d%02d.csv", tm.wYear, tm.wMonth, tm.wDay);
|
|
|
}
|
|
|
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
if (!files_read(files))
|
|
|
{
|
|
|
files_writes(files, title);
|
|
|
}
|
|
|
|
|
|
pszuser = get_cur_user();
|
|
|
ret = files_write(files, "%s,%s,%s,%s,%02d/%02d/%04d,%02d:%02d:%02d,%s,%s,%s,%d,%s,%s\n",
|
|
|
GetVersion(), m_cfg.sitel, m_cfg.project, m_cfg.machine,
|
|
|
tm.wDay, tm.wMonth, tm.wYear,
|
|
|
tm.wHour, tm.wMinute, tm.wSecond,
|
|
|
m_cfg.lot, pszuser ? pszuser : "OP", keyword, errcode, errmsg, msg);
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
if (ret) REPORT("写入日志%s 失败", files);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CManage::UnitTracker(const char* sn, const char* ate, const char* lot, int result, const char* RetryUsage)
|
|
|
{
|
|
|
int ret = 0;
|
|
|
SYS_TIME tm;
|
|
|
cstr pszuser = NULL;
|
|
|
char files[KEY_LEN] = { 0 };
|
|
|
const char* title = "SiteID,ProjectID,MachineID,Date,Time,LotName,"
|
|
|
"LoginMode,Serial Number,Socker ID,Test Result,Trial,Socket Usage\n";
|
|
|
|
|
|
sys_GetLocalTime(&tm);
|
|
|
if (IsMakeDir())
|
|
|
{//按日期生成文件夹
|
|
|
sprintf(files, "Break_Event_Summary_Unit\\%04d%02d%02d\\UnitTracker_%04d%02d%02d.csv",
|
|
|
tm.wYear, tm.wMonth, tm.wDay, tm.wYear, tm.wMonth, tm.wDay);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
sprintf(files, "Break_Event_Summary_Unit\\UnitTracker_%04d%02d%02d.csv", tm.wYear, tm.wMonth, tm.wDay);
|
|
|
}
|
|
|
/*sprintf(files, "log\\%04d%02d%02d_%s_%s_%s_UnitTracker.csv",
|
|
|
tm.wYear, tm.wMonth, tm.wDay, pCfg->sitel, pCfg->project, MachineID);*/ //2021-09-24 修改
|
|
|
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
if (!files_read(files))
|
|
|
{
|
|
|
files_writes(files, title);
|
|
|
}
|
|
|
|
|
|
pszuser = get_cur_user();
|
|
|
ret = files_write(files, "%s,%s,%s,%02d/%02d/%04d,%02d:%02d:%02d,"
|
|
|
"%s,%s,%s,%s,%s,%s,%d%d%d%d%d%d\n",
|
|
|
/*core_version(), */m_cfg.sitel, m_cfg.project, m_cfg.machine,
|
|
|
tm.wDay, tm.wMonth, tm.wYear,
|
|
|
tm.wHour, tm.wMinute, tm.wSecond,
|
|
|
lot, pszuser ? pszuser : "OP", sn,
|
|
|
ate, (result == 1) ? "PASS" : "FAIL", RetryUsage,
|
|
|
m_ptest[0]->_data.benable,
|
|
|
m_ptest[1]->_data.benable,
|
|
|
m_ptest[2]->_data.benable,
|
|
|
m_ptest[3]->_data.benable,
|
|
|
m_ptest[4]->_data.benable,
|
|
|
m_ptest[5]->_data.benable);
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
if (ret) REPORT("写入日志%s 失败", files);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
ulong CManage::GetLastCT(ulong curct)
|
|
|
{//获取最后一次CT
|
|
|
ulong ct = _logct > 0 ? curct - _logct : 0;
|
|
|
_logct = curct;
|
|
|
return ct;
|
|
|
}
|
|
|
|
|
|
int CManage::SummaryLog(const char* title, const char* content)
|
|
|
{
|
|
|
int ret = 0;
|
|
|
SYS_TIME tm;
|
|
|
char files[KEY_LEN] = { 0 };
|
|
|
cstr pszuser = NULL;
|
|
|
//按日期生成文件夹
|
|
|
sys_GetLocalTime(&tm);
|
|
|
if (IsMakeDir())
|
|
|
{//按日期生成文件夹
|
|
|
sprintf(files, "Break_Event_Summary_Unit\\%04d%02d%02d\\Summary_%04d%02d%02d.csv",
|
|
|
tm.wYear, tm.wMonth, tm.wDay, tm.wYear, tm.wMonth, tm.wDay);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
sprintf(files, "Break_Event_Summary_Unit\\Summary_%04d%02d%02d.csv", tm.wYear, tm.wMonth, tm.wDay);
|
|
|
}
|
|
|
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
if (title && *title && !files_read(files))
|
|
|
{
|
|
|
files_writes(files, title);
|
|
|
}
|
|
|
|
|
|
ret = files_writes(files, content);
|
|
|
pszuser = get_cur_user();
|
|
|
if (pszuser != NULL && (!strcmp(pszuser, "AUDIT") || !strcmp(pszuser, "Audit")))
|
|
|
{
|
|
|
sprintf(files, "Break_Event_Summary_Unit\\AuditCheck.csv");
|
|
|
files_writes(files, content);
|
|
|
}
|
|
|
//ret = files_close(files);
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
if (ret) REPORT("写入日志%s 失败", files);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::BreakdownLog(const char* psztype, const char* pszmsg)
|
|
|
{
|
|
|
int ret = 0;
|
|
|
SYS_TIME tm;
|
|
|
char files[KEY_LEN] = { 0 };
|
|
|
|
|
|
static const char* psztitle = "Machine,Tester Category,Tester_Sequence_Item Detail,TimeStamp,Time(ms)\n";
|
|
|
|
|
|
RETURN_CHK_NOPRT(NodeLog(), 0);
|
|
|
RETURN_CHK_NOPRT(psztype && pszmsg, ERR_INPUT_PARAM);
|
|
|
|
|
|
sys_GetLocalTime(&tm);
|
|
|
if (IsMakeDir())
|
|
|
{//按日期生成文件夹
|
|
|
sprintf(files, "Break_Event_Summary_Unit\\%04d%02d%02d\\Breakdown_%04d%02d%02d.csv",
|
|
|
tm.wYear, tm.wMonth, tm.wDay, tm.wYear, tm.wMonth, tm.wDay);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
sprintf(files, "Break_Event_Summary_Unit\\Breakdown_%04d%02d%02d.csv", tm.wYear, tm.wMonth, tm.wDay);
|
|
|
}
|
|
|
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
if (!files_read(files))
|
|
|
{
|
|
|
files_writes(files, psztitle);
|
|
|
}
|
|
|
ret = files_write(files, "%s,%s,%s,%02d/%02d/%04d %02d:%02d:%02d.%03d,%d\n",
|
|
|
m_cfg.machine, psztype, pszmsg, tm.wMonth, tm.wDay, tm.wYear,
|
|
|
tm.wHour, tm.wMinute, tm.wSecond, tm.wMilliseconds, GetLastCT(sys_GetTickCount()));
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
if (ret) REPORT("写入日志%s 失败", files);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
cstr CManage::GetTestModel()
|
|
|
{
|
|
|
cstr pszuser = get_cur_user();
|
|
|
if (!pszuser) pszuser = "OP";
|
|
|
return GetTestMode(pszuser);
|
|
|
}
|
|
|
|
|
|
int CManage::SetConfig(CoreConfig* pcfg)
|
|
|
{
|
|
|
RETURN_CHK_NOPRT(pcfg->uphFrequency >= 0 && pcfg->uphFrequency <= 5, ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(pcfg->iSimYield >= 0 && pcfg->iSimYield <= 100, ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(pcfg->iSimCT >= 5 && pcfg->iSimCT <= 100, ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(pcfg->idualindex >= MINAEND && pcfg->idualindex <= TESTCNT, ERR_INPUT_PARAM);
|
|
|
|
|
|
if (strcmp(pcfg->lot, m_cfg.lot))
|
|
|
{
|
|
|
strcpy(m_cfg.lot, pcfg->lot);
|
|
|
modify_cfg(CFG_KEY, "lot", m_cfg.lot);
|
|
|
}
|
|
|
|
|
|
if (strcmp(pcfg->Config, m_cfg.Config))
|
|
|
{
|
|
|
strcpy(m_cfg.Config, pcfg->Config);
|
|
|
modify_cfg(CFG_KEY, "Config", m_cfg.Config);
|
|
|
}
|
|
|
|
|
|
if (strcmp(pcfg->ConfigD, m_cfg.ConfigD))
|
|
|
{
|
|
|
strcpy(m_cfg.ConfigD, pcfg->ConfigD);
|
|
|
modify_cfg(CFG_KEY, "ConfigD", m_cfg.ConfigD);
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (strcmp(pcfg->project, m_cfg.project))
|
|
|
{
|
|
|
strcpy(m_cfg.project, pcfg->project);
|
|
|
modify_cfg(CFG_KEY, "project", m_cfg.project);
|
|
|
}
|
|
|
|
|
|
if (strcmp(pcfg->sublotname, m_cfg.sublotname))
|
|
|
{
|
|
|
strcpy(m_cfg.sublotname, pcfg->sublotname);
|
|
|
modify_cfg(CFG_KEY, "sublotname", m_cfg.sublotname);
|
|
|
}
|
|
|
|
|
|
if (pcfg->bFourPic != m_cfg.bFourPic)
|
|
|
{//和工作盘一起放
|
|
|
m_cfg.bFourPic = pcfg->bFourPic;
|
|
|
m_pFour->seti(m_cfg.bFourPic ? 4 : 1);
|
|
|
modify_cfg_int(CFG_KEY, "bFourPic", m_cfg.bFourPic);
|
|
|
}
|
|
|
|
|
|
if (pcfg->bSavePos != m_cfg.bSavePos)
|
|
|
{//是否缓存位置
|
|
|
m_cfg.bSavePos = pcfg->bSavePos;
|
|
|
modify_cfg_int(CFG_KEY, "bSavePos", m_cfg.bSavePos);
|
|
|
}
|
|
|
|
|
|
//系统配置
|
|
|
if (strcmp(pcfg->sitel, m_cfg.sitel))
|
|
|
{
|
|
|
strcpy(m_cfg.sitel, pcfg->sitel);
|
|
|
modify_sys_cfg(CFG_KEY, "sitel", m_cfg.sitel);
|
|
|
}
|
|
|
|
|
|
if (strcmp(pcfg->BinA, m_cfg.BinA))
|
|
|
{//BinA
|
|
|
strcpy(m_cfg.BinA, pcfg->BinA);
|
|
|
modify_sys_cfg(CFG_KEY, "BinA", m_cfg.BinA);
|
|
|
}
|
|
|
|
|
|
if (strcmp(pcfg->serverip, m_cfg.serverip) && chk_ipaddress(pcfg->serverip))
|
|
|
{//测试服务器IP
|
|
|
strcpy(m_cfg.serverip, pcfg->serverip);
|
|
|
modify_sys_cfg(CFG_KEY, "serverip", m_cfg.serverip);
|
|
|
}
|
|
|
|
|
|
if (strcmp(pcfg->visionip, m_cfg.visionip) && chk_ipaddress(pcfg->visionip))
|
|
|
{//视觉服务器IP
|
|
|
strcpy(m_cfg.visionip, pcfg->visionip);
|
|
|
modify_sys_cfg(CFG_KEY, "visionip", m_cfg.visionip);
|
|
|
for (int i = 0; i < EVSize; i++)
|
|
|
{
|
|
|
m_pVision[i]->Deinit();
|
|
|
m_pVision[i]->Init(m_cfg.visionip, VPORT + i);
|
|
|
}
|
|
|
m_pVisionTest->Deinit();
|
|
|
m_pVisionTest->Init(m_cfg.visionip, VPORTEST);
|
|
|
}
|
|
|
|
|
|
if (strcmp(pcfg->machine, m_cfg.machine))
|
|
|
{
|
|
|
strcpy(m_cfg.machine, pcfg->machine);
|
|
|
//modify_cfg(CFG_KEY, "machine", m_cfg.machine);
|
|
|
modify_sys_cfg(CFG_KEY, "machine", m_cfg.machine);
|
|
|
}
|
|
|
|
|
|
if (pcfg->testType != m_cfg.testType)
|
|
|
{
|
|
|
m_cfg.testType = pcfg->testType;
|
|
|
modify_sys_cfg_int(CFG_KEY, "testType", m_cfg.testType);
|
|
|
}
|
|
|
|
|
|
if (pcfg->bNodeLog != m_cfg.bNodeLog)
|
|
|
{
|
|
|
m_cfg.bNodeLog = pcfg->bNodeLog;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bNodeLog", m_cfg.bNodeLog);
|
|
|
}
|
|
|
|
|
|
if (pcfg->bUpMes != m_cfg.bUpMes)
|
|
|
{
|
|
|
m_cfg.bUpMes = pcfg->bUpMes;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bUpMes", m_cfg.bUpMes);
|
|
|
}
|
|
|
|
|
|
if (pcfg->bUpMTcp != m_cfg.bUpMTcp)
|
|
|
{
|
|
|
m_cfg.bUpMTcp = pcfg->bUpMTcp;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bUpMTcp", m_cfg.bUpMTcp);
|
|
|
}
|
|
|
|
|
|
if (pcfg->bUpNoise != m_cfg.bUpNoise)
|
|
|
{
|
|
|
m_cfg.bUpNoise = pcfg->bUpNoise;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bUpNoise", m_cfg.bUpNoise);
|
|
|
}
|
|
|
|
|
|
if (pcfg->bSingleTestFilter != m_cfg.bSingleTestFilter)
|
|
|
{
|
|
|
m_cfg.bSingleTestFilter = pcfg->bSingleTestFilter;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bSingleTestFilter", m_cfg.bSingleTestFilter);
|
|
|
}
|
|
|
|
|
|
if (pcfg->bDirDate != m_cfg.bDirDate)
|
|
|
{
|
|
|
m_cfg.bDirDate = pcfg->bDirDate;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bDirDate", m_cfg.bDirDate);
|
|
|
}
|
|
|
|
|
|
if (pcfg->b2nd != m_cfg.b2nd)
|
|
|
{
|
|
|
m_cfg.b2nd = pcfg->b2nd;
|
|
|
modify_sys_cfg_int(CFG_KEY, "b2nd", m_cfg.b2nd);
|
|
|
}
|
|
|
|
|
|
if (pcfg->bTestlog != m_cfg.bTestlog)
|
|
|
{
|
|
|
m_cfg.bTestlog = pcfg->bTestlog;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bTestlog", m_cfg.bTestlog);
|
|
|
}
|
|
|
|
|
|
if (pcfg->bVisionlog != m_cfg.bVisionlog)
|
|
|
{
|
|
|
m_cfg.bVisionlog = pcfg->bVisionlog;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bVisionlog", m_cfg.bVisionlog);
|
|
|
}
|
|
|
|
|
|
if (pcfg->uphFrequency != m_cfg.uphFrequency)
|
|
|
{
|
|
|
m_cfg.uphFrequency = pcfg->uphFrequency;
|
|
|
modify_sys_cfg_int(CFG_KEY, "uphFrequency", m_cfg.uphFrequency);
|
|
|
}
|
|
|
|
|
|
if (pcfg->idualindex != m_cfg.idualindex)
|
|
|
{//分组序号
|
|
|
m_cfg.idualindex = pcfg->idualindex;
|
|
|
SetVarInit("dualtest", m_cfg.idualindex);
|
|
|
}
|
|
|
|
|
|
if (pcfg->bPassTestB != m_cfg.bPassTestB)
|
|
|
{//是否测试pass才进入B组测试
|
|
|
m_cfg.bPassTestB = pcfg->bPassTestB;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bPassTestB", m_cfg.bPassTestB);
|
|
|
}
|
|
|
|
|
|
if (pcfg->bBindB != m_cfg.bBindB)
|
|
|
{//B组是否为绑定模式 TC1->TCB1 TC2->TCB2
|
|
|
m_cfg.bBindB = pcfg->bBindB;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bBindB", m_cfg.bBindB);
|
|
|
}
|
|
|
|
|
|
if (pcfg->iSimYield != m_cfg.iSimYield)
|
|
|
{//模拟良率
|
|
|
m_cfg.iSimYield = pcfg->iSimYield;
|
|
|
modify_sys_cfg_int(CFG_KEY, "iSimYield", m_cfg.iSimYield);
|
|
|
}
|
|
|
|
|
|
if (pcfg->iSimCT != m_cfg.iSimCT)
|
|
|
{//模拟机台CT
|
|
|
m_cfg.iSimCT = pcfg->iSimCT;
|
|
|
modify_sys_cfg_int(CFG_KEY, "iSimCT", m_cfg.iSimCT);
|
|
|
}
|
|
|
|
|
|
if (pcfg->bSimTest1 != m_cfg.bSimTest1)
|
|
|
{
|
|
|
m_cfg.bSimTest1 = pcfg->bSimTest1;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bSimTest1", m_cfg.bSimTest1);
|
|
|
m_cfg.bSimTest1 ? m_psimTest[0]->Init() : m_psimTest[0]->Deinit();
|
|
|
}
|
|
|
|
|
|
if (pcfg->bSimTest2 != m_cfg.bSimTest2)
|
|
|
{
|
|
|
m_cfg.bSimTest2 = pcfg->bSimTest2;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bSimTest2", m_cfg.bSimTest2);
|
|
|
m_cfg.bSimTest2 ? m_psimTest[1]->Init() : m_psimTest[1]->Deinit();
|
|
|
}
|
|
|
|
|
|
if (pcfg->bSimTest3 != m_cfg.bSimTest3)
|
|
|
{
|
|
|
m_cfg.bSimTest3 = pcfg->bSimTest3;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bSimTest3", m_cfg.bSimTest3);
|
|
|
m_cfg.bSimTest3 ? m_psimTest[2]->Init() : m_psimTest[2]->Deinit();
|
|
|
}
|
|
|
|
|
|
if (pcfg->bSimTest4 != m_cfg.bSimTest4)
|
|
|
{
|
|
|
m_cfg.bSimTest4 = pcfg->bSimTest4;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bSimTest4", m_cfg.bSimTest4);
|
|
|
m_cfg.bSimTest4 ? m_psimTest[3]->Init() : m_psimTest[3]->Deinit();
|
|
|
}
|
|
|
|
|
|
if (pcfg->bSimTest5 != m_cfg.bSimTest5)
|
|
|
{
|
|
|
m_cfg.bSimTest5 = pcfg->bSimTest5;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bSimTest5", m_cfg.bSimTest5);
|
|
|
m_cfg.bSimTest5 ? m_psimTest[4]->Init() : m_psimTest[4]->Deinit();
|
|
|
}
|
|
|
|
|
|
if (pcfg->bSimTest6 != m_cfg.bSimTest6)
|
|
|
{
|
|
|
m_cfg.bSimTest6 = pcfg->bSimTest6;
|
|
|
modify_sys_cfg_int(CFG_KEY, "bSimTest6", m_cfg.bSimTest6);
|
|
|
m_cfg.bSimTest6 ? m_psimTest[5]->Init() : m_psimTest[5]->Deinit();
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
void CManage::MakeInput()
|
|
|
{//生成进料盘
|
|
|
TMatrixInfo mat;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
get_matrix_info(LocationInput, &mat);
|
|
|
if (IsFourpic()) mat.size *= 4; //1拍4
|
|
|
for (int i = 0; i < mat.size; i++)
|
|
|
{
|
|
|
MakeProduct(LocationInput, i);
|
|
|
}
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
}
|
|
|
|
|
|
void CManage::Resize(vector<CProduct*>& vec, int nsize)
|
|
|
{//确保缓冲区够大
|
|
|
for (int i = (int)vec.size(); i < nsize; i++)
|
|
|
{
|
|
|
vec.push_back(NULL);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CManage::MakeProduct(int sindex, int index)
|
|
|
{//判断料盘某个位置是否有料？无料则创建一个
|
|
|
vector<CProduct*>& vec = m_vecStock[sindex - LocationInput];
|
|
|
Resize(vec, index + 1);
|
|
|
if (!vec[index]) vec[index] = new CProduct(sindex);
|
|
|
}
|
|
|
|
|
|
void CManage::ReleaseProduct(int sindex, int index)
|
|
|
{//判断料盘某个位置是否有料？有料则释放
|
|
|
vector<CProduct*>& vec = m_vecStock[sindex - LocationInput];
|
|
|
|
|
|
ZERO_CHK(index < (int)vec.size());
|
|
|
ZERO_CHK(vec[index]);
|
|
|
|
|
|
FreeProduct(vec[index]);
|
|
|
vec[index] = NULL;
|
|
|
}
|
|
|
|
|
|
CProduct* CManage::GetFromInput()
|
|
|
{//从进料仓获取物料
|
|
|
int index = 0;
|
|
|
TMatrixInfo mat;
|
|
|
TMatrixNode node;
|
|
|
CProduct* p = NULL;
|
|
|
vector<CProduct*>& vec = m_vecStock[LocationInput - LocationInput];
|
|
|
|
|
|
index = m_pCastoff->geti();
|
|
|
if (index > 0)
|
|
|
{//传入index
|
|
|
m_pCastoff->seti(0);
|
|
|
get_matrix_info(LocationInput, &mat);
|
|
|
get_matrix_cur_node(LocationInput, &node);
|
|
|
if (IsFourpic())
|
|
|
{//4次拍照 index依次传入1234 对应位置位左上、右上、左下、右下
|
|
|
index = (node.col - 1) * 2 + (node.row - 1) * 2 * mat.col * 2
|
|
|
+ ((index - 1) / 2) * mat.col * 2 + (index - 1) % 2 + 1;
|
|
|
}
|
|
|
else index = node.index; //不是1拍4则直接获取当前料盘索引
|
|
|
}
|
|
|
else index = GetPosxy(LocationInput); //从上次取料位置获取
|
|
|
if (index > 0 && index <= (int)vec.size() && vec[index - 1])
|
|
|
{//索引有效，且有值
|
|
|
p = vec[index - 1];
|
|
|
vec[index - 1] = NULL;
|
|
|
p->Clear();
|
|
|
//return p;
|
|
|
}
|
|
|
else p = new CProduct();
|
|
|
p->data.takeIndex = index;
|
|
|
return p;
|
|
|
}
|
|
|
|
|
|
void CManage::PutToStock(int sindex, CProduct* p)
|
|
|
{//放入料仓 -- sindex != LocationInput
|
|
|
int index = 0;
|
|
|
TMatrixNode node;
|
|
|
vector<CProduct*>& vec = m_vecStock[sindex - LocationInput];
|
|
|
|
|
|
m_pOutput->seti(m_pOutput->geti() + 1); //计数+1
|
|
|
p->data.pos = (EMapPos)sindex;
|
|
|
index = GetPosxy(sindex);
|
|
|
if (0 == index)
|
|
|
{//无效值
|
|
|
get_matrix_cur_node(sindex, &node);
|
|
|
index = node.index;
|
|
|
}
|
|
|
|
|
|
if (0 == index) index = 1; //为什么会运行这一步?
|
|
|
|
|
|
Resize(vec, index); //确保vec[index-1]可以访问
|
|
|
FreeProduct(vec[index - 1]); //若有，则释放
|
|
|
vec[index - 1] = p;
|
|
|
p->data.index = index; //赋值索引
|
|
|
}
|
|
|
|
|
|
int CManage::SetPosxy(int sindex)
|
|
|
{//posget sindex 获取拍照数据 变量res=0标识获取成功,拍照补偿写入(sn,x,y)。否则标识要拍照获取数据
|
|
|
TPosxy* p = NULL;
|
|
|
|
|
|
RETURN_CHK_NOPRT(sindex >= LocationInput && sindex <= LocationNg3, ERR_INPUT_PARAM);
|
|
|
|
|
|
list<TPosxy*>& lst = m_lst_pos[sindex - LocationInput];
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
if (!lst.empty())
|
|
|
{//队列有值
|
|
|
p = lst.front();
|
|
|
lst.pop_front();
|
|
|
if (IsSavePos()) m_lst_posTmp[sindex - LocationInput].push_back(p);
|
|
|
}
|
|
|
else RestorePos(sindex); //恢复
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
|
|
|
if (p)
|
|
|
{//有位置
|
|
|
set_var("sn", p->sn);
|
|
|
set_int_var("res", 0);
|
|
|
set_double_var("x", p->x);
|
|
|
set_double_var("y", p->y);
|
|
|
m_lst_index[sindex - LocationInput] = p->index;
|
|
|
if (!IsSavePos()) delete p;
|
|
|
}
|
|
|
else
|
|
|
{//is null
|
|
|
set_var("sn", "");
|
|
|
set_int_var("res", -1);
|
|
|
set_double_var("x", 0);
|
|
|
set_double_var("y", 0);
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CManage::GetPosxy(int sindex)
|
|
|
{//获取上一次获取位置时的索引 -- 并重置
|
|
|
int index = 0;
|
|
|
|
|
|
RETURN_CHK_NOPRT(sindex >= LocationInput && sindex <= LocationNg3, 0);
|
|
|
|
|
|
index = m_lst_index[sindex - LocationInput];
|
|
|
m_lst_index[sindex - LocationInput] = 0;
|
|
|
return index;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
int CManage::GetPosxy(int sindex)
|
|
|
{//获取位置索引，并从队列删除
|
|
|
int index = 0;
|
|
|
TPosxy* p = NULL;
|
|
|
|
|
|
RETURN_CHK_NOPRT(sindex >= LocationInput && sindex <= LocationNg3, 0);
|
|
|
|
|
|
list<TPosxy*>& lst = m_lst_pos[sindex - LocationInput];
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
if (!lst.empty())
|
|
|
{
|
|
|
p = lst.front();
|
|
|
lst.pop_front();
|
|
|
if (IsSavePos()) m_lst_posTmp[sindex - LocationInput].push_back(p);
|
|
|
}
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
|
|
|
RETURN_CHK_NOPRT(p, 0);
|
|
|
|
|
|
index = p->index;
|
|
|
if (!IsSavePos()) delete p;
|
|
|
return index;
|
|
|
}
|
|
|
*/
|
|
|
|
|
|
void CManage::RestorePos(int sindex)
|
|
|
{//从tmp队列恢复到主队列
|
|
|
TPosxy* p = NULL;
|
|
|
list<TPosxy*>& lst = m_lst_pos[sindex - LocationInput];
|
|
|
list<TPosxy*>& lstT = m_lst_posTmp[sindex - LocationInput];
|
|
|
//sys_EnterCriticalSection(m_hSection);
|
|
|
while (!lstT.empty())
|
|
|
{
|
|
|
lst.push_back(lstT.front());
|
|
|
lstT.pop_front();
|
|
|
}
|
|
|
//sys_LeaveCriticalSection(m_hSection);
|
|
|
}
|
|
|
|
|
|
int CManage::PosMap(int sindex)
|
|
|
{//posmap sindex 通过3点数据计算矩阵
|
|
|
int col = 0;
|
|
|
int row = 0;
|
|
|
TMatrixInfo mat;
|
|
|
TPosxy* p = NULL;
|
|
|
TPosxy* p1 = NULL;
|
|
|
TPosxy* p2 = NULL;
|
|
|
TPosxy* p3 = NULL;
|
|
|
double offsetc = 0;
|
|
|
double offsetr = 0;
|
|
|
|
|
|
RETURN_CHK_NOPRT(sindex >= LocationInput && sindex <= LocationNg3, ERR_INPUT_PARAM);
|
|
|
|
|
|
list<TPosxy*>& lst = m_lst_pos[sindex - LocationInput];
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
if (lst.size() != 3)
|
|
|
{//必须是3组数据
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ERR_INPUT_PARAM;
|
|
|
}
|
|
|
p1 = lst.front();
|
|
|
lst.pop_front();
|
|
|
p2 = lst.front();
|
|
|
lst.pop_front();
|
|
|
p3 = lst.front();
|
|
|
lst.pop_front();
|
|
|
ReleasePosxy(sindex); //释放队列
|
|
|
|
|
|
get_matrix_info(sindex, &mat);
|
|
|
if (IsFourpic() && LocationInput == sindex)
|
|
|
{//一次拍4个
|
|
|
mat.row *= 2;
|
|
|
mat.col *= 2;
|
|
|
mat.size *= 4;
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < mat.size; i++)
|
|
|
{//生成阵列 //memset(p, 0, sizeof(TPosxy));
|
|
|
p = new TPosxy;
|
|
|
p->index = i + 1;
|
|
|
col = i % mat.col;
|
|
|
row = i / mat.col;
|
|
|
//计算x轴
|
|
|
offsetc = mat.col > 1 ? (p2->x - p1->x) / (mat.col - 1) : 0.0f;
|
|
|
offsetr = mat.row > 1 ? (p3->x - p1->x) / (mat.row - 1) : 0.0f;
|
|
|
p->x = p1->x + offsetc * col + offsetr * row;
|
|
|
//计算y轴
|
|
|
offsetc = mat.col > 1 ? (p2->y - p1->y) / (mat.col - 1) : 0.0f;
|
|
|
offsetr = mat.row > 1 ? (p3->y - p1->y) / (mat.row - 1) : 0.0f;
|
|
|
p->y = p1->y + offsetc * col + offsetr * row;
|
|
|
lst.push_back(p);
|
|
|
}
|
|
|
delete p1;
|
|
|
delete p2;
|
|
|
delete p3;
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CManage::ReleasePosxy(int sindex)
|
|
|
{
|
|
|
RETURN_CHK_NOPRT(sindex >= LocationInput && sindex <= LocationNg3, ERR_INPUT_PARAM);
|
|
|
list<TPosxy*>& lst = m_lst_pos[sindex - LocationInput];
|
|
|
list<TPosxy*>& lstT = m_lst_posTmp[sindex - LocationInput];
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
while (!lst.empty())
|
|
|
{//释放主队列
|
|
|
FREE_ANY(lst.front());
|
|
|
lst.pop_front();
|
|
|
}
|
|
|
while (!lstT.empty())
|
|
|
{//释放缓冲区
|
|
|
FREE_ANY(lstT.front());
|
|
|
lstT.pop_front();
|
|
|
}
|
|
|
m_lst_index[sindex - LocationInput] = 0; //置0
|
|
|
if (LocationInput == sindex && m_pCastoff) m_pCastoff->seti(0); //变量标识清零
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
void CManage::Release()
|
|
|
{//释放内存
|
|
|
vector<CProduct*>::iterator it;
|
|
|
for (int i = 0; i < STOCKCNT; i++)
|
|
|
{//释放数据
|
|
|
ReleasePosxy(i + LocationInput);
|
|
|
for (it = m_vecStock[i].begin(); it != m_vecStock[i].end(); it++)
|
|
|
{//释放
|
|
|
FreeProduct(*it);
|
|
|
}
|
|
|
m_vecStock[i].clear();
|
|
|
}
|
|
|
for(auto it = m_hash_lst.begin(); it != m_hash_lst.end(); it++)
|
|
|
{//释放map表里面剩余的数据，一般到这都是空列表了
|
|
|
delete it->second;
|
|
|
}
|
|
|
m_hash_lst.clear();
|
|
|
}
|
|
|
|
|
|
void CManage::ReadConfig()
|
|
|
{
|
|
|
const char* ptmp = NULL;
|
|
|
|
|
|
ptmp = get_cfg(CFG_KEY, "Config");
|
|
|
comm_strncpy(m_cfg.Config, ptmp ? ptmp : CONFIG, MAX_NAME_LEN);
|
|
|
|
|
|
ptmp = get_cfg(CFG_KEY, "ConfigD");
|
|
|
comm_strncpy(m_cfg.ConfigD, ptmp ? ptmp : CONFIG, MAX_NAME_LEN);
|
|
|
|
|
|
ptmp = get_cfg(CFG_KEY, "lot");
|
|
|
comm_strncpy(m_cfg.lot, ptmp ? ptmp : LOT, MAX_NAME_LEN);
|
|
|
|
|
|
ptmp = get_cfg(CFG_KEY, "project");
|
|
|
comm_strncpy(m_cfg.project, ptmp ? ptmp : PRONA, MAX_NAME_LEN);
|
|
|
|
|
|
ptmp = get_cfg(CFG_KEY, "sublotname");
|
|
|
comm_strncpy(m_cfg.sublotname, ptmp ? ptmp : SUBLOT, MAX_NAME_LEN);
|
|
|
|
|
|
ptmp = get_cfg(CFG_KEY, "bFourPic");
|
|
|
m_cfg.bFourPic = ptmp ? atoi(ptmp) : 1; //默认1拍4
|
|
|
m_pFour->seti(m_cfg.bFourPic ? 4 : 1);
|
|
|
|
|
|
ptmp = get_cfg(CFG_KEY, "bSavePos");
|
|
|
m_cfg.bSavePos = ptmp ? atoi(ptmp) : 1; //默认缓存位置
|
|
|
|
|
|
//以下项使用系统配置，不跟随产品变化
|
|
|
ptmp = get_sys_cfg(CFG_KEY, "sitel");
|
|
|
comm_strncpy(m_cfg.sitel, ptmp ? ptmp : SITEL, MAX_NAME_LEN);
|
|
|
|
|
|
ptmp = get_sys_cfg(CFG_KEY, "BinA");
|
|
|
comm_strncpy(m_cfg.BinA, ptmp ? ptmp : BINA, MAX_NAME_LEN);
|
|
|
|
|
|
ptmp = get_sys_cfg(CFG_KEY, "serverip");
|
|
|
strcpy(m_cfg.serverip, chk_ipaddress(ptmp) ? ptmp : ANY_IP);
|
|
|
|
|
|
ptmp = get_sys_cfg(CFG_KEY, "visionip");
|
|
|
strcpy(m_cfg.visionip, chk_ipaddress(ptmp) ? ptmp : "127.0.0.1");
|
|
|
|
|
|
ptmp = get_sys_cfg(CFG_KEY, "machine");
|
|
|
comm_strncpy(m_cfg.machine, ptmp ? ptmp : MACHINE, MAX_NAME_LEN);
|
|
|
|
|
|
m_cfg.uphFrequency = get_sys_cfg_int(CFG_KEY, "uphFrequency");
|
|
|
if (m_cfg.uphFrequency < 0 || m_cfg.uphFrequency > 5) m_cfg.uphFrequency = 0;
|
|
|
m_cfg.testType = get_sys_cfg_int(CFG_KEY, "testType");
|
|
|
m_cfg.bNodeLog = get_sys_cfg_int(CFG_KEY, "bNodeLog");
|
|
|
m_cfg.bUpMes = get_sys_cfg_int(CFG_KEY, "bUpMes");
|
|
|
m_cfg.bUpMTcp = get_sys_cfg_int(CFG_KEY, "bUpMTcp");
|
|
|
m_cfg.bUpNoise = get_sys_cfg_int(CFG_KEY, "bUpNoise");
|
|
|
m_cfg.bSingleTestFilter = get_sys_cfg_int(CFG_KEY, "bSingleTestFilter");
|
|
|
m_cfg.b2nd = get_sys_cfg_int(CFG_KEY, "b2nd");
|
|
|
m_cfg.bTestlog = get_sys_cfg_int(CFG_KEY, "bTestlog");
|
|
|
m_cfg.bVisionlog = get_sys_cfg_int(CFG_KEY, "bVisionlog");
|
|
|
m_cfg.idualindex = get_int_var("dualtest");
|
|
|
m_cfg.bPassTestB = get_sys_cfg_int(CFG_KEY, "bPassTestB");
|
|
|
m_cfg.bBindB = get_sys_cfg_int(CFG_KEY, "bBindB");
|
|
|
if (m_cfg.idualindex < MINAEND || m_cfg.idualindex > TESTCNT)
|
|
|
{//不合法 -- 默认A(1-4) B(5-6)
|
|
|
m_cfg.idualindex = TESTCNT; //默认不分组
|
|
|
SetVarInit("dualtest", m_cfg.idualindex);
|
|
|
}
|
|
|
|
|
|
ptmp = get_sys_cfg(CFG_KEY, "bDirDate");
|
|
|
m_cfg.bDirDate = ptmp ? atoi(ptmp) : 1; //默认要生成日期文件夹
|
|
|
|
|
|
ptmp = get_sys_cfg(CFG_KEY, "iSimYield");
|
|
|
m_cfg.iSimYield = ptmp ? atoi(ptmp) : 100;
|
|
|
if (m_cfg.iSimYield < 0 || m_cfg.iSimYield > 100)
|
|
|
{//不合法 -- 默认100
|
|
|
m_cfg.iSimYield = 100;
|
|
|
modify_sys_cfg_int(CFG_KEY, "iSimYield", m_cfg.iSimYield);
|
|
|
}
|
|
|
|
|
|
ptmp = get_sys_cfg(CFG_KEY, "iSimCT");
|
|
|
m_cfg.iSimCT = ptmp ? atoi(ptmp) : 30;
|
|
|
if (m_cfg.iSimCT < 5 || m_cfg.iSimCT > 100)
|
|
|
{//不合法 -- 默认30
|
|
|
m_cfg.iSimCT = 30;
|
|
|
modify_sys_cfg_int(CFG_KEY, "iSimCT", m_cfg.iSimCT);
|
|
|
}
|
|
|
m_cfg.bSimTest1 = get_sys_cfg_int(CFG_KEY, "bSimTest1");
|
|
|
m_cfg.bSimTest2 = get_sys_cfg_int(CFG_KEY, "bSimTest2");
|
|
|
m_cfg.bSimTest3 = get_sys_cfg_int(CFG_KEY, "bSimTest3");
|
|
|
m_cfg.bSimTest4 = get_sys_cfg_int(CFG_KEY, "bSimTest4");
|
|
|
m_cfg.bSimTest5 = get_sys_cfg_int(CFG_KEY, "bSimTest5");
|
|
|
m_cfg.bSimTest6 = get_sys_cfg_int(CFG_KEY, "bSimTest6");
|
|
|
if (m_cfg.bSimTest1) m_psimTest[0]->Init();
|
|
|
if (m_cfg.bSimTest2) m_psimTest[1]->Init();
|
|
|
if (m_cfg.bSimTest3) m_psimTest[2]->Init();
|
|
|
if (m_cfg.bSimTest4) m_psimTest[3]->Init();
|
|
|
if (m_cfg.bSimTest5) m_psimTest[4]->Init();
|
|
|
if (m_cfg.bSimTest6) m_psimTest[5]->Init();
|
|
|
for (int i = 0; i < EVSize; i++)
|
|
|
{
|
|
|
m_pVision[i]->Init(m_cfg.visionip, VPORT + i);
|
|
|
}
|
|
|
m_pVisionTest->Init(m_cfg.visionip, VPORTEST);
|
|
|
}
|
|
|
|
|
|
int CManage::CreateVar(const char* pszname, const char* pszdesc, int keep)
|
|
|
{
|
|
|
TVar v;
|
|
|
int tid = 0;
|
|
|
|
|
|
tid = get_var_id(pszname);
|
|
|
|
|
|
RETURN_CHK_NOPRT(tid <= 0, tid);
|
|
|
|
|
|
memset(&v, 0, sizeof(v));
|
|
|
strcpy(v.val, "0");
|
|
|
strcpy(v.desc, pszdesc);
|
|
|
strcpy(v.name, pszname);
|
|
|
v.bkeep = keep;
|
|
|
return create_var(&v) ? 0 : v.id;
|
|
|
}
|
|
|
|
|
|
void CManage::SetVarInit(const char* pszname, int ival)
|
|
|
{
|
|
|
TVar v;
|
|
|
int tid = 0;
|
|
|
ipvar* p = NULL;
|
|
|
|
|
|
tid = get_var_id(pszname);
|
|
|
if (tid <= 0)
|
|
|
{//create
|
|
|
memset(&v, 0, sizeof(v));
|
|
|
strcpy(v.desc, pszname);
|
|
|
strcpy(v.name, pszname);
|
|
|
sprintf(v.val, "%d", ival);
|
|
|
create_var(&v);
|
|
|
}
|
|
|
else
|
|
|
{//set
|
|
|
get_var_info(tid, &v);
|
|
|
sprintf(v.val, "%d", ival);
|
|
|
update_var(&v);
|
|
|
p = get_ipvar(v.id);
|
|
|
if (p) p->seti(ival);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
ipvar* CManage::getVar(const char* pszname, const char* pszdesc, bool block)
|
|
|
{
|
|
|
int tid = 0;
|
|
|
ipvar* p = NULL;
|
|
|
|
|
|
tid = CreateVar(pszname, pszdesc, 0);
|
|
|
|
|
|
p = get_ipvar(tid);
|
|
|
|
|
|
RETURN_CHK_NOPRT(p, 0);
|
|
|
|
|
|
if (block) p->lock(); //锁定
|
|
|
return p;
|
|
|
}
|
|
|
|
|
|
ipvar* CManage::getVar(const char* pszname, const char* pszdesc, const char* pszval)
|
|
|
{
|
|
|
TVar v;
|
|
|
ipvar* p = get_ipvars(pszname);
|
|
|
if (!p)
|
|
|
{//no exist
|
|
|
memset(&v, 0, sizeof(v));
|
|
|
strcpy(v.val, pszval);
|
|
|
strcpy(v.desc, pszdesc);
|
|
|
strcpy(v.name, pszname);
|
|
|
create_var(&v);
|
|
|
p = get_ipvars(pszname);
|
|
|
}
|
|
|
if (p) p->lock(); //锁定
|
|
|
return p;
|
|
|
}
|
|
|
|
|
|
CProduct* CManage::FindProduct(const char* sn)
|
|
|
{
|
|
|
CProduct* p = NULL;
|
|
|
hash_map<string, CProduct*>::iterator it;
|
|
|
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
it = m_hash_lst.find(sn);
|
|
|
if (it != m_hash_lst.end())
|
|
|
{
|
|
|
p = it->second;
|
|
|
}
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return p;
|
|
|
}
|
|
|
|
|
|
void CManage::FreeProduct(CProduct* p)
|
|
|
{
|
|
|
hash_map<string, CProduct*>::iterator it;
|
|
|
|
|
|
ZERO_CHK(p);
|
|
|
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
it = m_hash_lst.find(p->data.sn);
|
|
|
if (it != m_hash_lst.end())
|
|
|
{
|
|
|
m_hash_lst.erase(it);
|
|
|
}
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
LOG_INF1("relsease product:%s", p->data.sn);
|
|
|
delete p;
|
|
|
}
|
|
|
|
|
|
int CManage::GreaterThenProduct(const void* a, const void* b)
|
|
|
{
|
|
|
int ret = 0;
|
|
|
const TProduct* info1 = (const TProduct*)a;
|
|
|
const TProduct* info2 = (const TProduct*)b;
|
|
|
|
|
|
ret = info1->pos - info2->pos;
|
|
|
RETURN_CHK_NOPRT(!ret, ret);
|
|
|
|
|
|
return strcmp(info1->start, info2->start);
|
|
|
}
|
|
|
|
|
|
int CManage::GetProductByPos(EMapPos pos, int index, TProduct* pdata/* = 0*/)
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = GetProductByPosB(pos, index, pdata);
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::GetProductList(EMapPos pos, TProduct* pdata/* = 0*/, int nsize/* = 0*/)
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = GetProductListB(pos, pdata, nsize);
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::GetProductByPosB(EMapPos pos, int index, TProduct* pdata/* = 0*/)
|
|
|
{
|
|
|
CProduct* p = NULL;
|
|
|
switch (pos)
|
|
|
{
|
|
|
case LocationVacm:
|
|
|
RETURN_CHK_NOPRT(index > 0 && index <= m_vacm_cnt, ERR_INPUT_PARAM);
|
|
|
p = m_vacm_lst[index-1];
|
|
|
break;
|
|
|
case LocationTest:
|
|
|
RETURN_CHK_NOPRT(index > 0 && index <= TESTCNT, ERR_INPUT_PARAM);
|
|
|
p = m_ptest[index - 1]->getProduct();
|
|
|
break;
|
|
|
default:
|
|
|
RETURN_CHK_NOPRT(index > 0 && index <= (int)m_vecStock[pos - LocationInput].size(), ERR_INPUT_PARAM);
|
|
|
p = m_vecStock[pos - LocationInput][index - 1];
|
|
|
break;
|
|
|
}
|
|
|
RETURN_CHK_NOPRT(p, ERR_INPUT_PARAM);
|
|
|
if (pdata) memcpy(pdata, &p->data, sizeof(TProduct));
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CManage::GetProductListB(EMapPos pos, TProduct* pdata/* = 0*/, int nsize/* = 0*/)
|
|
|
{
|
|
|
int ncnt = 0;
|
|
|
switch (pos)
|
|
|
{
|
|
|
case LocationVacm:
|
|
|
for(int i = 0; i < m_vacm_cnt; i++)
|
|
|
{//遍历吸嘴
|
|
|
if (!m_vacm_lst[i]) continue;
|
|
|
if (pdata)
|
|
|
{
|
|
|
if (ncnt >= nsize) return ncnt;
|
|
|
memcpy(pdata++, &m_vacm_lst[i]->data, sizeof(TProduct));
|
|
|
}
|
|
|
ncnt++;
|
|
|
}
|
|
|
break;
|
|
|
case LocationTest:
|
|
|
for(int i = 0; i < TESTCNT; i++)
|
|
|
{//遍历治具产品
|
|
|
if (!m_ptest[i]->getProduct()) continue;
|
|
|
if (pdata)
|
|
|
{
|
|
|
if (ncnt >= nsize) return ncnt;
|
|
|
memcpy(pdata++, &m_ptest[i]->getProduct()->data, sizeof(TProduct));
|
|
|
}
|
|
|
ncnt++;
|
|
|
}
|
|
|
break;
|
|
|
default:
|
|
|
vector<CProduct*>& lst = m_vecStock[pos - LocationInput];
|
|
|
for(int i = 0; i < (int)lst.size(); i++)
|
|
|
{//遍历其它料仓
|
|
|
if (!lst[i]) continue;
|
|
|
if (pdata)
|
|
|
{
|
|
|
if (ncnt >= nsize) return ncnt;
|
|
|
memcpy(pdata++, &lst[i]->data, sizeof(TProduct));
|
|
|
}
|
|
|
ncnt++;
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
return ncnt;
|
|
|
}
|
|
|
|
|
|
int CManage::GetProduct(const char* sn, TProduct* pdata)
|
|
|
{
|
|
|
int ret = ERR_INVALID_ID;
|
|
|
hash_map<string, CProduct*>::iterator it;
|
|
|
|
|
|
RETURN_CHK_NOPRT(sn && *sn && pdata, ERR_INPUT_PARAM);
|
|
|
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
it = m_hash_lst.find(sn);
|
|
|
if (it != m_hash_lst.end())
|
|
|
{
|
|
|
ret = 0;
|
|
|
memcpy(pdata, &it->second->data, sizeof(TProduct));
|
|
|
}
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::GetAllProduct(TProduct* pdata/* = 0*/, int nsize/* = 0*/)
|
|
|
{
|
|
|
int index = 0;
|
|
|
int ncount = 0;
|
|
|
hash_map<string, CProduct*>::iterator it;
|
|
|
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ncount = (int)m_hash_lst.size();
|
|
|
if (pdata)
|
|
|
{//需要获取
|
|
|
if (ncount > nsize) ncount = nsize;
|
|
|
for(it = m_hash_lst.begin(); it != m_hash_lst.end(); it++)
|
|
|
{
|
|
|
if (index >= ncount) break;
|
|
|
memcpy(&pdata[index++], &it->second->data, sizeof(TProduct));
|
|
|
}
|
|
|
qsort(pdata, ncount, sizeof(TProduct), CManage::GreaterThenProduct);
|
|
|
}
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ncount;
|
|
|
}
|
|
|
|
|
|
int CManage::GetMachine(int index, TestMachine* pdata)
|
|
|
{
|
|
|
RETURN_CHK_NOPRT(pdata && index > 0 && index <= TESTCNT, ERR_INPUT_PARAM);
|
|
|
memcpy(pdata, &m_ptest[index-1]->_data, sizeof(TestMachine));
|
|
|
//strcpy(pdata->sn, m_ptest[index-1]->_p ? _p)
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CManage::TestEnable(int index, int benable)
|
|
|
{
|
|
|
RETURN_CHK_NOPRT(index > 0 && index <= TESTCNT, ERR_INPUT_PARAM);
|
|
|
m_ptest[index-1]->_data.benable = benable;
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CManage::TestDebug(int index, const char* sn)
|
|
|
{
|
|
|
int ret = 0;
|
|
|
|
|
|
ret = TakeFromInput(sn, 1); //默认从1号吸嘴
|
|
|
|
|
|
RETURN_CHK_NOPRT(!ret, ret);
|
|
|
|
|
|
return MovetoTest(1, index);
|
|
|
}
|
|
|
|
|
|
int CManage::TestHome(int testIndex)
|
|
|
{
|
|
|
RETURN_CHK_NOPRT(testIndex > 0 && testIndex <= TESTCNT, ERR_INPUT_PARAM);
|
|
|
return m_ptest[testIndex - 1]->Home();
|
|
|
}
|
|
|
|
|
|
int CManage::TestReset(int testIndex)
|
|
|
{
|
|
|
RETURN_CHK_NOPRT(testIndex > 0 && testIndex <= TESTCNT, ERR_INPUT_PARAM);
|
|
|
return m_ptest[testIndex - 1]->Reset();
|
|
|
}
|
|
|
|
|
|
int CManage::TestClear(int testIndex)
|
|
|
{
|
|
|
RETURN_CHK_NOPRT(testIndex > 0 && testIndex <= TESTCNT, ERR_INPUT_PARAM);
|
|
|
m_ptest[testIndex - 1]->resetCounter();
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CManage::TestPause(int testIndex, int bpause)
|
|
|
{
|
|
|
RETURN_CHK_NOPRT(testIndex > 0 && testIndex <= TESTCNT, ERR_INPUT_PARAM);
|
|
|
return m_ptest[testIndex - 1]->Pause(bpause);
|
|
|
}
|
|
|
|
|
|
int CManage::GripEnable(int testIndex, int benable)
|
|
|
{
|
|
|
RETURN_CHK_NOPRT(testIndex > 0 && testIndex <= TESTCNT, ERR_INPUT_PARAM);
|
|
|
return m_ptest[testIndex - 1]->EnableGrip(benable);
|
|
|
}
|
|
|
|
|
|
int CManage::M1B()
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = M1();
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::M2B()
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = M2();
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::VacmResetB()
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = VacmReset();
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::StockResetB(int sindex)
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = StockReset(sindex);
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::VacmTakeB()
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = VacmTake();
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::TestPutB()
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = TestPut();
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::TestTakeB()
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = TestTake();
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::StockPutB()
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = StockPut();
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::WhereToGoB()
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = WhereToGo();
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::CreateProductB(const char* sn, int vacmIndex)
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = TakeFromInput(sn, vacmIndex);
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::MovetoVacmB(int testIndex, int vacmIndex)
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = MovetoVacm(testIndex, vacmIndex);
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::MovetoStockB(int vacmIndex, int sindex)
|
|
|
{
|
|
|
int ret = 0;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
ret = MovetoStock(vacmIndex, sindex);
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
int CManage::StartRun()
|
|
|
{//任务开始
|
|
|
RETURN_CHK_NOPRT(!m_brun, 0);
|
|
|
|
|
|
m_brun = true;
|
|
|
m_hThread = sys_CreateThread(ThreadFun, this);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CManage::StopRun()
|
|
|
{//关闭任务
|
|
|
RETURN_CHK_NOPRT(m_brun, 0);
|
|
|
|
|
|
m_brun = false;
|
|
|
sys_WaitForSingleObject(m_hThread);
|
|
|
sys_CloseHandle(m_hThread);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int CManage::GetTestIndex(const char* ate)
|
|
|
{//通过编码查找测试机台序号
|
|
|
for(int i = 0; i < TESTCNT; i++)
|
|
|
{
|
|
|
if (0 == strcmp(m_ptest[i]->_data.ate, ate))
|
|
|
{
|
|
|
return i + 1;
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int WINAPI CManage::ThreadFun(void* param)
|
|
|
{
|
|
|
CManage* p = (CManage*)param;
|
|
|
return p->Process();
|
|
|
}
|
|
|
|
|
|
int CManage::Process()
|
|
|
{
|
|
|
//ulong ct1, ct2;
|
|
|
while(m_brun)
|
|
|
{//循环
|
|
|
CalcUph(); //计算uph
|
|
|
//ct1 = sys_GetTickCount();
|
|
|
AcceptNew(); //等待新连接
|
|
|
//ct2 = sys_GetTickCount();
|
|
|
//if (ct2 > ct1) REPORT("AcceptNew ct: %dms", ct2 - ct1);
|
|
|
ProcessMsg(); //消息处理
|
|
|
//ct1 = sys_GetTickCount() - ct2;
|
|
|
//if ((ct1 > 0 && ct1 < 50) || ct1 > 110) REPORT("ProcessMsg ct: %dms", ct1);
|
|
|
//UploadReport();
|
|
|
//ct2 = sys_GetTickCount();
|
|
|
//if (ct2 > ct1) REPORT("UploadReport ct: %dms", ct2 - ct1);
|
|
|
UpdateVarProduct();
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
#define TMIN 1 //间隔多少分钟检测一次
|
|
|
|
|
|
static const int tmin[] = { 1, 2, 5, 6, 10, 20 };
|
|
|
|
|
|
void CManage::CalcUph()
|
|
|
{//计算uph
|
|
|
ulong wkc = 0;
|
|
|
ulong total = 0;
|
|
|
ulong cur = sys_GetTickCount();
|
|
|
ulong imin = tmin[m_cfg.uphFrequency];
|
|
|
static ulong lct = cur; //计时
|
|
|
static ulong alltm = 0; //总时间
|
|
|
static ulong lastotal = 0; //最后产量记录
|
|
|
|
|
|
ZERO_CHK(cur >= lct + imin * 60000);
|
|
|
|
|
|
lct = cur;
|
|
|
alltm += imin; //总时间
|
|
|
total = m_pOutput->geti();
|
|
|
wkc = total - lastotal; //此次产量多高？
|
|
|
lastotal = total;
|
|
|
m_pUph->seti(wkc * 60 / imin);
|
|
|
m_pAllUph->seti(total * 60 / alltm);
|
|
|
}
|
|
|
|
|
|
void CManage::UploadReport()
|
|
|
{//把日志传给UI
|
|
|
char* pmsg = NULL;
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
if (!m_lsgMsg.empty())
|
|
|
{//非空
|
|
|
pmsg = m_lsgMsg.front();
|
|
|
m_lsgMsg.pop_front();
|
|
|
}
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
if (pmsg)
|
|
|
{//send
|
|
|
send_messages(MSG_ASCII, pmsg);
|
|
|
delete pmsg;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CManage::AcceptNew()
|
|
|
{//等待连接
|
|
|
if (m_pconn->IsNormal())
|
|
|
{//已连接且已注册
|
|
|
*m_ptest[m_pconn->getIndex()-1] = *m_pconn; //赋值到对应位置
|
|
|
}
|
|
|
|
|
|
ZERO_CHK(!m_pconn->IsConn());
|
|
|
|
|
|
if (!m_pconn->IsOpen())
|
|
|
{//打开
|
|
|
m_pconn->Open(m_cfg.serverip);
|
|
|
}
|
|
|
|
|
|
m_pconn->Connect(); //触发连接
|
|
|
}
|
|
|
|
|
|
bool CManage::ChkAteValid(int index, const char* pszate)
|
|
|
{//检测治具编码是否重复
|
|
|
for (int i = 0; i < TESTCNT; i++)
|
|
|
{
|
|
|
if (i + 1 == index) continue;
|
|
|
if (!m_ptest[i]->IsNormal()) continue;
|
|
|
if (!stricmp(pszate, m_ptest[i]->_data.ate)) return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
static const char* psztgr[] = { "M1", "M2", "M3", "M4", "M5", "M6" };
|
|
|
|
|
|
int CManage::SendTestGR(int tindex, const char* s)
|
|
|
{
|
|
|
TOpsCfg cfg;
|
|
|
char buff[1024] = { 0 };
|
|
|
|
|
|
RETURN_CHK_NOPRT(tindex > 0 && tindex <= TESTCNT, ERR_INPUT_PARAM);
|
|
|
|
|
|
ops_get_cfg(&cfg);
|
|
|
if (cfg.offVision)
|
|
|
{//禁用视觉
|
|
|
return PostReplyGR(tindex, "0,1");
|
|
|
//return m_ptest[tindex - 1]->SendGR("0,1");
|
|
|
}
|
|
|
|
|
|
if (s && *s)
|
|
|
{//有附加参数
|
|
|
sprintf(buff, "%s,%s", psztgr[tindex - 1], s);
|
|
|
s = buff;
|
|
|
}
|
|
|
else s = psztgr[tindex - 1];
|
|
|
return m_pVisionTest->Send(s);
|
|
|
}
|
|
|
|
|
|
int CManage::PostReplyGR(int tindex, const char* s)
|
|
|
{
|
|
|
TGRMsg* pmsg = NULL;
|
|
|
|
|
|
RETURN_CHK_NOPRT(s && *s, ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(tindex > 0 && tindex <= TESTCNT, ERR_INPUT_PARAM);
|
|
|
|
|
|
pmsg = new TGRMsg;
|
|
|
pmsg->tindex = tindex;
|
|
|
pmsg->s = new char[strlen(s) + 1];
|
|
|
comm_strcpy(pmsg->s, s);
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
m_tstMsg.push_back(pmsg);
|
|
|
if (!m_tstRun)
|
|
|
{//启动线程
|
|
|
m_tstRun = true;
|
|
|
pool_thread(PoolGR, this);
|
|
|
}
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
void CManage::ProcessSendGR()
|
|
|
{//线程池执行
|
|
|
int ret = 0;
|
|
|
TGRMsg* pmsg = NULL;
|
|
|
while (1)
|
|
|
{
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
if (m_tstMsg.empty())
|
|
|
{//null
|
|
|
m_tstRun = false;
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
break;
|
|
|
}
|
|
|
pmsg = m_tstMsg.front();
|
|
|
m_tstMsg.pop_front();
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
ret = m_ptest[pmsg->tindex - 1]->SendGR(pmsg->s); //发送
|
|
|
if (ret)
|
|
|
{
|
|
|
LOG_ERR("test(%d) send:%s ERROR.", pmsg->tindex, pmsg->s);
|
|
|
}
|
|
|
delete pmsg->s;
|
|
|
delete pmsg;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
int WINAPI CManage::PoolGR(void* lparam)
|
|
|
{
|
|
|
((CManage*)lparam)->ProcessSendGR();
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
void CManage::RecvTestMsg()
|
|
|
{
|
|
|
char* pcmd = NULL;
|
|
|
char* ptmp = NULL;
|
|
|
char* pnext = NULL;
|
|
|
char msg[1024] = { 0 };
|
|
|
|
|
|
m_pVisionTest->RecvMsg(msg, 1024);
|
|
|
|
|
|
ZERO_CHK(msg[0]);
|
|
|
|
|
|
pnext = msg;
|
|
|
while (1)
|
|
|
{//可能有多条消息
|
|
|
ptmp = sys_strtok(NULL, ";", &pnext);
|
|
|
if (0 == ptmp || 0 == *ptmp) break;
|
|
|
pcmd = sys_strtok(NULL, ",", &ptmp);
|
|
|
for (int i = 0; i < TESTCNT; i++)
|
|
|
{
|
|
|
if (!stricmp(pcmd, psztgr[i]))
|
|
|
{//find tindex
|
|
|
//m_ptest[i]->SendGR(ptmp);
|
|
|
ins->PostReplyGR(i + 1, ptmp);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CManage::ProcessMsg()
|
|
|
{//消息处理
|
|
|
int ret = 0;
|
|
|
int index = 0;
|
|
|
vector<int> s;
|
|
|
vector<int> si;
|
|
|
|
|
|
if (m_pconn->IsConn())
|
|
|
{//处理其它事务，例如注册
|
|
|
m_pconn->Process();
|
|
|
if (m_pconn->IsConn())
|
|
|
{//process有可能断开连接
|
|
|
si.push_back(0); //序号0
|
|
|
s.push_back(m_pconn->getSocket());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//视觉检测
|
|
|
index++;
|
|
|
if (!m_pVisionTest->IsConn()) m_pVisionTest->Connect();
|
|
|
if (m_pVisionTest->IsConn())
|
|
|
{
|
|
|
si.push_back(1); //序号1
|
|
|
s.push_back(m_pVisionTest->getSocket());
|
|
|
}
|
|
|
|
|
|
index++;
|
|
|
for (int i = 0; i < EVSize; i++)
|
|
|
{
|
|
|
if (!m_pVision[i]->IsConn()) m_pVision[i]->Connect();
|
|
|
if (m_pVision[i]->IsConn())
|
|
|
{
|
|
|
si.push_back(i + index); //前面有2个固定位
|
|
|
s.push_back(m_pVision[i]->getSocket());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
index += EVSize;
|
|
|
for(int i = 0; i < TESTCNT; i++)
|
|
|
{//遍历处理
|
|
|
if (m_ptest[i]->IsConn())
|
|
|
{//process处理
|
|
|
m_ptest[i]->Process();
|
|
|
if (m_ptest[i]->IsConn())
|
|
|
{//process有可能断开连接
|
|
|
si.push_back(i + index);
|
|
|
s.push_back(m_ptest[i]->getSocket());
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (s.size() == 0)
|
|
|
{//没有连接对象
|
|
|
sys_Sleep(50);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
ret = sys_Select(&s[0], (int)s.size(), 100);
|
|
|
|
|
|
ZERO_CHK(ret >= 0);
|
|
|
|
|
|
ret = si[ret]; //获取序号
|
|
|
if (0 == ret)
|
|
|
{//等待连接测试治具
|
|
|
m_pconn->RecvMsg();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (1 == ret)
|
|
|
{//侧相机
|
|
|
RecvTestMsg();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (ret < index)
|
|
|
{//其它视觉对象
|
|
|
m_pVision[ret-2]->RecvMsg();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
//测试治具通信
|
|
|
//ulong ct1 = sys_GetTickCount();
|
|
|
m_ptest[ret - index]->RecvMsg();
|
|
|
//ulong ct2 = sys_GetTickCount();
|
|
|
//if (ct2 > ct1) REPORT("test(%d) msg ct: %dms", ret - index, ct2 - ct1);
|
|
|
}
|
|
|
|
|
|
static const char* _pszcmddesc =
|
|
|
"业务模块自定义消息格式.\n"
|
|
|
"\n发送消息格式：\n\n\n"
|
|
|
"M1 通知取料仓拍照，并返回拍照结果\n\n"
|
|
|
"M2 通知搬运模组拍照，并返回拍照结果\n\n"
|
|
|
"M3 通知OK仓拍照，并返回拍照结果\n\n"
|
|
|
"M4 通知NG仓拍照，并返回拍照结果\n\n"
|
|
|
"M5 通知NG取一拍一模式拍照，并返回拍照结果\n\n"
|
|
|
"M6 通知NG放一拍一模式拍照，并返回拍照结果\n\n"
|
|
|
"M7 通知治具取料模式拍照，并返回拍照结果\n\n"
|
|
|
"M8 通知治具放料模式拍照，并返回拍照结果\n\n"
|
|
|
"MT tindex [sn] 模拟治具发送侧相机处理请求\n\n"
|
|
|
"vacmreset 通知释放吸嘴产品数据\n\n"
|
|
|
"makeinput 模拟生成进料盘数据\n\n"
|
|
|
"posreset sindex 通知释放拍照数据 sindex料仓编号[1-5]\n\n"
|
|
|
"posget sindex 获取拍照取料位置数据写入变量 res=0标识获取成功,否则标识要拍照获取数据.取料信息写入(sn,x,y)\n\n"
|
|
|
"posset sindex index sn x y 将拍照数据暂存起来,sindex料仓编号[1-5] index数据编号[1-4] sn二维码 x,y基于相机的坐标值\n\n"
|
|
|
"posmap sindex 拍照3次(左上、右上、左下)后，此指令可计算矩阵，生成料盘位置数据.\n\n"
|
|
|
"clear tindex 清空治具统计参数 tindex治具编号[1-6]\n\n"
|
|
|
"home tindex 通知治具回原 tindex治具编号[1-6]\n\n"
|
|
|
"reset tindex 通知治具复位 tindex治具编号[1-6]\n\n"
|
|
|
"pause tindex flag 通知治具暂停 tindex治具编号[1-6] flag 1暂停 0暂停取消\n\n"
|
|
|
"grip tindex 1/0 通知治具控制夹爪 tindex治具编号[1-6] 1夹紧 0松开\n\n"
|
|
|
"status tindex a 设置治具状态更新到某个变量 tindex治具编号[1-6] a变量名\n\n"
|
|
|
"sim tindex bsim 打开/关闭模拟治具 tindex治具编号[1-6] bsim 1打开模拟 0关闭模拟\n\n"
|
|
|
"stockreset sindex 通知释放料盘产品数据 sindex料仓编号[1-5]\n\n"
|
|
|
"where 通知设置当前是给治具换料还是放料到料仓，设置到变量't'中，0标识放料到料仓，[1-6]标识给治具换料\n\n"
|
|
|
"vacmtake 通知设置需要取料的吸嘴编号为0时无效，设置到变量'v'中\n\n"
|
|
|
"testput 通知设置需要进入治具的吸嘴编号->'v'，治具编号->'t'，为0时无效\n\n"
|
|
|
"testake 通知设置需要从治具取料的吸嘴编号->'v'，治具编号->'t'，为0时无效\n\n"
|
|
|
"stockput 通知设置需要放回料仓的吸嘴编号->'v'，料仓编号[2-5]->'t'，为0时无效\n\n"
|
|
|
"create sn vindex 从进料仓到吸嘴，并创建产品资料 vindex吸嘴编号\n\n"
|
|
|
"vacm_to_test vindex tindex 变更产品位置，从吸嘴到测试治具并开始测试 vindex吸嘴编号 tindex治具编号\n\n"
|
|
|
"test_to_vacm tindex vindex 变更产品位置，从测试治具到吸嘴 tindex治具编号 vindex吸嘴编号\n\n"
|
|
|
"vacm_to_stock vindex sindex 变更产品位置，从吸嘴到料仓 vindex吸嘴编号 sindex料仓编号[2-5]\n\n"
|
|
|
"\n接收消息(\"msg\"格式)：\n\n\n"
|
|
|
"waitOk tindex 等待测试治具就绪，当状态就绪时，返回0，否则返回超时\n\n"
|
|
|
"WaitM1 接收进料仓拍照处理结果，消息返回格式：res,sn,x,y res=0标识成功\n\n"
|
|
|
"WaitM2 sindex sindex料仓编号[1-5] 等待搬运模组拍照处理结果，自动刷新产品标识到数组中,消息返回格式：res 0标识成功\n\n"
|
|
|
"WaitM3 接收OK仓拍照结果，消息返回格式：res,x,y res=0标识成功\n\n"
|
|
|
"WaitM4 接收NG仓拍照结果，消息返回格式：res,x,y res=0标识成功\n\n"
|
|
|
"WaitM5 接收NG取一拍一拍照结果，消息返回格式：res,x,y res=0标识成功\n\n"
|
|
|
"WaitM6 接收NG放一拍一拍照结果，消息返回格式：res,x,y res=0标识成功\n\n"
|
|
|
"WaitM7 接收治具取料拍照结果，消息返回格式：res,x,y res=0标识成功\n\n"
|
|
|
"WaitM8 接收治具放料拍照结果，消息返回格式：res,x,y res=0标识成功\n\n"
|
|
|
"uploadnoreset 给治具上料的顺序复位，从第一个治具开始上料\n\n"
|
|
|
;
|
|
|
|
|
|
int CManage::GetCommandDesc(char* pszcmddesc)
|
|
|
{
|
|
|
int len = (int)strlen(_pszcmddesc);
|
|
|
|
|
|
if (!pszcmddesc) return len;
|
|
|
|
|
|
comm_strcpy(pszcmddesc, _pszcmddesc);
|
|
|
return len;
|
|
|
}
|
|
|
|
|
|
int CManage::SendCustomCmd(const char* msg, char* res)
|
|
|
{
|
|
|
int tmp = 0;
|
|
|
char* pcmd = NULL;
|
|
|
char* ptmp = NULL;
|
|
|
char buff[MAX_BUF_LEN] = {0};
|
|
|
|
|
|
RETURN_CHK_NOPRT(msg && *msg, ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(strlen(msg) < MAX_BUF_LEN, ERR_INPUT_PARAM);
|
|
|
|
|
|
strcpy(buff, msg);
|
|
|
ptmp = sys_strtok(buff, " ", &pcmd);
|
|
|
|
|
|
if (!strcmp("test", ptmp))
|
|
|
{//测试接口
|
|
|
return Test(pcmd);
|
|
|
}
|
|
|
|
|
|
if (!strcmp("sim", ptmp))
|
|
|
{//清空吸嘴数据
|
|
|
ptmp = sys_strtok(NULL, " ", &pcmd);
|
|
|
if (ptmp) trim_char(ptmp);
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(ptmp), ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return SimTest(atoi(ptmp), atoi(pcmd));
|
|
|
}
|
|
|
|
|
|
if (!strcmp("M1", ptmp))
|
|
|
{//取料拍照
|
|
|
return M1();
|
|
|
}
|
|
|
|
|
|
if (!strcmp("M2", ptmp))
|
|
|
{//搬运拍照
|
|
|
return M2();
|
|
|
}
|
|
|
|
|
|
if (!strcmp("M3", ptmp))
|
|
|
{//OK拍照
|
|
|
return M3();
|
|
|
}
|
|
|
|
|
|
if (!strcmp("M4", ptmp))
|
|
|
{//NG拍照
|
|
|
return M4();
|
|
|
}
|
|
|
|
|
|
if (!strcmp("M5", ptmp))
|
|
|
{//NG取一拍一
|
|
|
return M5();
|
|
|
}
|
|
|
|
|
|
if (!strcmp("M6", ptmp))
|
|
|
{//NG放一拍一
|
|
|
return M6();
|
|
|
}
|
|
|
|
|
|
if (!strcmp("M7", ptmp))
|
|
|
{//治具取
|
|
|
return M7();
|
|
|
}
|
|
|
|
|
|
if (!strcmp("M8", ptmp))
|
|
|
{//治具放
|
|
|
return M8();
|
|
|
}
|
|
|
|
|
|
if (!strcmp("MT", ptmp))
|
|
|
{//治具侧相机
|
|
|
RETURN_CHK_NOPRT(pcmd, ERR_INPUT_PARAM);
|
|
|
trim_char(pcmd);
|
|
|
ptmp = sys_strtok(NULL, " ", &pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(ptmp), ERR_INPUT_PARAM);
|
|
|
return SendTestGR(atoi(ptmp), pcmd);
|
|
|
}
|
|
|
|
|
|
if (!strcmp("vacmreset", ptmp))
|
|
|
{//清空吸嘴数据
|
|
|
return VacmResetB();
|
|
|
}
|
|
|
|
|
|
if (!strcmp("makeinput", ptmp))
|
|
|
{//模拟进料盘数据
|
|
|
MakeInput();
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
if (!strcmp("stockreset", ptmp))
|
|
|
{//清空料盘数据
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return StockResetB(atoi(pcmd));
|
|
|
}
|
|
|
|
|
|
if (!strcmp("posreset", ptmp))
|
|
|
{//清空拍照数据
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return ReleasePosxy(atoi(pcmd));
|
|
|
}
|
|
|
|
|
|
if (!strcmp("posget", ptmp))
|
|
|
{//获取拍照数据
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return SetPosxy(atoi(pcmd));;
|
|
|
}
|
|
|
|
|
|
if (!strcmp("posmap", ptmp))
|
|
|
{//通过3点数据计算矩阵
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return PosMap(atoi(pcmd));;
|
|
|
}
|
|
|
|
|
|
if (!strcmp("posset", ptmp))
|
|
|
{//保存拍照数据
|
|
|
ptmp = sys_strtok(NULL, " ", &pcmd);
|
|
|
if (ptmp) trim_char(ptmp);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(ptmp), ERR_INPUT_PARAM);
|
|
|
return SetPosxy(atoi(ptmp), pcmd);
|
|
|
}
|
|
|
|
|
|
if (!strcmp("where", ptmp))
|
|
|
{//去哪？
|
|
|
return WhereToGoB();
|
|
|
}
|
|
|
|
|
|
if (!strcmp("vacmtake", ptmp))
|
|
|
{//设置取料吸嘴编号
|
|
|
return VacmTakeB();
|
|
|
}
|
|
|
|
|
|
if (!strcmp("testput", ptmp))
|
|
|
{//设置放治具测试编号
|
|
|
return TestPutB();
|
|
|
}
|
|
|
|
|
|
if (!strcmp("testake", ptmp))
|
|
|
{//设置取治具测试编号
|
|
|
return TestTakeB();
|
|
|
}
|
|
|
|
|
|
if (!strcmp("stockput", ptmp))
|
|
|
{//设置放料仓
|
|
|
return StockPutB();
|
|
|
}
|
|
|
|
|
|
if (!stricmp("home", ptmp))
|
|
|
{//控制回原
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return TestHome(atoi(pcmd));
|
|
|
}
|
|
|
|
|
|
if (!stricmp("reset", ptmp))
|
|
|
{//控制复位
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return TestReset(atoi(pcmd));
|
|
|
}
|
|
|
|
|
|
if (!stricmp("clear", ptmp))
|
|
|
{//控制重置统计
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return TestClear(atoi(pcmd));
|
|
|
}
|
|
|
|
|
|
if (!stricmp("grip", ptmp))
|
|
|
{//控制夹爪
|
|
|
ptmp = sys_strtok(NULL, " ", &pcmd);
|
|
|
if (ptmp) trim_char(ptmp);
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(ptmp), ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return GripEnable(atoi(ptmp), atoi(pcmd));
|
|
|
}
|
|
|
|
|
|
if (!stricmp("pause", ptmp))
|
|
|
{//控制治具暂停
|
|
|
ptmp = sys_strtok(NULL, " ", &pcmd);
|
|
|
if (ptmp) trim_char(ptmp);
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(ptmp), ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return TestPause(atoi(ptmp), atoi(pcmd));
|
|
|
}
|
|
|
|
|
|
if (!strcmp("create", ptmp))
|
|
|
{//进料仓到吸嘴
|
|
|
ptmp = sys_strtok(NULL, " ", &pcmd);
|
|
|
if (ptmp) trim_char(ptmp);
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return CreateProductB(ptmp, atoi(pcmd));
|
|
|
}
|
|
|
|
|
|
if (!strcmp("vacm_to_test", ptmp))
|
|
|
{//吸嘴到测试治具
|
|
|
WriteLog("manager.txt", "%s", "vacm_to_test-->start");
|
|
|
ptmp = sys_strtok(NULL, " ", &pcmd);
|
|
|
if (ptmp) trim_char(ptmp);
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(ptmp), ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return MovetoTest(atoi(ptmp), atoi(pcmd));
|
|
|
}
|
|
|
|
|
|
if (!strcmp("test_to_vacm", ptmp))
|
|
|
{//测试治具到吸嘴
|
|
|
ptmp = sys_strtok(NULL, " ", &pcmd);
|
|
|
if (ptmp) trim_char(ptmp);
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(ptmp), ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return MovetoVacmB(atoi(ptmp), atoi(pcmd));
|
|
|
}
|
|
|
|
|
|
if (!strcmp("vacm_to_stock", ptmp))
|
|
|
{//吸嘴到料仓
|
|
|
|
|
|
ptmp = sys_strtok(NULL, " ", &pcmd);
|
|
|
if (ptmp) trim_char(ptmp);
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(ptmp), ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return MovetoStockB(atoi(ptmp), atoi(pcmd));
|
|
|
}
|
|
|
|
|
|
if (!strcmp("status", ptmp))
|
|
|
{//设置治具状态到变量
|
|
|
ptmp = sys_strtok(NULL, " ", &pcmd);
|
|
|
if (ptmp) trim_char(ptmp);
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(ptmp) && pcmd, ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(get_var_id(pcmd) > 0, ERR_INPUT_PARAM);
|
|
|
tmp = atoi(ptmp);
|
|
|
RETURN_CHK_NOPRT(tmp > 0 && tmp <= TESTCNT, ERR_INPUT_PARAM);
|
|
|
return m_ptest[tmp-1]->SetVarStatus(pcmd);
|
|
|
}
|
|
|
|
|
|
if (!strcmp("test_debug", ptmp))
|
|
|
{//吸嘴到测试治具
|
|
|
ptmp = sys_strtok(NULL, " ", &pcmd);
|
|
|
if (ptmp) trim_char(ptmp);
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(ptmp) && pcmd, ERR_INPUT_PARAM);
|
|
|
return TestDebug(atoi(ptmp), pcmd);
|
|
|
}
|
|
|
|
|
|
if (!strcmp("uploadnoreset", ptmp))
|
|
|
{
|
|
|
m_prePut = 0;
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
return ERR_INPUT_PARAM;
|
|
|
}
|
|
|
|
|
|
int CManage::RecvCustomCmd(const char* msg, char* res, int timeout/* = 0*/)
|
|
|
{
|
|
|
char* pcmd = NULL;
|
|
|
char* ptmp = NULL;
|
|
|
char buff[MAX_BUF_LEN] = {0};
|
|
|
|
|
|
RETURN_CHK_NOPRT(res && msg && *msg, ERR_INPUT_PARAM);
|
|
|
RETURN_CHK_NOPRT(strlen(msg) < MAX_BUF_LEN, ERR_INPUT_PARAM);
|
|
|
|
|
|
if (!strcmp("WaitM1", msg))
|
|
|
{//等待拍照结果
|
|
|
return m_pVision[EVInput]->WaitResult(res, timeout);
|
|
|
}
|
|
|
|
|
|
if (!strcmp("WaitM3", msg))
|
|
|
{//等待拍照结果
|
|
|
return m_pVision[EVOkTray]->WaitResult(res, timeout);
|
|
|
}
|
|
|
|
|
|
if (!strcmp("WaitM4", msg))
|
|
|
{//等待拍照结果
|
|
|
return m_pVision[EVNGTray]->WaitResult(res, timeout);
|
|
|
}
|
|
|
|
|
|
if (!strcmp("WaitM5", msg))
|
|
|
{//NG取一拍一拍照结果
|
|
|
return m_pVision[EVNGTakeOne]->WaitResult(res, timeout);
|
|
|
}
|
|
|
|
|
|
if (!strcmp("WaitM6", msg))
|
|
|
{//NG放一拍一拍照结果
|
|
|
return m_pVision[EVNGPutOne]->WaitResult(res, timeout);
|
|
|
}
|
|
|
|
|
|
if (!strcmp("WaitM7", msg))
|
|
|
{//治具取料拍照结果
|
|
|
return m_pVision[EVTestTake]->WaitResult(res, timeout);
|
|
|
}
|
|
|
|
|
|
if (!strcmp("WaitM8", msg))
|
|
|
{//治具放料拍照结果
|
|
|
return m_pVision[EVTestPut]->WaitResult(res, timeout);
|
|
|
}
|
|
|
|
|
|
strcpy(buff, msg);
|
|
|
ptmp = sys_strtok(buff, " ", &pcmd);
|
|
|
|
|
|
//waitOk tindex 等待测试治具就绪，当状态就绪时，返回0，否则返回超时
|
|
|
if (!strcmp("waitOk", ptmp))
|
|
|
{//等待测试治具ok
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return WaitTestIdle(atoi(pcmd), timeout);
|
|
|
}
|
|
|
|
|
|
if (!strcmp("WaitM2", ptmp))
|
|
|
{//等待拍照结果
|
|
|
if (pcmd) trim_char(pcmd);
|
|
|
RETURN_CHK_NOPRT(EMSTR_INT == get_str_type(pcmd), ERR_INPUT_PARAM);
|
|
|
return WaitM2Result(atoi(pcmd), res, timeout);
|
|
|
}
|
|
|
|
|
|
return ERR_INPUT_PARAM;
|
|
|
}
|
|
|
|
|
|
void CManage::Report(const char *pszFormat, ...)
|
|
|
{
|
|
|
va_list args;
|
|
|
int nWrite = 0;
|
|
|
char* pmsg = NULL;
|
|
|
char buff[1024] = { 0 };
|
|
|
|
|
|
ZERO_CHK(pszFormat);
|
|
|
|
|
|
va_start(args, pszFormat);
|
|
|
nWrite = vsprintf(buff, pszFormat, args);
|
|
|
va_end(args);
|
|
|
|
|
|
ZERO_CHK(nWrite > 0 && nWrite < MAX_BUF_LEN);
|
|
|
|
|
|
pmsg = new char[nWrite + 1];
|
|
|
comm_strcpy(pmsg, buff);
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
m_lsgMsg.push_back(pmsg);
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
}
|
|
|
|
|
|
int WINAPI ThreadPostWarn(void* param)
|
|
|
{
|
|
|
char* pmsg = (char*)param;
|
|
|
send_messages(MSG_WARN, pmsg);
|
|
|
delete pmsg;
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
void CManage::PostWarn(const char *pszFormat, ...)
|
|
|
{
|
|
|
va_list args;
|
|
|
int nWrite = 0;
|
|
|
char* pmsg = NULL;
|
|
|
char buff[1024] = { 0 };
|
|
|
|
|
|
ZERO_CHK(pszFormat);
|
|
|
|
|
|
va_start(args, pszFormat);
|
|
|
nWrite = vsprintf(buff, pszFormat, args);
|
|
|
va_end(args);
|
|
|
|
|
|
ZERO_CHK(nWrite > 0 && nWrite < MAX_BUF_LEN);
|
|
|
|
|
|
pmsg = new char[nWrite + 1];
|
|
|
comm_strcpy(pmsg, buff);
|
|
|
pool_thread(ThreadPostWarn, pmsg);
|
|
|
}
|
|
|
|
|
|
void CManage::WriteLog(const char* filename, const char* pszFormat, ...)
|
|
|
{
|
|
|
if (this->testLog())
|
|
|
{
|
|
|
sys_EnterCriticalSection(m_hSection);
|
|
|
time_t now = time(0);
|
|
|
tm *ltm = localtime(&now);
|
|
|
int year = ltm->tm_year + 1900;
|
|
|
int month = ltm->tm_mon + 1;
|
|
|
int day = ltm->tm_mday;
|
|
|
int hour = ltm->tm_hour;
|
|
|
int min = ltm->tm_min;
|
|
|
int sec = ltm->tm_sec;
|
|
|
char sztime[64] = { 0 };
|
|
|
sprintf(sztime, "%d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, min, sec);
|
|
|
char date[64] = { 0 };
|
|
|
char filedir[256] = { 0 };
|
|
|
char filepath[256] = { 0 };
|
|
|
char pszcontent[2048] = { 0 };
|
|
|
sprintf(date, "%d%02d%02d", year, month, day);
|
|
|
sprintf(filedir, "d:\\log\\updown\\%s", date);
|
|
|
if (is_file_exist(filedir) == 0)
|
|
|
{
|
|
|
create_path(filedir);
|
|
|
}
|
|
|
sprintf(filepath, "%s\\%s", filedir, filename);
|
|
|
std::ofstream ofs;
|
|
|
ofs.open(filepath, std::ios::app);
|
|
|
va_list vl;
|
|
|
va_start(vl, pszFormat);
|
|
|
vsnprintf(pszcontent, 2048, pszFormat, vl);
|
|
|
va_end(vl);
|
|
|
ofs << sztime << " >>> " << pszcontent << std::endl;
|
|
|
ofs.close();
|
|
|
sys_LeaveCriticalSection(m_hSection);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
int CManage::get_cam_status()
|
|
|
{
|
|
|
int status = 0;
|
|
|
for (int i = 0; i < EVSize; i++)
|
|
|
{
|
|
|
status |= (m_pVision[i]->IsConn() << i);
|
|
|
}
|
|
|
status |= (m_pVisionTest->IsConn() << EVSize);
|
|
|
return status;
|
|
|
}
|
|
|
|
|
|
int CManage::get_test_status()
|
|
|
{
|
|
|
int status = 0;
|
|
|
for (int i = 0; i < TESTCNT; i++)
|
|
|
{
|
|
|
status |= (m_ptest[i]->IsConn() << i);
|
|
|
}
|
|
|
return status;
|
|
|
}
|
|
|
|
|
|
int CManage::registercallbackmsg(CommunicationMsgCallback communicationmsgCallback)
|
|
|
{
|
|
|
if (communicationmsgCallback != NULL)
|
|
|
{
|
|
|
m_communicationmsgCallback = communicationmsgCallback;
|
|
|
return 0;
|
|
|
}
|
|
|
return -1;
|
|
|
} |