1209 lines
34 KiB
C++
1209 lines
34 KiB
C++
#include "Scanner.h"
|
||
#include "../global.h"
|
||
#include "../SystemInfo.h"
|
||
#include "../Logger.h"
|
||
|
||
Scanner::Scanner(ScannerControlCfg* cfg)
|
||
:m_ScannerControlCfg(cfg)
|
||
, m_DebugThread(INVALID_HANDLE_VALUE)
|
||
, m_DebugFlag(false)
|
||
, m_Thread(INVALID_HANDLE_VALUE)
|
||
, m_HeatingScannerThread(INVALID_HANDLE_VALUE)
|
||
, m_HeatingScannerRunFlag(false)
|
||
, m_InfoThread(INVALID_HANDLE_VALUE)
|
||
, m_IsLeftScan(false)
|
||
, m_IsOrderSeqV2(false)
|
||
{
|
||
m_TimePowerCompensateCfg = &cfg->m_ScanCfgWrapper.m_TimePowerCompensateCfg;
|
||
m_PowerCompensateCfg = &cfg->m_ScanCfgWrapper.m_PowerCompensateCfg;
|
||
m_CorrectParamCfg = &cfg->m_ScanCfgWrapper.m_CorrectParamCfg;
|
||
m_SkyWritingCfg = &cfg->m_ScanCfgWrapper.m_SkyWritingCfg;
|
||
m_ScanParamCfg = &cfg->m_ScanCfgWrapper.m_ScanParamCfg;
|
||
m_ScanTestCfg = &cfg->m_ScanCfgWrapper.m_ScanTestCfg;
|
||
m_AlarmCfgWrapper = ConfigManager::GetInstance()->GetAlarmCfg();
|
||
m_MachineCfg = ConfigManager::GetInstance()->GetMachineCfg();
|
||
m_RunCfg = ConfigManager::GetInstance()->GetRunCfg();
|
||
m_ExtCfg = ConfigManager::GetInstance()->GetExtCfg();
|
||
m_ScannerIO = ConfigManager::GetInstance()->GetIoCfgWrapper()->m_Laser;
|
||
time(&m_ScanStateUpdateTime);
|
||
InitializeCriticalSection(&m_ScannerInfoCS);
|
||
|
||
m_XOffsetAssist = 0.0f;
|
||
m_YOffsetAssist = 0.0f;
|
||
|
||
m_ScanParamCfgMap["BlockSupport"] = &cfg->m_ScanCfgWrapper.m_SupportParams;
|
||
m_ScanParamCfgMap["DownBorder"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
|
||
m_ScanParamCfgMap["DownBorderAd"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
|
||
m_ScanParamCfgMap["DownFBorder"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
|
||
m_ScanParamCfgMap["DownHatching"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
|
||
m_ScanParamCfgMap["DownHatching2"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
|
||
m_ScanParamCfgMap["DownHatching3"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
|
||
m_ScanParamCfgMap["DownHatching4"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
|
||
m_ScanParamCfgMap["DownHatching5"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
|
||
m_ScanParamCfgMap["DownThin"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
|
||
m_ScanParamCfgMap["Dummy"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
|
||
m_ScanParamCfgMap["InBorder"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
|
||
m_ScanParamCfgMap["InBorderAd"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
|
||
m_ScanParamCfgMap["InFBorder"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
|
||
m_ScanParamCfgMap["InHatching"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
|
||
m_ScanParamCfgMap["InThin"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
|
||
m_ScanParamCfgMap["Other"] = &cfg->m_ScanCfgWrapper.m_ScanParamCfg;
|
||
m_ScanParamCfgMap["SupportBorder"] = &cfg->m_ScanCfgWrapper.m_SupportParams;
|
||
m_ScanParamCfgMap["SupportBorderAd"] = &cfg->m_ScanCfgWrapper.m_SupportParams;
|
||
m_ScanParamCfgMap["SupportHatching"] = &cfg->m_ScanCfgWrapper.m_SupportParams;
|
||
m_ScanParamCfgMap["UpBorder"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
|
||
m_ScanParamCfgMap["UpBorderAd"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
|
||
m_ScanParamCfgMap["UpFBorder"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
|
||
m_ScanParamCfgMap["UpHatching"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
|
||
m_ScanParamCfgMap["UpHatching2"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
|
||
m_ScanParamCfgMap["UpHatching3"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
|
||
m_ScanParamCfgMap["UpHatching4"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
|
||
m_ScanParamCfgMap["UpHatching5"] = &cfg->m_ScanCfgWrapper.m_HatchingParams;
|
||
m_ScanParamCfgMap["UpThin"] = &cfg->m_ScanCfgWrapper.m_BorderParams;
|
||
}
|
||
|
||
Scanner::~Scanner()
|
||
{
|
||
m_ScanData.clear();
|
||
StopGetScanInfo();
|
||
DeleteCriticalSection(&m_ScannerInfoCS);
|
||
}
|
||
|
||
void Scanner::AddDataBlock(BPBinary::BinDataBlock* bdb, MetaData::Part* part, MetaData::ParameterSet* ps,int _order,int _delaytime)
|
||
{
|
||
DataBlockInfo* dbi = new DataBlockInfo(bdb, part, ps, _order,_delaytime);
|
||
if (m_MachineCfg->IsDataSeqStragegy())
|
||
{
|
||
if (_order == 0)
|
||
{
|
||
if (ps->set_type.find("Support") != ps->set_type.npos)
|
||
{
|
||
m_SupportSeq.push_back(dbi);
|
||
}
|
||
else {
|
||
m_ZeroSeq.push(dbi);
|
||
}
|
||
|
||
}
|
||
else {
|
||
if (m_OrderMap.find(_order) == m_OrderMap.end())
|
||
{
|
||
m_OrderMap[_order] = new OrderMap();
|
||
}
|
||
m_OrderMap[_order]->m_DBS.push(dbi);
|
||
// m_OrderSeq.insert(_order);
|
||
|
||
m_ScanData.push_back(dbi);
|
||
m_OrderDataCountMap[_order]++;
|
||
}
|
||
}
|
||
else {
|
||
m_ScanData.push_back(dbi);
|
||
}
|
||
}
|
||
|
||
|
||
bool Scanner::IsDebugEnable()
|
||
{
|
||
return (m_DebugThread == INVALID_HANDLE_VALUE);
|
||
}
|
||
|
||
void Scanner::StartDebugTest()
|
||
{
|
||
StopDebugTest();
|
||
m_DebugFlag = true;
|
||
m_DebugThread = AtlCreateThread(DebugProc, this);
|
||
}
|
||
|
||
void Scanner::StopDebugTest()
|
||
{
|
||
m_DebugFlag = false;
|
||
if (m_DebugThread != INVALID_HANDLE_VALUE) {
|
||
if (m_ScannerControlCfg->m_ScanCfgWrapper.m_ScanTestCfg.m_is_cycle) {
|
||
m_ScannerControlCfg->m_ScanCfgWrapper.m_ScanTestCfg.m_is_cycle = false;
|
||
}
|
||
Sleep(200);
|
||
StopWork();
|
||
if (WaitForSingleObject(m_DebugThread, 1000) == WAIT_TIMEOUT) {
|
||
TerminateThread(m_DebugThread, 0);
|
||
}
|
||
CloseHandle(m_DebugThread);
|
||
m_DebugThread = INVALID_HANDLE_VALUE;
|
||
}
|
||
}
|
||
|
||
DWORD WINAPI Scanner::DebugProc(Scanner* _this)
|
||
{
|
||
if (_this) {
|
||
_this->ScanDebug();
|
||
if (_this->m_DebugThread != INVALID_HANDLE_VALUE) {
|
||
CloseHandle(_this->m_DebugThread);
|
||
_this->m_DebugThread = INVALID_HANDLE_VALUE;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
bool Scanner::BeginWork()
|
||
{
|
||
if (m_ScanData.empty() && m_ZeroSeq.empty() && m_SupportSeq.empty())
|
||
return false;
|
||
|
||
|
||
if (m_Thread != INVALID_HANDLE_VALUE) {
|
||
StopWork();
|
||
TerminateThread(m_Thread, 1);
|
||
CloseHandle(m_Thread);
|
||
m_Thread = INVALID_HANDLE_VALUE;
|
||
}
|
||
m_Thread = AtlCreateThread(ScanProc, this);
|
||
return true;
|
||
}
|
||
|
||
DWORD WINAPI Scanner::ScanProc(Scanner* _this)
|
||
{
|
||
if (_this) {
|
||
if (_this->m_MachineCfg->IsDataSeqStragegy())
|
||
{
|
||
EnterCriticalSection(&m_SeqCS);
|
||
m_SeqDataUnFinishBit[_this->m_ScannerControlCfg->m_SeqNo] = true;
|
||
m_SupportSeqDataUnFinishBit[_this->m_ScannerControlCfg->m_SeqNo] = true;
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
_this->ScanSeqV2();
|
||
EnterCriticalSection(&m_SeqCS);
|
||
m_SeqDataUnFinishBit[_this->m_ScannerControlCfg->m_SeqNo] = false;
|
||
m_SupportSeqDataUnFinishBit[_this->m_ScannerControlCfg->m_SeqNo] = false;
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
}
|
||
else {
|
||
_this->Scan();
|
||
}
|
||
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void Scanner::WaitFinish()
|
||
{
|
||
if (m_Thread == INVALID_HANDLE_VALUE)return;
|
||
if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(u8"<EFBFBD><EFBFBD>ʼ<EFBFBD>ȴ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>%d<><64><EFBFBD><EFBFBD>ɨ<EFBFBD><C9A8>", m_ScannerControlCfg->m_SeqNo);
|
||
WaitForSingleObject(m_Thread, INFINITE);
|
||
Clean();
|
||
CloseHandle(m_Thread);
|
||
m_Thread = INVALID_HANDLE_VALUE;
|
||
if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(u8"<EFBFBD><EFBFBD><EFBFBD><EFBFBD>%d<><64><EFBFBD><EFBFBD>ɨ<EFBFBD><C9A8>", m_ScannerControlCfg->m_SeqNo);
|
||
}
|
||
|
||
void Scanner::Clean()
|
||
{
|
||
for (unsigned int i = 0; i < m_SupportSeq.size(); i++)
|
||
{
|
||
delete m_SupportSeq[i];
|
||
m_SupportSeq[i] = NULL;
|
||
}
|
||
m_SupportSeq.clear();
|
||
for (unsigned int i = 0; i < m_ScanData.size(); i++)
|
||
{
|
||
delete m_ScanData[i];
|
||
m_ScanData[i] = NULL;
|
||
}
|
||
m_ScanData.clear();
|
||
while (!m_ZeroSeq.empty()) {
|
||
DataBlockInfo* temp = m_ZeroSeq.front();
|
||
delete temp;
|
||
temp = NULL;
|
||
m_ZeroSeq.pop();
|
||
}
|
||
for (map<int, OrderMap*>::iterator orderIt = m_OrderMap.begin(); orderIt != m_OrderMap.end(); orderIt++) {
|
||
OrderMap* orderMap = orderIt->second;
|
||
while (!orderMap->m_DBS.empty()) {
|
||
orderMap->m_DBS.pop();
|
||
}
|
||
delete orderMap;
|
||
orderMap = NULL;
|
||
}
|
||
m_OrderMap.clear();
|
||
m_OrderDataCountMap.clear();
|
||
|
||
EnterCriticalSection(&m_SeqCS);
|
||
m_SeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo] = false;
|
||
m_SupportSeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo] = false;
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
}
|
||
|
||
void Scanner::Scan(void)
|
||
{
|
||
unsigned int memorySize = GetMemorySize();
|
||
bool nodebug = !g_isDebug;
|
||
//SetAutoUpdateScanInfo(false);
|
||
//Sleep(100);
|
||
uint64_t tnow = GetTickCount64();
|
||
/*bool isPowerChange = false;
|
||
float powerChangeValue = 0.0f;
|
||
if (m_RunCfg->m_TimePowerCompensateEnable) {
|
||
unsigned int spendtime = tnow - m_JobStartTime;
|
||
|
||
EnterCriticalSection(&m_TimePowerCompensateCfg->m_CS);
|
||
bool isFind = false;
|
||
for (size_t tpIndex = 0; tpIndex < m_TimePowerCompensateCfg->m_TimePowerCompensates.size(); tpIndex++) {
|
||
TimePowerCompensate* tpc = m_TimePowerCompensateCfg->m_TimePowerCompensates[tpIndex];
|
||
unsigned int startMil = tpc->m_StartMinute * 60 * 1000;
|
||
unsigned int endMil = tpc->m_EndMinute * 60 * 1000;
|
||
if ((spendtime > startMil) && (spendtime < endMil)) {
|
||
isPowerChange = true;
|
||
isFind = true;
|
||
powerChangeValue = tpc->m_Compensate;
|
||
break;
|
||
}
|
||
}
|
||
if (!isFind) {
|
||
isPowerChange = false;
|
||
}
|
||
LeaveCriticalSection(&m_TimePowerCompensateCfg->m_CS);
|
||
}*/
|
||
|
||
//DWORD tUpdateScanInfoFlag = GetTickCount64();
|
||
|
||
for (unsigned int i = 0; i < m_ScanData.size(); i++)
|
||
{
|
||
|
||
/*DWORD ttemp = GetTickCount64();
|
||
if (ttemp - tUpdateScanInfoFlag > 10000) {
|
||
UpdateScannerInfo();
|
||
tUpdateScanInfoFlag = ttemp;
|
||
}*/
|
||
|
||
MetaData::Part* part = m_ScanData[i]->part;
|
||
bool ischange = false;
|
||
if (m_RunCfg->m_OffsetRotateEnable) {
|
||
if (part->partPosBean.m_XOffset != 0.0f || part->partPosBean.m_YOffset != 0.0f || part->partPosBean.m_RotateAngle != 0.0f) {
|
||
ischange = true;
|
||
}
|
||
}
|
||
|
||
BPBinary::BinDataBlock* pdb = m_ScanData[i]->bdb;
|
||
MetaData::ParameterSet* paramSet = m_ScanData[i]->ps;
|
||
double laserSpeed = paramSet->laser_speed;
|
||
double laserPower = paramSet->laser_set->laser_real_power;
|
||
double spotDiameter = paramSet->laser_set->laser_diameter;
|
||
|
||
float ds = 0.0f;
|
||
bool isSkyWritingEnable = true;
|
||
double dtmep = spotDiameter - (unsigned int)(spotDiameter);
|
||
ds = (float)(dtmep * m_CorrectParamCfg->m_DefocusRatio);
|
||
if (spotDiameter > 100.0) {
|
||
isSkyWritingEnable = false;
|
||
}
|
||
|
||
ScanParamCfg* sp = m_ScannerControlCfg->GetScanParamCfg(paramSet->set_type);
|
||
LoadList(1, nodebug);
|
||
UpdateScanParamByCfg(sp);
|
||
SetSkyWritingEnable(isSkyWritingEnable, true);
|
||
SetScanSpeed(laserSpeed);
|
||
|
||
g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo - 1]->laserSpeed = laserSpeed;
|
||
SetPower(laserPower);
|
||
g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo - 1]->laserPower = paramSet->laser_set->laser_power;
|
||
|
||
if (m_CorrectParamCfg->m_IsDynamicFocus) {
|
||
SetDefocus(ds);
|
||
g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo - 1]->laserDefocus = ds;
|
||
}
|
||
EndList();
|
||
ListExecute(1, nodebug);
|
||
unsigned int currentList = 1;
|
||
unsigned int index = 0;
|
||
bool isfirst = true;
|
||
bool islistStart = true;
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
if (pdb->type == BIN_VECTOR) {
|
||
for (size_t j = 0; j < pdb->point_indexs.size(); ++j) {
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
BPBinary::VectorPoint* pvp = (BPBinary::VectorPoint*)pdb->point_indexs[j];
|
||
double real_x1 = pvp->x1;
|
||
double real_y1 = pvp->y1;
|
||
double real_x2 = pvp->x2;
|
||
double real_y2 = pvp->y2;
|
||
if (ischange) {
|
||
double mov_x1 = part->partPosBean.m_XOffset + pvp->x1;
|
||
double mov_y1 = part->partPosBean.m_YOffset + pvp->y1;
|
||
double mov_x2 = part->partPosBean.m_XOffset + pvp->x2;
|
||
double mov_y2 = part->partPosBean.m_YOffset + pvp->y2;
|
||
|
||
real_x1 = (mov_x1 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
|
||
real_y1 = (mov_x1 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
|
||
real_x2 = (mov_x2 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y2 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
|
||
real_y2 = (mov_x2 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y2 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
|
||
}
|
||
|
||
|
||
if (islistStart) {
|
||
LoadList(currentList, nodebug);
|
||
islistStart = false;
|
||
}
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
index += 2;
|
||
AddVector(real_x1, real_y1, real_x2, real_y2);
|
||
if (index == memorySize - 2) {
|
||
ListNop();
|
||
index++;
|
||
}
|
||
if (index >= (memorySize - 1)) {
|
||
EndList();
|
||
islistStart = true;
|
||
if (isfirst) {
|
||
ListExecute(currentList, false);
|
||
isfirst = false;
|
||
}
|
||
else {
|
||
AutoChangeList();
|
||
}
|
||
currentList = (currentList == 1 ? 2 : 1);
|
||
index = 0;
|
||
}
|
||
}
|
||
}
|
||
else if (pdb->type == BIN_CHAIN) {
|
||
for (unsigned int j = 0; j < pdb->point_indexs.size(); ++j) {
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
BPBinary::ChainPoint* point = (BPBinary::ChainPoint*)pdb->point_indexs[j];
|
||
for (unsigned int k = 0; k < point->points.size(); ++k) {
|
||
double real_x = point->points[k]->x;
|
||
double real_y = point->points[k]->y;
|
||
if (ischange) {
|
||
double mov_x1 = part->partPosBean.m_XOffset + point->points[k]->x;
|
||
double mov_y1 = part->partPosBean.m_YOffset + point->points[k]->y;
|
||
real_x = (mov_x1 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
|
||
real_y = (mov_x1 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
|
||
}
|
||
|
||
if (islistStart) {
|
||
LoadList(currentList, nodebug);
|
||
islistStart = false;
|
||
}
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
index++;
|
||
if (k == 0) {
|
||
JumpAbs(real_x, real_y);
|
||
}
|
||
else {
|
||
MarkAbs(real_x, real_y);
|
||
}
|
||
if (index >= (memorySize - 1)) {
|
||
EndList();
|
||
islistStart = true;
|
||
if (isfirst) {
|
||
ListExecute(currentList, false);
|
||
isfirst = false;
|
||
}
|
||
else {
|
||
AutoChangeList();
|
||
}
|
||
currentList = (currentList == 1 ? 2 : 1);
|
||
index = 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (!islistStart) {
|
||
EndList();
|
||
if (isfirst) {
|
||
ListExecute(1, false);
|
||
}
|
||
else {
|
||
AutoChangeList();
|
||
}
|
||
}
|
||
if (nodebug)
|
||
{
|
||
WaitListFree();
|
||
}
|
||
|
||
|
||
if (BaseCtrl::IsStop())
|
||
break;
|
||
|
||
Sleep(100);
|
||
}
|
||
//UpdateScannerInfo();
|
||
//SetAutoUpdateScanInfo(true);
|
||
}
|
||
|
||
void Scanner::ScanSeqV2() {
|
||
unsigned int memorySize = GetMemorySize();
|
||
bool nodebug = !g_isDebug;
|
||
uint64_t tnow = GetTickCount64();
|
||
|
||
bool isSupportFinish = false;
|
||
for (size_t supIndex = 0; supIndex < m_SupportSeq.size(); supIndex++) {
|
||
if (BaseCtrl::IsStop())break;
|
||
ScanDataBlock(m_SupportSeq[supIndex]);
|
||
}
|
||
if (BaseCtrl::IsStop())return;
|
||
|
||
EnterCriticalSection(&m_SeqCS);
|
||
m_SupportSeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo] = false;
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
|
||
while (true && (!BaseCtrl::IsStop())) {
|
||
EnterCriticalSection(&m_SeqCS);
|
||
int sb = m_SupportSeqDataUnFinishBit.to_ulong();
|
||
if (sb == 0) {
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
break;
|
||
}
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
Sleep(100);
|
||
}
|
||
if (BaseCtrl::IsStop())return;
|
||
while (true && !BaseCtrl::IsStop()) {
|
||
bool isAllFinished = true;
|
||
DataBlockInfo* Printdbi = NULL;
|
||
if (m_IsLeftScan && m_PairScan)
|
||
{
|
||
isAllFinished = false;
|
||
DataBlockInfo* dbi = NULL;
|
||
for (map<int, OrderMap*>::iterator orderIt = m_OrderMap.begin(); orderIt != m_OrderMap.end();) {
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
OrderMap* orderMap = orderIt->second;
|
||
if (orderMap->m_DBS.empty()) {
|
||
delete orderMap;
|
||
orderMap = NULL;
|
||
m_OrderMap.erase(orderIt++);
|
||
}
|
||
else {
|
||
int order = orderIt->first;
|
||
if ((order > 0) && (order <= m_SeqCount))
|
||
{
|
||
EnterCriticalSection(&m_SeqCS);
|
||
map<int, int>* PairOrderDataCountMap = m_PairScan->GetOrderDataCountMap();
|
||
int hsCode = m_HorizontalSeq2[order];
|
||
bitset<64> btemp(hsCode);
|
||
bool canPrint = true;
|
||
for (int i = 1; i < m_SeqCount + 1; i++) {
|
||
if (btemp[i]) {
|
||
if (PairOrderDataCountMap->find(i) != PairOrderDataCountMap->end())
|
||
{
|
||
if ((*PairOrderDataCountMap)[i] > 0) {
|
||
canPrint = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
|
||
if (!canPrint) {
|
||
Sleep(3);
|
||
continue;
|
||
}
|
||
|
||
EnterCriticalSection(&m_SeqCS);
|
||
uint64_t sb = m_ScaningBit.to_ullong();
|
||
uint64_t limitCode = m_LimitMap2[order];
|
||
uint64_t lrel = sb&limitCode;
|
||
if (lrel > 0) {
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
continue;
|
||
}
|
||
|
||
m_ScaningBit[order] = true;
|
||
DataBlockInfo* db = orderMap->m_DBS.front();
|
||
dbi = db;
|
||
orderMap->m_DBS.pop();
|
||
isAllFinished = false;
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
}
|
||
}
|
||
if (dbi) {
|
||
Printdbi = dbi;
|
||
if (g_isDebug) {
|
||
stringstream ss;
|
||
ss << "(" << Printdbi->order << ")" << "\n";
|
||
for (int sindex = 1; sindex < 32; sindex++) {
|
||
if (m_ScaningBit[sindex])
|
||
{
|
||
ss << sindex << " ";
|
||
}
|
||
}
|
||
ss << "\n";
|
||
OutputDebugString(ss.str().c_str());
|
||
}
|
||
break;
|
||
}
|
||
Sleep(3);
|
||
}
|
||
|
||
if (!Printdbi)Sleep(3);
|
||
if (m_OrderMap.empty()) {
|
||
isAllFinished = true;
|
||
}
|
||
}
|
||
else {
|
||
DataBlockInfo* dbi = NULL;
|
||
for (map<int, OrderMap*>::iterator orderIt = m_OrderMap.begin(); orderIt != m_OrderMap.end();) {
|
||
OrderMap* orderMap = orderIt->second;
|
||
if (orderMap->m_DBS.empty()) {
|
||
delete orderMap;
|
||
orderMap = NULL;
|
||
m_OrderMap.erase(orderIt++);
|
||
}
|
||
else {
|
||
DataBlockInfo* db = orderMap->m_DBS.front();
|
||
dbi = db;
|
||
orderMap->m_DBS.pop();
|
||
isAllFinished = false;
|
||
break;
|
||
}
|
||
}
|
||
if (dbi) {
|
||
while (true && !BaseCtrl::IsStop())
|
||
{
|
||
EnterCriticalSection(&m_SeqCS);
|
||
uint64_t sb = m_ScaningBit.to_ullong();
|
||
uint64_t limitCode = m_LimitMap2[dbi->order];
|
||
uint64_t lrel = sb&limitCode;
|
||
if (lrel > 0) {
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
Sleep(5);
|
||
continue;
|
||
}
|
||
else {
|
||
m_ScaningBit[dbi->order] = true;
|
||
Printdbi = dbi;
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
|
||
if (g_isDebug) {
|
||
stringstream ss;
|
||
ss << "(" << Printdbi->order << ")" << "\n";
|
||
for (int sindex = 1; sindex < 32; sindex++) {
|
||
if (m_ScaningBit[sindex])
|
||
{
|
||
ss << sindex << " ";
|
||
}
|
||
}
|
||
ss << "\n";
|
||
OutputDebugString(ss.str().c_str());
|
||
}
|
||
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (isAllFinished)
|
||
{
|
||
if (m_ZeroSeq.empty())
|
||
{
|
||
break;
|
||
}
|
||
else {
|
||
EnterCriticalSection(&m_SeqCS);
|
||
m_SeqDataUnFinishBit[m_ScannerControlCfg->m_SeqNo] = false;
|
||
int sb = m_SeqDataUnFinishBit.to_ulong();
|
||
if (sb == 0) {
|
||
Printdbi = m_ZeroSeq.front();
|
||
m_ZeroSeq.pop();
|
||
}
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
}
|
||
}
|
||
if (BaseCtrl::IsStop())break;
|
||
if (Printdbi) {
|
||
MetaData::Part* part = Printdbi->part;
|
||
bool ischange = false;
|
||
if (m_RunCfg->m_OffsetRotateEnable) {
|
||
if (part->partPosBean.m_XOffset != 0.0f || part->partPosBean.m_YOffset != 0.0f || part->partPosBean.m_RotateAngle != 0.0f) {
|
||
ischange = true;
|
||
}
|
||
}
|
||
|
||
BPBinary::BinDataBlock* pdb = Printdbi->bdb;
|
||
MetaData::ParameterSet* paramSet = Printdbi->ps;
|
||
double laserSpeed = paramSet->laser_speed;
|
||
double laserPower = paramSet->laser_set->laser_real_power;
|
||
double spotDiameter = paramSet->laser_set->laser_diameter;
|
||
|
||
|
||
float ds = 0.0f;
|
||
bool isSkyWritingEnable = true;
|
||
double dtmep = spotDiameter - (unsigned int)(spotDiameter);
|
||
ds = (float)(dtmep * m_CorrectParamCfg->m_DefocusRatio);
|
||
if (spotDiameter > 100.0) {
|
||
isSkyWritingEnable = false;
|
||
}
|
||
|
||
ScanParamCfg* sp = m_ScannerControlCfg->GetScanParamCfg(paramSet->set_type);
|
||
LoadList(1, nodebug);
|
||
UpdateScanParamByCfg(sp);
|
||
SetSkyWritingEnable(isSkyWritingEnable, true);
|
||
SetScanSpeed(laserSpeed);
|
||
|
||
g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo - 1]->laserSpeed = laserSpeed;
|
||
SetPower(laserPower);
|
||
g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo - 1]->laserPower = paramSet->laser_set->laser_power;
|
||
|
||
if (m_CorrectParamCfg->m_IsDynamicFocus) {
|
||
SetDefocus(ds);
|
||
g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo - 1]->laserDefocus = ds;
|
||
}
|
||
EndList();
|
||
ListExecute(1, nodebug);
|
||
|
||
unsigned int currentList = 1;
|
||
unsigned int index = 0;
|
||
bool isfirst = true;
|
||
bool islistStart = true;
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
|
||
if (pdb->type == BIN_VECTOR) {
|
||
for (size_t j = 0; j < pdb->point_indexs.size(); ++j) {
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
BPBinary::VectorPoint* pvp = (BPBinary::VectorPoint*)pdb->point_indexs[j];
|
||
double real_x1 = pvp->x1;
|
||
double real_y1 = pvp->y1;
|
||
double real_x2 = pvp->x2;
|
||
double real_y2 = pvp->y2;
|
||
if (ischange) {
|
||
double mov_x1 = part->partPosBean.m_XOffset + pvp->x1;
|
||
double mov_y1 = part->partPosBean.m_YOffset + pvp->y1;
|
||
double mov_x2 = part->partPosBean.m_XOffset + pvp->x2;
|
||
double mov_y2 = part->partPosBean.m_YOffset + pvp->y2;
|
||
|
||
real_x1 = (mov_x1 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
|
||
real_y1 = (mov_x1 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
|
||
real_x2 = (mov_x2 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y2 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
|
||
real_y2 = (mov_x2 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y2 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
|
||
}
|
||
|
||
|
||
if (islistStart) {
|
||
LoadList(currentList, nodebug);
|
||
islistStart = false;
|
||
}
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
index += 2;
|
||
|
||
AddVector(real_x1, real_y1, real_x2, real_y2);
|
||
if (index == memorySize - 2) {
|
||
ListNop();
|
||
index++;
|
||
}
|
||
if (index >= (memorySize - 1)) {
|
||
EndList();
|
||
islistStart = true;
|
||
if (isfirst) {
|
||
ListExecute(currentList, false);
|
||
isfirst = false;
|
||
}
|
||
else {
|
||
AutoChangeList();
|
||
}
|
||
currentList = (currentList == 1 ? 2 : 1);
|
||
index = 0;
|
||
}
|
||
}
|
||
}
|
||
else if (pdb->type == BIN_CHAIN) {
|
||
for (unsigned int j = 0; j < pdb->point_indexs.size(); ++j) {
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
BPBinary::ChainPoint* point = (BPBinary::ChainPoint*)pdb->point_indexs[j];
|
||
for (unsigned int k = 0; k < point->points.size(); ++k) {
|
||
double real_x = point->points[k]->x;
|
||
double real_y = point->points[k]->y;
|
||
if (ischange) {
|
||
double mov_x1 = part->partPosBean.m_XOffset + point->points[k]->x;
|
||
double mov_y1 = part->partPosBean.m_YOffset + point->points[k]->y;
|
||
real_x = (mov_x1 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
|
||
real_y = (mov_x1 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
|
||
}
|
||
|
||
if (islistStart) {
|
||
LoadList(currentList, nodebug);
|
||
islistStart = false;
|
||
}
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
index++;
|
||
if (k == 0) {
|
||
JumpAbs(real_x, real_y);
|
||
}
|
||
else {
|
||
MarkAbs(real_x, real_y);
|
||
}
|
||
if (index >= (memorySize - 1)) {
|
||
EndList();
|
||
islistStart = true;
|
||
if (isfirst) {
|
||
ListExecute(currentList, false);
|
||
isfirst = false;
|
||
}
|
||
else {
|
||
AutoChangeList();
|
||
}
|
||
currentList = (currentList == 1 ? 2 : 1);
|
||
index = 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (!islistStart) {
|
||
EndList();
|
||
if (isfirst) {
|
||
ListExecute(1, false);
|
||
}
|
||
else {
|
||
AutoChangeList();
|
||
}
|
||
}
|
||
if (nodebug)
|
||
{
|
||
WaitListFree();
|
||
}
|
||
else {
|
||
Sleep(Printdbi->delayTime);
|
||
}
|
||
|
||
if (BaseCtrl::IsStop())
|
||
break;
|
||
|
||
if ((Printdbi->order > 0) && (Printdbi->order <= m_SeqCount))
|
||
{
|
||
EnterCriticalSection(&m_SeqCS);
|
||
m_ScaningBit[Printdbi->order] = false;
|
||
m_OrderDataCountMap[Printdbi->order]--;
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
}
|
||
Printdbi->isFinished = true;
|
||
|
||
/*DWORD ttemp = GetTickCount64();
|
||
if (ttemp - tUpdateScanInfoFlag > 10000) {
|
||
UpdateScannerInfo();
|
||
tUpdateScanInfoFlag = ttemp;
|
||
}*/
|
||
|
||
}
|
||
else {
|
||
Sleep(20);
|
||
}
|
||
|
||
}
|
||
//OutputDebugString("end\n");
|
||
}
|
||
|
||
|
||
void Scanner::ScanDataBlock(DataBlockInfo* Printdbi)
|
||
{
|
||
if (!Printdbi)return;
|
||
unsigned int memorySize = GetMemorySize();
|
||
bool nodebug = !g_isDebug;
|
||
MetaData::Part* part = Printdbi->part;
|
||
bool ischange = false;
|
||
if (m_RunCfg->m_OffsetRotateEnable) {
|
||
if (part->partPosBean.m_XOffset != 0.0f || part->partPosBean.m_YOffset != 0.0f || part->partPosBean.m_RotateAngle != 0.0f) {
|
||
ischange = true;
|
||
}
|
||
}
|
||
|
||
BPBinary::BinDataBlock* pdb = Printdbi->bdb;
|
||
MetaData::ParameterSet* paramSet = Printdbi->ps;
|
||
double laserSpeed = paramSet->laser_speed;
|
||
double laserPower = paramSet->laser_set->laser_real_power;
|
||
double spotDiameter = paramSet->laser_set->laser_diameter;
|
||
|
||
float ds = 0.0f;
|
||
bool isSkyWritingEnable = true;
|
||
if (spotDiameter < 100.0) {
|
||
ds = (float)(m_CorrectParamCfg->m_DefocusRatio * spotDiameter);
|
||
}
|
||
else {
|
||
double dtmep = spotDiameter - (unsigned int)(spotDiameter);
|
||
isSkyWritingEnable = false;
|
||
ds = (float)(dtmep * m_CorrectParamCfg->m_DefocusRatio);
|
||
}
|
||
ScanParamCfg* sp = m_ScannerControlCfg->GetScanParamCfg(paramSet->set_type);
|
||
LoadList(1, nodebug);
|
||
UpdateScanParamByCfg(sp);
|
||
SetSkyWritingEnable(isSkyWritingEnable, true);
|
||
SetScanSpeed(laserSpeed);
|
||
|
||
g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo - 1]->laserSpeed = laserSpeed;
|
||
SetPower(laserPower);
|
||
g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo - 1]->laserPower = paramSet->laser_set->laser_power;
|
||
|
||
if (m_CorrectParamCfg->m_IsDynamicFocus) {
|
||
SetDefocus(ds);
|
||
g_SystemInfo->m_StateBean.laserParams[m_ScannerControlCfg->m_SeqNo - 1]->laserDefocus = ds;
|
||
}
|
||
EndList();
|
||
ListExecute(1, nodebug);
|
||
|
||
unsigned int currentList = 1;
|
||
unsigned int index = 0;
|
||
bool isfirst = true;
|
||
bool islistStart = true;
|
||
if (BaseCtrl::IsStop()) {
|
||
return;
|
||
}
|
||
|
||
if (pdb->type == BIN_VECTOR) {
|
||
for (size_t j = 0; j < pdb->point_indexs.size(); ++j) {
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
BPBinary::VectorPoint* pvp = (BPBinary::VectorPoint*)pdb->point_indexs[j];
|
||
double real_x1 = pvp->x1;
|
||
double real_y1 = pvp->y1;
|
||
double real_x2 = pvp->x2;
|
||
double real_y2 = pvp->y2;
|
||
if (ischange) {
|
||
double mov_x1 = part->partPosBean.m_XOffset + pvp->x1;
|
||
double mov_y1 = part->partPosBean.m_YOffset + pvp->y1;
|
||
double mov_x2 = part->partPosBean.m_XOffset + pvp->x2;
|
||
double mov_y2 = part->partPosBean.m_YOffset + pvp->y2;
|
||
|
||
real_x1 = (mov_x1 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
|
||
real_y1 = (mov_x1 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
|
||
real_x2 = (mov_x2 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y2 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
|
||
real_y2 = (mov_x2 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y2 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
|
||
}
|
||
|
||
|
||
if (islistStart) {
|
||
LoadList(currentList, nodebug);
|
||
islistStart = false;
|
||
}
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
index += 2;
|
||
|
||
AddVector(real_x1, real_y1, real_x2, real_y2);
|
||
if (index == memorySize - 2) {
|
||
ListNop();
|
||
index++;
|
||
}
|
||
if (index >= (memorySize - 1)) {
|
||
EndList();
|
||
islistStart = true;
|
||
if (isfirst) {
|
||
ListExecute(currentList, false);
|
||
isfirst = false;
|
||
}
|
||
else {
|
||
AutoChangeList();
|
||
}
|
||
currentList = (currentList == 1 ? 2 : 1);
|
||
index = 0;
|
||
}
|
||
}
|
||
}
|
||
else if (pdb->type == BIN_CHAIN) {
|
||
for (unsigned int j = 0; j < pdb->point_indexs.size(); ++j) {
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
BPBinary::ChainPoint* point = (BPBinary::ChainPoint*)pdb->point_indexs[j];
|
||
for (unsigned int k = 0; k < point->points.size(); ++k) {
|
||
double real_x = point->points[k]->x;
|
||
double real_y = point->points[k]->y;
|
||
if (ischange) {
|
||
double mov_x1 = part->partPosBean.m_XOffset + point->points[k]->x;
|
||
double mov_y1 = part->partPosBean.m_YOffset + point->points[k]->y;
|
||
real_x = (mov_x1 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
|
||
real_y = (mov_x1 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
|
||
}
|
||
|
||
if (islistStart) {
|
||
LoadList(currentList, nodebug);
|
||
islistStart = false;
|
||
}
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
index++;
|
||
if (k == 0) {
|
||
JumpAbs(real_x, real_y);
|
||
}
|
||
else {
|
||
MarkAbs(real_x, real_y);
|
||
}
|
||
if (index >= (memorySize - 1)) {
|
||
EndList();
|
||
islistStart = true;
|
||
if (isfirst) {
|
||
ListExecute(currentList, false);
|
||
isfirst = false;
|
||
}
|
||
else {
|
||
AutoChangeList();
|
||
}
|
||
currentList = (currentList == 1 ? 2 : 1);
|
||
index = 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (!islistStart) {
|
||
EndList();
|
||
if (isfirst) {
|
||
ListExecute(1, false);
|
||
}
|
||
else {
|
||
AutoChangeList();
|
||
}
|
||
}
|
||
if (nodebug)
|
||
{
|
||
WaitListFree();
|
||
}
|
||
else {
|
||
Sleep(Printdbi->delayTime);
|
||
}
|
||
|
||
if (BaseCtrl::IsStop())
|
||
return;
|
||
|
||
if ((Printdbi->order > 0) && (Printdbi->order <= m_SeqCount))
|
||
{
|
||
EnterCriticalSection(&m_SeqCS);
|
||
m_ScaningBit[Printdbi->order] = false;
|
||
m_OrderDataCountMap[Printdbi->order]--;
|
||
LeaveCriticalSection(&m_SeqCS);
|
||
}
|
||
Printdbi->isFinished = true;
|
||
}
|
||
|
||
void Scanner::StartHeatingScannerTest()
|
||
{
|
||
StopHeatingScannerTest();
|
||
m_HeatingScannerRunFlag = true;
|
||
m_HeatingScannerThread = AtlCreateThread(HeatingScannerProc, this);
|
||
}
|
||
|
||
void Scanner::StopHeatingScannerTest()
|
||
{
|
||
m_HeatingScannerRunFlag = false;
|
||
if (m_HeatingScannerThread != INVALID_HANDLE_VALUE) {
|
||
if (WaitForSingleObject(m_HeatingScannerThread, 300) == WAIT_TIMEOUT) {
|
||
StopWork();
|
||
TerminateThread(m_HeatingScannerThread, 1);
|
||
}
|
||
CloseHandle(m_HeatingScannerThread);
|
||
m_HeatingScannerThread = INVALID_HANDLE_VALUE;
|
||
}
|
||
}
|
||
|
||
bool Scanner::IsHeatingScannerTest()
|
||
{
|
||
return m_HeatingScannerRunFlag;
|
||
}
|
||
|
||
DWORD WINAPI Scanner::HeatingScannerProc(Scanner* _this)
|
||
{
|
||
if (_this) {
|
||
_this->HeatingScannerRun();
|
||
_this->m_HeatingScannerRunFlag = false;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
void Scanner::WaitHeatingScanner()
|
||
{
|
||
if (m_HeatingScannerThread == INVALID_HANDLE_VALUE)return;
|
||
WaitForSingleObject(m_HeatingScannerThread, INFINITE);
|
||
}
|
||
|
||
void Scanner::StartGetScanInfo()
|
||
{
|
||
if (!m_MachineCfg->m_IsIntelli)return;
|
||
if (m_InfoThread != INVALID_HANDLE_VALUE) {
|
||
m_IsAutoInfo = false;
|
||
m_InfoRunFlag = false;
|
||
if (WaitForSingleObject(m_InfoThread, 500) == WAIT_TIMEOUT)
|
||
{
|
||
TerminateThread(m_InfoThread, 1);
|
||
}
|
||
CloseHandle(m_InfoThread);
|
||
m_InfoThread = INVALID_HANDLE_VALUE;
|
||
}
|
||
m_InfoRunFlag = true;
|
||
m_IsAutoInfo = true;
|
||
m_InfoThread = AtlCreateThread(ScannerInfoProc, this);
|
||
}
|
||
|
||
void Scanner::StopGetScanInfo()
|
||
{
|
||
m_IsAutoInfo = false;
|
||
m_InfoRunFlag = false;
|
||
if (m_InfoThread != INVALID_HANDLE_VALUE) {
|
||
if (WaitForSingleObject(m_InfoThread, 500) == WAIT_TIMEOUT)
|
||
{
|
||
TerminateThread(m_InfoThread, 1);
|
||
}
|
||
CloseHandle(m_InfoThread);
|
||
m_InfoThread = INVALID_HANDLE_VALUE;
|
||
}
|
||
}
|
||
|
||
DWORD WINAPI Scanner::ScannerInfoProc(Scanner* _this)
|
||
{
|
||
if (_this) {
|
||
_this->ScannerInfoRun();
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
void Scanner::SetAutoUpdateScanInfo(bool isauto)
|
||
{
|
||
m_IsAutoInfo = isauto;
|
||
}
|
||
|
||
void Scanner::GetXYScanState(ScanStateXY* scanstate, time_t &t)
|
||
{
|
||
EnterCriticalSection(&m_ScannerInfoCS);
|
||
t = m_ScanStateUpdateTime;
|
||
memcpy_s(&scanstate->m_X, sizeof(IntelliScanState), &m_ScanState.m_X, sizeof(IntelliScanState));
|
||
memcpy_s(&scanstate->m_Y, sizeof(IntelliScanState), &m_ScanState.m_Y, sizeof(IntelliScanState));
|
||
LeaveCriticalSection(&m_ScannerInfoCS);
|
||
}
|
||
|
||
|
||
/*bool Scanner::IsUpScanner()
|
||
{
|
||
if (m_LaserCfg->m_Cno < 3) {
|
||
return true;
|
||
}
|
||
else return false;
|
||
}*/
|
||
|
||
uint64_t Scanner::GetLimitCodeV2(int ivalue)
|
||
{
|
||
bitset<64> btemp;
|
||
btemp.reset();
|
||
switch (ivalue) {
|
||
|
||
case 8: {
|
||
btemp[17] = true;
|
||
btemp[25] = true;
|
||
}break;
|
||
|
||
case 16: {
|
||
btemp[17] = true;
|
||
btemp[25] = true;
|
||
}break;
|
||
case 17: {
|
||
btemp[8] = true;
|
||
btemp[16] = true;
|
||
}break;
|
||
|
||
case 25: {
|
||
btemp[8] = true;
|
||
btemp[16] = true;
|
||
}break;
|
||
}
|
||
|
||
bitset<64> htemp;
|
||
htemp.reset();
|
||
switch (ivalue) {
|
||
case 1: {
|
||
htemp[9] = true;
|
||
}break;
|
||
case 2: {
|
||
htemp[9] = true;
|
||
htemp[10] = true;
|
||
}break;
|
||
case 3: {
|
||
htemp[10] = true;
|
||
htemp[11] = true;
|
||
}break;
|
||
case 4: {
|
||
htemp[11] = true;
|
||
htemp[12] = true;
|
||
}break;
|
||
case 5: {
|
||
htemp[12] = true;
|
||
htemp[13] = true;
|
||
}break;
|
||
case 6: {
|
||
htemp[13] = true;
|
||
htemp[14] = true;
|
||
}break;
|
||
|
||
case 7: {
|
||
htemp[14] = true;
|
||
htemp[15] = true;
|
||
}break;
|
||
|
||
case 8: {
|
||
htemp[15] = true;
|
||
htemp[16] = true;
|
||
}break;
|
||
|
||
case 17: {
|
||
htemp[25] = true;
|
||
}break;
|
||
case 18: {
|
||
htemp[25] = true;
|
||
htemp[26] = true;
|
||
}break;
|
||
case 19: {
|
||
htemp[26] = true;
|
||
htemp[27] = true;
|
||
}break;
|
||
case 20: {
|
||
htemp[27] = true;
|
||
htemp[28] = true;
|
||
}break;
|
||
case 21: {
|
||
htemp[28] = true;
|
||
htemp[29] = true;
|
||
}break;
|
||
case 22: {
|
||
htemp[29] = true;
|
||
htemp[30] = true;
|
||
}break;
|
||
case 23: {
|
||
htemp[30] = true;
|
||
htemp[31] = true;
|
||
}break;
|
||
case 24: {
|
||
htemp[31] = true;
|
||
htemp[32] = true;
|
||
}break;
|
||
}
|
||
m_HorizontalSeq2[ivalue] = htemp.to_ullong();
|
||
return btemp.to_ullong();
|
||
}
|
||
|
||
|
||
map<int, uint64_t> Scanner::m_LimitMap2 = map<int, uint64_t>();
|
||
map<int, uint64_t> Scanner::m_HorizontalSeq2 = map<int, uint64_t>();
|
||
bitset<8> Scanner::m_SeqDataUnFinishBit = bitset<8>();
|
||
bitset<8> Scanner::m_SupportSeqDataUnFinishBit = bitset<8>();
|
||
bitset<64> Scanner::m_ScaningBit = bitset<64>();
|
||
CRITICAL_SECTION Scanner::m_SeqCS;
|
||
map<int, unsigned int> Scanner::m_CurrentSerio=map<int, unsigned int>(); |