wangxx1809/GrpcPrint
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
GrpcPrint/PrintS/ScannerCtrl/Scanner.cpp

1209 lines
34 KiB
C++
Raw Normal View History

添加功能
2024-03-26 10:33:00 +08:00
#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>();
Reference in New Issue Copy Permalink