1688 lines
43 KiB
C++
1688 lines
43 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);
|
|
m_ScanState.m_ScanStateUpdateTime->SetValue(to_string(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() || m_MachineCfg->IsMassStrategy())
|
|
{
|
|
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())
|
|
{
|
|
OrderMap* om = new OrderMap();
|
|
om->m_Order = _order;
|
|
m_OrderMap[_order] = om;
|
|
}
|
|
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) {
|
|
int seqNo = _this->m_ScannerControlCfg->m_SeqNo ;
|
|
if (_this->m_MachineCfg->IsDataSeqStragegy())
|
|
{
|
|
EnterCriticalSection(&m_SeqCS);
|
|
m_SeqDataUnFinishBit[seqNo] = true;
|
|
m_SupportSeqDataUnFinishBit[seqNo] = true;
|
|
LeaveCriticalSection(&m_SeqCS);
|
|
_this->ScanSeqV2();
|
|
EnterCriticalSection(&m_SeqCS);
|
|
m_SeqDataUnFinishBit[seqNo] = false;
|
|
m_SupportSeqDataUnFinishBit[seqNo] = false;
|
|
LeaveCriticalSection(&m_SeqCS);
|
|
}
|
|
else if (_this->m_MachineCfg->IsMassStrategy())
|
|
{
|
|
EnterCriticalSection(&m_SeqCS);
|
|
m_SeqDataUnFinishBit[seqNo] = true;
|
|
m_SupportSeqDataUnFinishBit[seqNo] = true;
|
|
LeaveCriticalSection(&m_SeqCS);
|
|
_this->ScanMass();
|
|
EnterCriticalSection(&m_SeqCS);
|
|
m_SeqDataUnFinishBit[seqNo] = false;
|
|
m_SupportSeqDataUnFinishBit[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->GetValue())g_log->TraceInfo(u8"开始等待振镜%d完成扫描", m_ScannerControlCfg->m_SeqNo);
|
|
WaitForSingleObject(m_Thread, INFINITE);
|
|
Clean();
|
|
CloseHandle(m_Thread);
|
|
m_Thread = INVALID_HANDLE_VALUE;
|
|
if (m_RunCfg->m_LogDebugInfo->GetValue())g_log->TraceInfo(u8"振镜%d完成扫描", 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);
|
|
if (m_ScannerControlCfg){
|
|
int seqNo = m_ScannerControlCfg->m_SeqNo ;
|
|
m_SeqDataUnFinishBit[seqNo] = false;
|
|
m_SupportSeqDataUnFinishBit[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();
|
|
char buffer[512];
|
|
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->GetValue()) {
|
|
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);
|
|
|
|
int seqNo = m_ScannerControlCfg->m_SeqNo ;
|
|
g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserSpeed = laserSpeed;
|
|
SetPower(laserPower);
|
|
g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserPower = paramSet->laser_set->laser_power;
|
|
|
|
if (m_CorrectParamCfg->m_IsDynamicFocus) {
|
|
SetDefocus(ds);
|
|
g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserDefocus = ds;
|
|
}
|
|
EndList();
|
|
ListExecute(1, nodebug);
|
|
|
|
EnterCriticalSection(&m_SeqCS);
|
|
sprintf_s(buffer, sizeof(buffer), "scanner:%d scan part:%d\n", seqNo, part->id);
|
|
OutputDebugString(buffer);
|
|
LeaveCriticalSection(&m_SeqCS);
|
|
|
|
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 (g_isDebug) {
|
|
Sleep(m_ScanData[i]->delayTime);
|
|
}
|
|
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<128>btemp = m_HorizontalSeqLeftFirst[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;
|
|
bitset<128> lrel = m_ScaningBit & m_LimitMap[order];
|
|
if (lrel.any()) {
|
|
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;
|
|
/*
|
|
stringstream ss;
|
|
ss << "(" << Printdbi->order << ")" << "\n";
|
|
for (int sindex = 1; sindex < m_SeqCount; 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;
|
|
bitset<128> lrel = m_ScaningBit & m_LimitMap[dbi->order];
|
|
if (lrel.any()) {
|
|
LeaveCriticalSection(&m_SeqCS);
|
|
Sleep(5);
|
|
continue;
|
|
}
|
|
else {
|
|
m_ScaningBit[dbi->order] = true;
|
|
Printdbi = dbi;
|
|
LeaveCriticalSection(&m_SeqCS);
|
|
/*
|
|
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->GetValue()) {
|
|
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::ScanMass() {
|
|
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;
|
|
|
|
int seqNo = m_ScannerControlCfg->m_SeqNo ;
|
|
EnterCriticalSection(&m_SeqCS);
|
|
m_SupportSeqDataUnFinishBit[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;
|
|
|
|
OrderMap* printOrderMap = NULL;
|
|
|
|
for (map<int, OrderMap*>::iterator orderIt = m_OrderMap.begin(); orderIt != m_OrderMap.end();) {
|
|
|
|
if (BaseCtrl::IsStop()) {
|
|
break;
|
|
}
|
|
Sleep(20);
|
|
OrderMap* orderMap = orderIt->second;
|
|
if (orderMap->m_DBS.empty()) {
|
|
delete orderMap;
|
|
orderMap = NULL;
|
|
m_OrderMap.erase(orderIt++);
|
|
continue;
|
|
}
|
|
else {
|
|
int order = orderIt->first;
|
|
if ((order <= 0) || (order > m_SeqCount) || (m_MassHorizontalSeq.find(order) == m_MassHorizontalSeq.end()))
|
|
{
|
|
delete orderMap;
|
|
orderMap = NULL;
|
|
m_OrderMap.erase(orderIt++);
|
|
continue;
|
|
}
|
|
EnterCriticalSection(&m_SeqCS);
|
|
int limitseq = m_MassHorizontalSeq[order];
|
|
if (m_ScaningBit[limitseq]) {
|
|
LeaveCriticalSection(&m_SeqCS);
|
|
orderIt++;
|
|
continue;
|
|
}
|
|
else {
|
|
m_ScaningBit[order] = true;
|
|
printOrderMap = orderMap;
|
|
LeaveCriticalSection(&m_SeqCS);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (printOrderMap != NULL)
|
|
{
|
|
|
|
while (!printOrderMap->m_DBS.empty()) {
|
|
DataBlockInfo* dbi = printOrderMap->m_DBS.front();
|
|
printOrderMap->m_DBS.pop();
|
|
ScanDataBlock(dbi);
|
|
if (BaseCtrl::IsStop()) {
|
|
break;
|
|
}
|
|
}
|
|
EnterCriticalSection(&m_SeqCS);
|
|
m_ScaningBit[printOrderMap->m_Order] = false;
|
|
LeaveCriticalSection(&m_SeqCS);
|
|
printOrderMap = NULL;
|
|
}
|
|
|
|
if (m_OrderMap.empty()) {
|
|
EnterCriticalSection(&m_SeqCS);
|
|
m_SeqDataUnFinishBit[seqNo] = false;
|
|
LeaveCriticalSection(&m_SeqCS);
|
|
break;
|
|
}
|
|
}
|
|
if (BaseCtrl::IsStop())return;
|
|
|
|
if (m_ZeroSeq.empty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
while (true && !BaseCtrl::IsStop()) {
|
|
if (m_ZeroSeq.empty()) {
|
|
break;
|
|
}
|
|
DataBlockInfo* Printdbi = NULL;
|
|
EnterCriticalSection(&m_SeqCS);
|
|
int sb = m_SeqDataUnFinishBit.to_ulong();
|
|
if (sb == 0) {
|
|
Printdbi = m_ZeroSeq.front();
|
|
m_ZeroSeq.pop();
|
|
}
|
|
LeaveCriticalSection(&m_SeqCS);
|
|
|
|
if (!Printdbi) {
|
|
Sleep(20);
|
|
continue;
|
|
}
|
|
ScanDataBlock(Printdbi);
|
|
}
|
|
}
|
|
|
|
|
|
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->GetValue()) {
|
|
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);
|
|
|
|
int seqNo = m_ScannerControlCfg->m_SeqNo ;
|
|
g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserSpeed = laserSpeed;
|
|
SetPower(laserPower);
|
|
g_SystemInfo->m_StateBean.laserParams[seqNo - 1]->laserPower = paramSet->laser_set->laser_power;
|
|
|
|
if (m_CorrectParamCfg->m_IsDynamicFocus) {
|
|
SetDefocus(ds);
|
|
g_SystemInfo->m_StateBean.laserParams[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 (m_MachineCfg->IsDataSeqStragegy()) {
|
|
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->GetValue())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;
|
|
}
|
|
|
|
|
|
/*bool Scanner::IsUpScanner()
|
|
{
|
|
if (m_LaserCfg->m_Cno < 3) {
|
|
return true;
|
|
}
|
|
else return false;
|
|
}*/
|
|
|
|
void Scanner::GetLimitCodeV2(int ivalue)
|
|
{
|
|
bitset<128> 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;
|
|
|
|
case 24: {
|
|
btemp[33] = true;
|
|
btemp[41] = true;
|
|
}break;
|
|
|
|
case 32: {
|
|
btemp[33] = true;
|
|
btemp[41] = true;
|
|
}break;
|
|
case 33: {
|
|
btemp[24] = true;
|
|
btemp[32] = true;
|
|
}break;
|
|
case 41: {
|
|
btemp[24] = true;
|
|
btemp[32] = true;
|
|
}break;
|
|
|
|
case 40: {
|
|
btemp[49] = true;
|
|
btemp[57] = true;
|
|
}break;
|
|
case 48: {
|
|
btemp[49] = true;
|
|
btemp[57] = true;
|
|
}break;
|
|
case 49: {
|
|
btemp[40] = true;
|
|
btemp[48] = true;
|
|
}break;
|
|
case 57: {
|
|
btemp[40] = true;
|
|
btemp[48] = true;
|
|
}break;
|
|
}
|
|
m_LimitMap[ivalue] = btemp;
|
|
|
|
bitset<128> 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;
|
|
|
|
case 33: {
|
|
htemp[41] = true;
|
|
}break;
|
|
case 34: {
|
|
htemp[41] = true;
|
|
htemp[42] = true;
|
|
}break;
|
|
case 35: {
|
|
htemp[42] = true;
|
|
htemp[43] = true;
|
|
}break;
|
|
case 36: {
|
|
htemp[43] = true;
|
|
htemp[44] = true;
|
|
}break;
|
|
case 37: {
|
|
htemp[44] = true;
|
|
htemp[45] = true;
|
|
}break;
|
|
case 38: {
|
|
htemp[45] = true;
|
|
htemp[46] = true;
|
|
}break;
|
|
case 39: {
|
|
htemp[46] = true;
|
|
htemp[47] = true;
|
|
}break;
|
|
case 40: {
|
|
htemp[47] = true;
|
|
htemp[48] = true;
|
|
}break;
|
|
case 49: {
|
|
htemp[57] = true;
|
|
}break;
|
|
case 50: {
|
|
htemp[57] = true;
|
|
htemp[58] = true;
|
|
}break;
|
|
case 51: {
|
|
htemp[58] = true;
|
|
htemp[59] = true;
|
|
}break;
|
|
case 52: {
|
|
htemp[59] = true;
|
|
htemp[60] = true;
|
|
}break;
|
|
case 53: {
|
|
htemp[60] = true;
|
|
htemp[61] = true;
|
|
}break;
|
|
case 54: {
|
|
htemp[61] = true;
|
|
htemp[62] = true;
|
|
}break;
|
|
case 55: {
|
|
htemp[62] = true;
|
|
htemp[63] = true;
|
|
}break;
|
|
case 56: {
|
|
htemp[63] = true;
|
|
htemp[64] = true;
|
|
}break;
|
|
}
|
|
m_HorizontalSeqRightFirst[ivalue] = htemp;
|
|
|
|
|
|
bitset<128> htemp2;
|
|
htemp2.reset();
|
|
switch (ivalue) {
|
|
case 9: {
|
|
htemp2[1] = true;
|
|
}break;
|
|
case 10: {
|
|
htemp2[1] = true;
|
|
htemp2[2] = true;
|
|
}break;
|
|
case 11: {
|
|
htemp2[2] = true;
|
|
htemp2[3] = true;
|
|
}break;
|
|
case 12: {
|
|
htemp2[3] = true;
|
|
htemp2[4] = true;
|
|
}break;
|
|
case 13: {
|
|
htemp2[4] = true;
|
|
htemp2[5] = true;
|
|
}break;
|
|
case 14: {
|
|
htemp2[5] = true;
|
|
htemp2[6] = true;
|
|
}break;
|
|
|
|
case 15: {
|
|
htemp2[6] = true;
|
|
htemp2[7] = true;
|
|
}break;
|
|
|
|
case 16: {
|
|
htemp2[7] = true;
|
|
htemp2[8] = true;
|
|
}break;
|
|
|
|
case 25: {
|
|
htemp2[17] = true;
|
|
}break;
|
|
case 26: {
|
|
htemp2[17] = true;
|
|
htemp2[18] = true;
|
|
}break;
|
|
case 27: {
|
|
htemp2[18] = true;
|
|
htemp2[19] = true;
|
|
}break;
|
|
case 28: {
|
|
htemp2[19] = true;
|
|
htemp2[20] = true;
|
|
}break;
|
|
case 29: {
|
|
htemp2[20] = true;
|
|
htemp2[21] = true;
|
|
}break;
|
|
case 30: {
|
|
htemp2[21] = true;
|
|
htemp2[22] = true;
|
|
}break;
|
|
case 31: {
|
|
htemp2[22] = true;
|
|
htemp2[23] = true;
|
|
}break;
|
|
case 32: {
|
|
htemp2[23] = true;
|
|
htemp2[24] = true;
|
|
}break;
|
|
|
|
case 41: {
|
|
htemp2[33] = true;
|
|
}break;
|
|
case 42: {
|
|
htemp2[33] = true;
|
|
htemp2[34] = true;
|
|
}break;
|
|
case 43: {
|
|
htemp2[34] = true;
|
|
htemp2[35] = true;
|
|
}break;
|
|
case 44: {
|
|
htemp2[35] = true;
|
|
htemp2[36] = true;
|
|
}break;
|
|
case 45: {
|
|
htemp2[36] = true;
|
|
htemp2[37] = true;
|
|
}break;
|
|
case 46: {
|
|
htemp2[37] = true;
|
|
htemp2[38] = true;
|
|
}break;
|
|
case 47: {
|
|
htemp2[38] = true;
|
|
htemp2[39] = true;
|
|
}break;
|
|
case 48: {
|
|
htemp2[39] = true;
|
|
htemp2[40] = true;
|
|
}break;
|
|
case 57: {
|
|
htemp2[49] = true;
|
|
}break;
|
|
case 58: {
|
|
htemp2[49] = true;
|
|
htemp2[50] = true;
|
|
}break;
|
|
case 59: {
|
|
htemp2[50] = true;
|
|
htemp2[51] = true;
|
|
}break;
|
|
case 60: {
|
|
htemp2[51] = true;
|
|
htemp2[52] = true;
|
|
}break;
|
|
case 61: {
|
|
htemp2[52] = true;
|
|
htemp2[53] = true;
|
|
}break;
|
|
case 62: {
|
|
htemp2[53] = true;
|
|
htemp2[54] = true;
|
|
}break;
|
|
case 63: {
|
|
htemp2[54] = true;
|
|
htemp2[55] = true;
|
|
}break;
|
|
case 64: {
|
|
htemp2[55] = true;
|
|
htemp2[56] = true;
|
|
}break;
|
|
}
|
|
m_HorizontalSeqLeftFirst[ivalue] = htemp2;
|
|
|
|
}
|
|
|
|
|
|
void Scanner::InitMassLimitCode()
|
|
{
|
|
m_MassHorizontalSeq[1] = 9;
|
|
m_MassHorizontalSeq[2] = 10;
|
|
m_MassHorizontalSeq[3] = 11;
|
|
m_MassHorizontalSeq[4] = 12;
|
|
m_MassHorizontalSeq[5] = 13;
|
|
m_MassHorizontalSeq[6] = 14;
|
|
m_MassHorizontalSeq[7] = 15;
|
|
m_MassHorizontalSeq[8] = 16;
|
|
|
|
m_MassHorizontalSeq[9] = 1;
|
|
m_MassHorizontalSeq[10] = 2;
|
|
m_MassHorizontalSeq[11] = 3;
|
|
m_MassHorizontalSeq[12] = 4;
|
|
m_MassHorizontalSeq[13] = 5;
|
|
m_MassHorizontalSeq[14] = 6;
|
|
m_MassHorizontalSeq[15] = 7;
|
|
m_MassHorizontalSeq[16] = 8;
|
|
|
|
m_MassHorizontalSeq[17] = 25;
|
|
m_MassHorizontalSeq[18] = 26;
|
|
m_MassHorizontalSeq[19] = 27;
|
|
m_MassHorizontalSeq[20] = 28;
|
|
m_MassHorizontalSeq[21] = 29;
|
|
m_MassHorizontalSeq[22] = 30;
|
|
m_MassHorizontalSeq[23] = 31;
|
|
m_MassHorizontalSeq[24] = 32;
|
|
|
|
m_MassHorizontalSeq[25] = 17;
|
|
m_MassHorizontalSeq[26] = 18;
|
|
m_MassHorizontalSeq[27] = 19;
|
|
m_MassHorizontalSeq[28] = 20;
|
|
m_MassHorizontalSeq[29] = 21;
|
|
m_MassHorizontalSeq[30] = 22;
|
|
m_MassHorizontalSeq[31] = 23;
|
|
m_MassHorizontalSeq[32] = 24;
|
|
|
|
m_MassHorizontalSeq[33] = 41;
|
|
m_MassHorizontalSeq[34] = 42;
|
|
m_MassHorizontalSeq[35] = 43;
|
|
m_MassHorizontalSeq[36] = 44;
|
|
m_MassHorizontalSeq[37] = 45;
|
|
m_MassHorizontalSeq[38] = 46;
|
|
m_MassHorizontalSeq[39] = 47;
|
|
m_MassHorizontalSeq[40] = 48;
|
|
|
|
m_MassHorizontalSeq[41] = 33;
|
|
m_MassHorizontalSeq[42] = 34;
|
|
m_MassHorizontalSeq[43] = 35;
|
|
m_MassHorizontalSeq[44] = 36;
|
|
m_MassHorizontalSeq[45] = 37;
|
|
m_MassHorizontalSeq[46] = 38;
|
|
m_MassHorizontalSeq[47] = 39;
|
|
m_MassHorizontalSeq[48] = 40;
|
|
|
|
m_MassHorizontalSeq[49] = 57;
|
|
m_MassHorizontalSeq[50] = 58;
|
|
m_MassHorizontalSeq[51] = 59;
|
|
m_MassHorizontalSeq[52] = 60;
|
|
m_MassHorizontalSeq[53] = 61;
|
|
m_MassHorizontalSeq[54] = 62;
|
|
m_MassHorizontalSeq[55] = 63;
|
|
m_MassHorizontalSeq[56] = 64;
|
|
|
|
m_MassHorizontalSeq[57] = 49;
|
|
m_MassHorizontalSeq[58] = 50;
|
|
m_MassHorizontalSeq[59] = 51;
|
|
m_MassHorizontalSeq[60] = 52;
|
|
m_MassHorizontalSeq[61] = 53;
|
|
m_MassHorizontalSeq[62] = 54;
|
|
m_MassHorizontalSeq[63] = 55;
|
|
m_MassHorizontalSeq[64] = 56;
|
|
|
|
}
|
|
|
|
void Scanner::GetXYScanState(ScanStateXYSCT* scanstate, time_t& t)
|
|
{
|
|
EnterCriticalSection(&m_ScannerInfoCS);
|
|
t = m_ScanStateUpdateTime;
|
|
|
|
m_ScanState.m_X.GetState(scanstate->m_X);
|
|
m_ScanState.m_Y.GetState(scanstate->m_Y);
|
|
m_ScanState.m_Focus.GetState(scanstate->m_Focus);
|
|
//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);
|
|
}
|
|
|
|
|
|
map<int, bitset<128>> Scanner::m_LimitMap = map<int, bitset<128>>();
|
|
map<int, bitset<128>> Scanner::m_HorizontalSeqRightFirst = map<int, bitset<128>>();
|
|
map<int, bitset<128>> Scanner::m_HorizontalSeqLeftFirst = map<int, bitset<128>>();
|
|
bitset<16> Scanner::m_SeqDataUnFinishBit = bitset<16>();
|
|
bitset<16> Scanner::m_SupportSeqDataUnFinishBit = bitset<16>();
|
|
bitset<128> Scanner::m_ScaningBit = bitset<128>();
|
|
CRITICAL_SECTION Scanner::m_SeqCS;
|
|
map<int, unsigned int> Scanner::m_CurrentSerio = map<int, unsigned int>();
|
|
map<int, int> Scanner::m_MassHorizontalSeq = map<int, int>();
|
|
int Scanner::m_SeqCount = 64; |