1737 lines
54 KiB
C++
1737 lines
54 KiB
C++
#include "ScannerCtrl.h"
|
||
#include "../config/ConfigManager.h"
|
||
#include "../Toast.h"
|
||
#include "../LanguageManager.h"
|
||
#include "../SystemInfo.h"
|
||
#include "RTC5Scanner.h"
|
||
#include "../Logger.h"
|
||
#include "../global.h"
|
||
#include "../PLC/SignalService.h"
|
||
#include "ScannerPair.h"
|
||
#include "../utils/StringHelper.h"
|
||
#include "../Remote/RemoteClient.h"
|
||
#include "../utils/TimeHelper.h"
|
||
|
||
ScannerCtrl::ScannerCtrl()
|
||
:m_print_thread(INVALID_HANDLE_VALUE)
|
||
, m_RedPrintTestThread(INVALID_HANDLE_VALUE)
|
||
, m_PressureCtrlFlag(false)
|
||
, m_PressureThread(INVALID_HANDLE_VALUE)
|
||
, m_HeatingMotionThread(INVALID_HANDLE_VALUE)
|
||
, m_HeatingMotionFlag(false)
|
||
{
|
||
InitializeCriticalSection(&m_LayerTestCs);
|
||
//m_PowderEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
||
m_DownSkinStopFlag = 1;
|
||
m_IsDownSkinContinue = false;
|
||
time(&m_LastSendFinishReportTime);
|
||
}
|
||
|
||
ScannerCtrl::~ScannerCtrl()
|
||
{
|
||
m_PressureCtrlFlag = false;
|
||
if (m_print_thread!= INVALID_HANDLE_VALUE) {
|
||
BaseCtrl::SetState(BaseCtrl::STOP);
|
||
if (WaitForSingleObject(m_print_thread, 5000)==WAIT_TIMEOUT) {
|
||
TerminateThread(m_print_thread, 1);
|
||
}
|
||
CloseHandle(m_print_thread);
|
||
m_print_thread = INVALID_HANDLE_VALUE;
|
||
}
|
||
WaitForSingleObject(m_PressureThread, 1000);
|
||
//if (m_UpScannerPair)delete m_UpScannerPair;
|
||
//if (m_DownScannerPair)delete m_DownScannerPair;
|
||
|
||
DeleteCriticalSection(&m_LayerTestCs);
|
||
|
||
for (unsigned int i = 0; i < m_scan.size(); i++)
|
||
{
|
||
delete m_scan[i];
|
||
}
|
||
m_scan.clear();
|
||
|
||
RTC5Scanner::Uninit();
|
||
|
||
//CloseHandle(m_PowderEvent);
|
||
}
|
||
|
||
bool ScannerCtrl::Init() {
|
||
// m_UpScannerPair = new ScannerPair();
|
||
//m_DownScannerPair = new ScannerPair();
|
||
m_RunCfg = ConfigManager::GetInstance()->GetRunCfg();
|
||
m_MachineCfg = ConfigManager::GetInstance()->GetMachineCfg();
|
||
m_Machine = ConfigManager::GetInstance()->GetMachine();
|
||
m_IOCfgWrapper = ConfigManager::GetInstance()->GetIoCfgWrapper();
|
||
m_ExtCfg = ConfigManager::GetInstance()->GetExtCfg();
|
||
m_CoverCfg = ConfigManager::GetInstance()->GetCoverCfg();
|
||
m_PowderEstimateCfg = ConfigManager::GetInstance()->GetPowderEstimateCfg();
|
||
m_AlarmCfgWrapper = ConfigManager::GetInstance()->GetAlarmCfg();
|
||
m_RecoatCheckCfg = ConfigManager::GetInstance()->GetRecoatCheckCfg();
|
||
map<int, ScannerControlCfg*>* scannerControlCfgsMap = ConfigManager::GetInstance()->GetScannerControlCfg();
|
||
bool rel = false;
|
||
unsigned int card_num = 0;
|
||
RTC5Scanner::PreInit(card_num);
|
||
|
||
|
||
|
||
int difSize = Scanner::m_CurrentSerio.size() - scannerControlCfgsMap->size();
|
||
if (difSize > 0) {
|
||
int flag = 0;
|
||
for (map<int, unsigned int>::iterator s = Scanner::m_CurrentSerio.begin(); s != Scanner::m_CurrentSerio.end(); s++) {
|
||
bool find = false;
|
||
for (map<int, ScannerControlCfg*>::iterator scc = scannerControlCfgsMap->begin(); scc != scannerControlCfgsMap->end(); scc++)
|
||
{
|
||
ScannerControlCfg* cfg = scc->second;
|
||
if (cfg->m_SerialNo == s->second)
|
||
{
|
||
find = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!find && flag < difSize)
|
||
{
|
||
ScannerControlCfg* cfg = new ScannerControlCfg();
|
||
cfg->m_SeqNo = scannerControlCfgsMap->size() + 1;
|
||
cfg->m_CardName = "Laser" + to_string(cfg->m_SeqNo);
|
||
cfg->m_ControlNo = s->first;
|
||
cfg->m_ControlType = m_MachineCfg->m_ScanControl;
|
||
cfg->m_SerialNo = s->second;
|
||
cfg->m_HadMatch = false;
|
||
cfg->m_IsEnable = true;
|
||
cfg->Init();
|
||
//m_Machine->InitScanParamBeforeFind(&cfg->m_ScanCfgWrapper); //wxxtest
|
||
ConfigManager::GetInstance()->GetScannerControlCfgDao()->Add(cfg);
|
||
ConfigManager::GetInstance()->GetScannerControlCfgDao()->Maintain(cfg);
|
||
ConfigManager::GetInstance()->GetScannerControlCfgs()->push_back(cfg);
|
||
(*scannerControlCfgsMap)[cfg->m_SeqNo] = cfg;
|
||
flag++;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (card_num == 0)
|
||
{
|
||
g_log->TraceError(_(u8"没有振镜控制卡").c_str());
|
||
m_InitErrorInfos.push_back(_(u8"没有振镜控制卡").c_str());
|
||
return false;
|
||
}
|
||
|
||
|
||
for (map<int, ScannerControlCfg*>::iterator sit = scannerControlCfgsMap->begin(); sit != scannerControlCfgsMap->end(); sit++) {
|
||
ScannerControlCfg* cfg = sit->second;
|
||
if (m_IOCfgWrapper->m_LaserIOMap.find(cfg->m_SeqNo) != m_IOCfgWrapper->m_LaserIOMap.end()) {
|
||
cfg->m_LaserRed = m_IOCfgWrapper->m_LaserIOMap[cfg->m_SeqNo]->m_LaserRed;
|
||
cfg->m_LaserStart = m_IOCfgWrapper->m_LaserIOMap[cfg->m_SeqNo]->m_LaserStart;
|
||
cfg->m_LaserEnable = m_IOCfgWrapper->m_LaserIOMap[cfg->m_SeqNo]->m_LaserEnable;
|
||
}
|
||
Scanner* scanner = new RTC5Scanner(cfg);
|
||
|
||
|
||
if (scanner->Init())
|
||
{
|
||
ConfigManager::GetInstance()->GetMatchScannerControlCfg()->push_back(cfg);
|
||
m_scan.push_back(scanner);
|
||
}
|
||
else
|
||
{
|
||
delete scanner;
|
||
scanner = NULL;
|
||
char buffer[256];
|
||
sprintf_s(buffer, sizeof(buffer), _(u8"振镜卡 %d 初始化失败").c_str(), cfg->m_SeqNo);
|
||
g_log->TraceError(buffer);
|
||
m_InitErrorInfos.push_back(buffer);
|
||
}
|
||
LaserParam* param = new LaserParam();
|
||
g_SystemInfo->m_StateBean.laserParams.push_back(param);
|
||
}
|
||
|
||
|
||
if (m_scan.empty())
|
||
{
|
||
g_log->TraceError(_(u8"配置有误，不能生成振镜控制模块").c_str());
|
||
m_InitErrorInfos.push_back(_(u8"配置有误，不能生成振镜控制模块").c_str());
|
||
rel = false;
|
||
}
|
||
else {
|
||
if (m_scan.size() == 4)
|
||
{
|
||
m_scan[0]->SetPairScan(m_scan[1]);
|
||
m_scan[1]->SetPairScan(m_scan[0]);
|
||
m_scan[2]->SetPairScan(m_scan[3]);
|
||
m_scan[3]->SetPairScan(m_scan[2]);
|
||
}
|
||
}
|
||
|
||
//#endif
|
||
|
||
return rel;
|
||
}
|
||
|
||
DWORD WINAPI ScannerCtrl::PrintProc(thisClass* _this)
|
||
{
|
||
if (_this != nullptr) {
|
||
_this->PrintRun();
|
||
_this->CtrlIoWhenExit();
|
||
if (!BaseCtrl::IsPauseStanBy()) {
|
||
_this->m_IOCfgWrapper->m_PrintDoorLock->SetActive(false);
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void ScannerCtrl::PrintRun()
|
||
{
|
||
bool startAfterPause = false;
|
||
if (BaseCtrl::IsPauseStanBy()) {
|
||
startAfterPause = true;
|
||
}
|
||
if (!startAfterPause) {
|
||
m_job_controller->GetJob()->m_TaskId = StringHelper::GenerateUUID();
|
||
}
|
||
BaseCtrl::SetState(BaseCtrl::PREPRINT);
|
||
BaseCtrl::SetPauseState(BaseCtrl::NoPause);
|
||
BaseCtrl::SetPreState(BaseCtrl::CheckIO);
|
||
|
||
|
||
m_IOCfgWrapper->m_PrintDoorLock->SetActive(true);
|
||
|
||
IOCfg* servoMotor = m_IOCfgWrapper->m_ServoMotor;
|
||
if (!servoMotor->IsActive()) {
|
||
servoMotor->SetActive(true);
|
||
g_Toast->AddToast(new ToastBean(_(u8"正在打开伺服驱动").c_str(), 3000, ImVec4(1, 0.4f, 0, 1)));
|
||
Sleep(3000);
|
||
}
|
||
|
||
SignalService& alarmService = SignalService::GetInstance();
|
||
|
||
//if (!m_Machine->CheckPrintMoldReady() && !g_isDebug) { //wxxtest
|
||
// g_Toast->AddToast(new ToastBean(_(u8"执行失败：缸体未在打印位装载").c_str(), 3000, Toast::COLOR_RED));
|
||
// BaseCtrl::SetState(BaseCtrl::STANDBY);
|
||
// return;
|
||
//}
|
||
|
||
//检测振镜检测红光
|
||
vector<ScannerControlCfg*>* laserCfgs = ConfigManager::GetInstance()->GetMatchScannerControlCfg();
|
||
for (size_t laserIndex = 0; laserIndex < laserCfgs->size();laserIndex++) {
|
||
ScannerControlCfg* laserCfg = (*laserCfgs)[laserIndex];
|
||
if (laserCfg->m_LaserRed && laserCfg->m_LaserRed->IsActive()) {
|
||
laserCfg->m_LaserRed->SetActive(false);
|
||
}
|
||
}
|
||
|
||
bool isHeatingActive = false;
|
||
if (m_IOCfgWrapper->m_Heating) {
|
||
isHeatingActive = m_IOCfgWrapper->m_Heating->IsActive();
|
||
}
|
||
if (!m_job_controller->GetJob()->m_IsAutoCtrl && m_job_controller->GetJob()->m_AutoHeatingScanner) {
|
||
if (m_IOCfgWrapper->m_Heating) {
|
||
m_IOCfgWrapper->m_Heating->SetActive(true);
|
||
}
|
||
Sleep(500);
|
||
m_MachineCtrl->StopLaser(true);
|
||
if (!m_IOCfgWrapper->m_Laser->IsActive()) {
|
||
m_IOCfgWrapper->m_Laser->SetActive(true);
|
||
Sleep(10000);
|
||
}
|
||
vector<ScannerControlCfg*>* laserCfgs = ConfigManager::GetInstance()->GetMatchScannerControlCfg();
|
||
for (size_t laserIndex = 0; laserIndex < laserCfgs->size(); laserIndex++) {
|
||
ScannerControlCfg* laserCfg = (*laserCfgs)[laserIndex];
|
||
if (laserCfg->m_LaserRed && !laserCfg->m_LaserRed->IsActive()) {
|
||
laserCfg->m_LaserRed->SetActive(true);
|
||
}
|
||
}
|
||
Sleep(500);
|
||
for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
|
||
Scanner* scanner = m_scan[scanIndex];
|
||
scanner->StartHeatingScannerTest();
|
||
}
|
||
}
|
||
|
||
|
||
if (!m_RunCfg->m_IsDebugMode) {
|
||
if (!ReadyPrint(startAfterPause)) {
|
||
for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
|
||
Scanner* scanner = m_scan[scanIndex];
|
||
scanner->WaitHeatingScanner();
|
||
}
|
||
|
||
for (size_t laserIndex = 0; laserIndex < laserCfgs->size(); laserIndex++) {
|
||
ScannerControlCfg* laserCfg = (*laserCfgs)[laserIndex];
|
||
if (laserCfg->m_LaserRed && laserCfg->m_LaserRed->IsActive()) {
|
||
laserCfg->m_LaserRed->SetActive(false);
|
||
}
|
||
}
|
||
if (!isHeatingActive) {
|
||
if (m_IOCfgWrapper->m_Heating) {
|
||
m_IOCfgWrapper->m_Heating->SetActive(false);
|
||
Sleep(500);
|
||
}
|
||
}
|
||
BaseCtrl::SetState(BaseCtrl::STANDBY);
|
||
|
||
return;
|
||
}
|
||
|
||
if (alarmService.CheckAlarmAfterDeoxygen())
|
||
{
|
||
for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
|
||
Scanner* scanner = m_scan[scanIndex];
|
||
scanner->WaitHeatingScanner();
|
||
}
|
||
|
||
for (size_t laserIndex = 0; laserIndex < laserCfgs->size(); laserIndex++) {
|
||
ScannerControlCfg* laserCfg = (*laserCfgs)[laserIndex];
|
||
if (laserCfg->m_LaserRed && laserCfg->m_LaserRed->IsActive()) {
|
||
laserCfg->m_LaserRed->SetActive(false);
|
||
}
|
||
}
|
||
if (!isHeatingActive) {
|
||
if (m_IOCfgWrapper->m_Heating) {
|
||
m_IOCfgWrapper->m_Heating->SetActive(false);
|
||
Sleep(500);
|
||
}
|
||
}
|
||
BaseCtrl::SetState(BaseCtrl::STANDBY);
|
||
return;
|
||
}
|
||
}
|
||
|
||
|
||
for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
|
||
Scanner* scanner = m_scan[scanIndex];
|
||
scanner->WaitHeatingScanner();
|
||
}
|
||
|
||
for (size_t laserIndex = 0; laserIndex < laserCfgs->size(); laserIndex++) {
|
||
ScannerControlCfg* laserCfg = (*laserCfgs)[laserIndex];
|
||
if (laserCfg->m_LaserRed && laserCfg->m_LaserRed->IsActive()) {
|
||
laserCfg->m_LaserRed->SetActive(false);
|
||
}
|
||
}
|
||
if (!isHeatingActive) {
|
||
if (m_IOCfgWrapper->m_Heating) {
|
||
m_IOCfgWrapper->m_Heating->SetActive(false);
|
||
Sleep(500);
|
||
}
|
||
}
|
||
|
||
if (m_IOCfgWrapper->m_Heating && m_IOCfgWrapper->m_Heating->IsActive())
|
||
{
|
||
TempStat ts;
|
||
int count = 0;
|
||
float platformTemp = 0.0f;
|
||
float platformTempSettingValue = 0.0f;
|
||
while (BaseCtrl::IsPrePrint()) {
|
||
if (!m_IOCfgWrapper->m_Heating->IsActive()) {
|
||
break;
|
||
}
|
||
EnterCriticalSection(&g_SystemInfo->m_InfoCs);
|
||
platformTemp = g_SystemInfo->m_PlatformTemp;
|
||
platformTempSettingValue = g_SystemInfo->m_PlatformTempSettingValue;
|
||
LeaveCriticalSection(&g_SystemInfo->m_InfoCs);
|
||
|
||
if ((platformTempSettingValue - platformTemp) < 3.0f) {
|
||
break;
|
||
}
|
||
else {
|
||
if ((count % 20) == 0) {
|
||
g_Toast->AddToast(new ToastBean(_(u8"正在等待基板预热").c_str(), 3000, Toast::COLOR_ORANGE));
|
||
}
|
||
}
|
||
count++;
|
||
if (count > 100000)count = 0;
|
||
Sleep(500);
|
||
}
|
||
}
|
||
if (!BaseCtrl::IsPrePrint()) {
|
||
BaseCtrl::SetState(BaseCtrl::STANDBY);
|
||
return;
|
||
}
|
||
|
||
if (!m_job_controller->GetJob()->m_IsAutoCtrl) {
|
||
BaseCtrl::SetPreState(BaseCtrl::WaitConfirm);
|
||
bool isconfirm = false;
|
||
while (BaseCtrl::IsPrePrint())
|
||
{
|
||
if (BaseCtrl::GetPreState() == CancelConfirm) {
|
||
break;
|
||
}
|
||
if (BaseCtrl::GetPreState() == SummitConfirm) {
|
||
isconfirm = true;
|
||
break;
|
||
}
|
||
Sleep(300);
|
||
}
|
||
|
||
if (!isconfirm) {
|
||
BaseCtrl::SetState(BaseCtrl::STANDBY);
|
||
BaseCtrl::SetPreState(BaseCtrl::NonePre);
|
||
return;
|
||
}
|
||
}
|
||
|
||
BaseCtrl::SetPreState(BaseCtrl::PreFinished);
|
||
if (!BaseCtrl::IsPrePrint()) {
|
||
BaseCtrl::SetState(BaseCtrl::STANDBY);
|
||
BaseCtrl::SetPreState(BaseCtrl::NonePre);
|
||
return;
|
||
}
|
||
StopHeatingMotion(true);
|
||
|
||
m_MachineCtrl->StartLaser(true);
|
||
//m_gc->StartLaser(true);
|
||
if (!BaseCtrl::IsPrePrint()) {
|
||
BaseCtrl::SetState(BaseCtrl::STANDBY);
|
||
BaseCtrl::SetPreState(BaseCtrl::NonePre);
|
||
return;
|
||
}
|
||
g_SystemInfo->m_AutoPrintCtrlState = AutoPrint;
|
||
m_job_controller->GetJob()->m_BeginPrintTime = GetTickCount64();
|
||
if (m_job_controller->GetJob()->m_FirstStartTime == 0L)m_job_controller->GetJob()->m_FirstStartTime = GetTickCount64();
|
||
JobBean* jobBean = m_job_controller->GetJob()->GetJobbean();
|
||
jobBean->m_TaskID = m_job_controller->GetJob()->m_TaskId;
|
||
m_job_controller->GetJob()->UpdateJobBeanWhenStart();
|
||
|
||
if (!jobBean->m_IsContinue) {
|
||
g_SystemInfo->LockInfo();
|
||
jobBean->m_StartMoldPos = g_SystemInfo->m_MoldMainPos;
|
||
g_SystemInfo->UnlockInfo();
|
||
jobBean->m_FirstStartIndex = m_job_controller->GetJob()->GetStartIndex();
|
||
}
|
||
g_log->m_LogDao->LogJobStart(jobBean);
|
||
if (m_ScannerPowerClient)m_ScannerPowerClient->SetJobId(jobBean->m_Id);
|
||
|
||
BaseCtrl::SetState(BaseCtrl::PRINTING);
|
||
for (size_t i = 0; i < m_scan.size(); i++)
|
||
{
|
||
m_scan[i]->SetAutoUpdateScanInfo(false);
|
||
m_scan[i]->ResetDefocus();
|
||
m_scan[i]->m_IsOrderSeqV2 = m_job_controller->GetJob()->GetMetaData()->m_IsScanOrderSeqV2;
|
||
}
|
||
Sleep(500);
|
||
DispatchDataBlock();
|
||
|
||
Sleep(100);
|
||
for (size_t i = 0; i < m_scan.size(); i++)
|
||
{
|
||
m_scan[i]->SetAutoUpdateScanInfo(true);
|
||
m_scan[i]->ResetDefocus();
|
||
}
|
||
|
||
if (m_ServoManager)m_ServoManager->ResetLogServo();
|
||
g_log->m_LogDao->ResetImageDB();
|
||
if (BaseCtrl::IsFinish()) {
|
||
g_SystemInfo->m_AutoPrintCtrlState = NoAuto;
|
||
if (m_RemoteClient)m_RemoteClient->SetNeedSendFinish(true);
|
||
m_ShowFinishReport = true;
|
||
CtrlWhenStop();
|
||
m_job_controller->GetJob()->UpdateJobBeanWhenStop();
|
||
g_SystemInfo->m_StateBean.layerIndex = 0;
|
||
m_IOCfgWrapper->m_PrintDoorLock->SetActive(false);
|
||
}
|
||
else if(BaseCtrl::IsPause()){
|
||
m_job_controller->GetJob()->GetJobbean()->m_IsContinue = true;
|
||
m_job_controller->GetJob()->GetJobbean()->m_PrintSecond = m_job_controller->GetJob()->GetJobbean()->m_PrintSecond + (int)m_job_controller->GetJob()->GetJobbean()->m_EveryPrintedTime;
|
||
if (m_RunCfg->m_PrintRestEnable) {
|
||
g_SystemInfo->m_AutoPrintCtrlState = AutoPause;
|
||
m_job_controller->GetJob()->m_AutoPauseTime = GetTickCount64();
|
||
}
|
||
BaseCtrl::SetState(BaseCtrl::STANDBY_PAUSE);
|
||
}
|
||
else if (BaseCtrl::IsStop()) {
|
||
m_job_controller->GetJob()->UpdateJobBeanWhenStop();
|
||
g_SystemInfo->m_StateBean.layerIndex = 0;
|
||
CtrlWhenStop();
|
||
m_IOCfgWrapper->m_PrintDoorLock->SetActive(false);
|
||
BaseCtrl::SetState(BaseCtrl::STANDBY_STOP);
|
||
}
|
||
else {
|
||
BaseCtrl::SetState(BaseCtrl::STANDBY);
|
||
}
|
||
BaseCtrl::SetPreState(BaseCtrl::NonePre);
|
||
CtrlIoWhenExit();
|
||
|
||
}
|
||
|
||
|
||
bool ScannerCtrl::ReadyPrint(bool startAfterPause)
|
||
{
|
||
//DWORD startTick = GetTickCount64();
|
||
unsigned int deoxytime = 0;
|
||
bool rel = false;
|
||
rel=m_PurifierClient->HandleReadyPrint(startAfterPause, deoxytime);
|
||
//DWORD stoptick = GetTickCount64();
|
||
|
||
FileProcessor* job = m_job_controller->GetJob();
|
||
if (job) {
|
||
job->GetJobbean()->m_DeoxygenSecond = deoxytime;
|
||
}
|
||
return rel;
|
||
}
|
||
|
||
void ScannerCtrl::StopRedTest()
|
||
{
|
||
PrintState printStateTemp = BaseCtrl::GetState();
|
||
BaseCtrl::SetState(BaseCtrl::STOP);
|
||
EnterCriticalSection(&m_LayerTestCs);
|
||
if (m_RedPrintTestThread != INVALID_HANDLE_VALUE) {
|
||
for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
|
||
Scanner* scanner = m_scan[scanIndex];
|
||
scanner->StopWork();
|
||
}
|
||
if (WaitForSingleObject(m_RedPrintTestThread, 1000) == WAIT_TIMEOUT) {
|
||
TerminateThread(m_RedPrintTestThread, 0);
|
||
}
|
||
CloseHandle(m_RedPrintTestThread);
|
||
m_RedPrintTestThread = INVALID_HANDLE_VALUE;
|
||
}
|
||
LeaveCriticalSection(&m_LayerTestCs);
|
||
BaseCtrl::SetState(printStateTemp);
|
||
|
||
for (size_t i = 0; i < m_scan.size();i++) {
|
||
m_scan[i]->Clean();
|
||
}
|
||
}
|
||
|
||
DWORD WINAPI ScannerCtrl::RedPrintTestProc(thisClass* _this)
|
||
{
|
||
if (_this)
|
||
{
|
||
_this->DispatchTestDataBlock();
|
||
EnterCriticalSection(&_this->m_LayerTestCs);
|
||
if (_this->m_RedPrintTestThread != INVALID_HANDLE_VALUE) {
|
||
CloseHandle(_this->m_RedPrintTestThread);
|
||
_this->m_RedPrintTestThread = INVALID_HANDLE_VALUE;
|
||
}
|
||
LeaveCriticalSection(&_this->m_LayerTestCs);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
bool ScannerCtrl::BeginWork()
|
||
{
|
||
StopRedTest();
|
||
for (size_t i = 0; i < m_scan.size(); i++) {
|
||
m_scan[i]->StopDebugTest();
|
||
}
|
||
if (m_scan.size() == 0)
|
||
{
|
||
ToastBean* bean = new ToastBean(_(u8"没有振镜控制卡").c_str(), 3000);
|
||
g_Toast->AddToast(bean);
|
||
return false;
|
||
}
|
||
//是否达到打印条件
|
||
/*if (m_AlarmCfgWrapper->m_CoverBreak)m_AlarmCfgWrapper->m_CoverBreak->m_IsAlarm = false;
|
||
if(m_AlarmCfgWrapper->m_MoldMotionTransferAlarm)m_AlarmCfgWrapper->m_MoldMotionTransferAlarm->m_IsAlarm = false;
|
||
if (m_AlarmCfgWrapper->m_PowderMotionTransferAlarm)m_AlarmCfgWrapper->m_PowderMotionTransferAlarm->m_IsAlarm = false;
|
||
*/
|
||
SignalService::GetInstance().ResetRelateCoverAlarm();
|
||
if (!m_job_controller || !m_job_controller->GetJob()) {
|
||
ToastBean* bean = new ToastBean(_(u8"没有可打印的任务").c_str(),3000);
|
||
g_Toast->AddToast(bean);
|
||
return false;
|
||
}
|
||
|
||
if (!m_job_controller->CheckDiskSpace())
|
||
{
|
||
char buffer[123];
|
||
sprintf_s(buffer, sizeof(buffer), _(u8"任务执行失败：%s空间不足，请清理").c_str(), g_AppDisk.c_str());
|
||
ToastBean* bean = new ToastBean(buffer, 5000, Toast::COLOR_RED);
|
||
g_Toast->AddToast(bean);
|
||
return false;
|
||
}
|
||
|
||
|
||
if (!g_isDebug) {
|
||
vector<string> ei;
|
||
m_job_controller->GetJob()->GetMetaData()->GetErrorInfo(ei);
|
||
if (!ei.empty()) {
|
||
g_Toast->AddToast(new ToastBean(ei[0], 5000, Toast::COLOR_RED));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
if (m_scan.size()==1)
|
||
{
|
||
Scanner* sc = m_scan[0];
|
||
if (!sc) {
|
||
return false;
|
||
}
|
||
vector<MetaData::Part*> &partVec = m_job_controller->GetJob()->GetMetaData()->GetPartVec();
|
||
CorrectParamCfg* correctCfg = &sc->GetConfig()->m_ScanCfgWrapper.m_CorrectParamCfg;
|
||
char buffer[1024];
|
||
bool hasOutLimit = false;
|
||
for (size_t i = 0; i < partVec.size(); ++i)
|
||
{
|
||
MetaData::Part* part = partVec[i];
|
||
if (!part->print_enable)continue;
|
||
|
||
double corxmin = (part->dimensions->xmin + part->partPosBean.m_XOffset );
|
||
double corxmax = (part->dimensions->xmax + part->partPosBean.m_XOffset);
|
||
double corymin = (part->dimensions->ymin + part->partPosBean.m_YOffset );
|
||
double corymxn = (part->dimensions->ymax + part->partPosBean.m_YOffset);
|
||
if (corxmin<correctCfg->m_xmeasure_min || corxmax>correctCfg->m_xmeasure_max) {
|
||
sprintf_s(buffer, sizeof(buffer), _(u8"零件：%s X方向超出可打印范围").c_str(), part->name.c_str());
|
||
hasOutLimit = true;
|
||
break;
|
||
}
|
||
if (corymin<correctCfg->m_ymeasure_min || corymxn>correctCfg->m_ymeasure_max) {
|
||
sprintf_s(buffer, sizeof(buffer), _(u8"零件：%s Y方向超出可打印范围").c_str(), part->name.c_str());
|
||
hasOutLimit = true;
|
||
break;
|
||
}
|
||
}
|
||
if (hasOutLimit) {
|
||
ToastBean* bean = new ToastBean(buffer, 5000, Toast::COLOR_RED);
|
||
g_Toast->AddToast(bean);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
if (!SignalService::GetInstance().CheckAlarmBeforeDeoxygen())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
|
||
if (!m_RunCfg->m_HadSetBasePlatformPoint && !m_RunCfg->m_IsDebugMode) {
|
||
ToastBean* bean = new ToastBean(_(u8"请先执行基板缸平面位置确定").c_str(), 5000, Toast::COLOR_RED);
|
||
g_Toast->AddToast(bean);
|
||
return false;
|
||
}
|
||
|
||
if (!BaseCtrl::IsStandBy()) {
|
||
ToastBean* bean = new ToastBean(_(u8"请等待系统就绪后再开始任务").c_str(), 3000);
|
||
g_Toast->AddToast(bean);
|
||
return false;
|
||
}
|
||
|
||
if (!g_isDebug) {
|
||
if (!m_Machine->CheckPrintHigh(m_job_controller->GetJob()->GetJobPrintHigh()))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
m_IOCfgWrapper->SetAutoCtrlHeating(false);
|
||
|
||
m_print_thread = AtlCreateThread(PrintProc, this);
|
||
return true;
|
||
}
|
||
|
||
bool ScannerCtrl::PauseWork()
|
||
{
|
||
m_PauseMsg = "";
|
||
SignalService::GetInstance().ResetRelateCoverAlarm();
|
||
if (!m_job_controller || !m_job_controller->GetJob()) {
|
||
ToastBean* bean = new ToastBean(_(u8"没有可暂停的打印任务").c_str(), 3000);
|
||
g_Toast->AddToast(bean);
|
||
m_PauseMsg = _(u8"没有可暂停的打印任务").c_str();
|
||
return false;
|
||
}
|
||
m_job_controller->GetJob()->m_IsAutoCtrl = false;
|
||
g_SystemInfo->m_AutoPrintCtrlState = NoAuto;
|
||
if (BaseCtrl::IsStandBy()) {
|
||
m_PauseMsg = _(u8"就绪状态不能暂停").c_str();
|
||
return false;
|
||
}
|
||
BaseCtrl::SetState(BaseCtrl::PAUSE);
|
||
BaseCtrl::SetPreState(BaseCtrl::NonePre);
|
||
g_Toast->AddToast(new ToastBean(_(u8"正在暂停任务").c_str(),3000,Toast::COLOR_ORANGE));
|
||
g_log->TraceInfo(_(u8"暂停任务").c_str());
|
||
return true;
|
||
}
|
||
|
||
void ScannerCtrl::PauseAuto()
|
||
{
|
||
SignalService::GetInstance().ResetRelateCoverAlarm();
|
||
|
||
if (!m_job_controller || !m_job_controller->GetJob()) {
|
||
ToastBean* bean = new ToastBean(_(u8"没有可暂停的打印任务").c_str(), 3000);
|
||
g_Toast->AddToast(bean);
|
||
return ;
|
||
}
|
||
|
||
m_job_controller->GetJob()->m_IsAutoCtrl = true;
|
||
if (BaseCtrl::IsStandBy()) {
|
||
return ;
|
||
}
|
||
BaseCtrl::SetState(BaseCtrl::PAUSE);
|
||
BaseCtrl::SetPreState(BaseCtrl::NonePre);
|
||
g_Toast->AddToast(new ToastBean(_(u8"正在暂停任务").c_str(), 3000, Toast::COLOR_ORANGE));
|
||
g_log->TraceInfo(_(u8"自动暂停任务").c_str());
|
||
}
|
||
|
||
bool ScannerCtrl::StopWork()
|
||
{
|
||
|
||
m_StopMsg = "";
|
||
SignalService::GetInstance().ResetRelateCoverAlarm();
|
||
if (!m_job_controller || !m_job_controller->GetJob()) {
|
||
ToastBean* bean = new ToastBean(_(u8"没有可停止的打印任务").c_str(), 3000);
|
||
g_Toast->AddToast(bean);
|
||
m_StopMsg = _(u8"没有可停止的打印任务").c_str();
|
||
return false;
|
||
}
|
||
m_job_controller->GetJob()->m_IsAutoCtrl = false;
|
||
g_SystemInfo->m_AutoPrintCtrlState = NoAuto;
|
||
BaseCtrl::SetPauseState(BaseCtrl::NoPause);
|
||
if (BaseCtrl::IsStandBy()) {
|
||
m_job_controller->GetJob()->SetStartIndex(0);
|
||
m_job_controller->GetJob()->GetJobbean()->m_IsContinue = false;
|
||
CtrlWhenStop();
|
||
m_job_controller->GetJob()->UpdateJobBeanWhenStop();
|
||
BaseCtrl::SetState(BaseCtrl::STANDBY_STOP);
|
||
return true;
|
||
}
|
||
|
||
BaseCtrl::SetState(BaseCtrl::STOP);
|
||
for (size_t i = 0; i < m_scan.size(); i++) {
|
||
m_scan[i]->StopWork();
|
||
}
|
||
BaseCtrl::SetPreState(BaseCtrl::NonePre);
|
||
g_Toast->AddToast(new ToastBean(_(u8"正在停止任务").c_str(), 3000, Toast::COLOR_ORANGE));
|
||
g_log->TraceKeyInfo(_(u8"正在停止任务").c_str());
|
||
return true;
|
||
}
|
||
|
||
bool ScannerCtrl::IsTestLayerEnable()
|
||
{
|
||
return (m_RedPrintTestThread == INVALID_HANDLE_VALUE);
|
||
}
|
||
|
||
void ScannerCtrl::TestLayer()
|
||
{
|
||
if (m_RedPrintTestThread != INVALID_HANDLE_VALUE)
|
||
return;
|
||
|
||
if (m_scan.size() == 0)
|
||
{
|
||
ToastBean* bean = new ToastBean(_(u8"没有振镜控制卡").c_str(), 3000);
|
||
g_Toast->AddToast(bean);
|
||
return;
|
||
}
|
||
|
||
m_RedPrintTestThread = AtlCreateThread(RedPrintTestProc, this);
|
||
}
|
||
|
||
void ScannerCtrl::CtrlIoWhenExit() {
|
||
|
||
m_PurifierClient->ResetSlowWind();
|
||
}
|
||
|
||
void ScannerCtrl::CtrlWhenStop()
|
||
{
|
||
m_MachineCtrl->StopLaser(true);
|
||
if (BaseCtrl::IsFinish()) {
|
||
m_IOCfgWrapper->SetAutoCtrlHeating(true);
|
||
m_PurifierClient->HandlePrintFinish();
|
||
|
||
if (m_RunCfg->m_IsAutoReleasePressureWhenFinish) {
|
||
m_PressureCtrlFlag = true;
|
||
m_PressureThread = AtlCreateThread(ReleasePressureProc, this);
|
||
}
|
||
if (m_RunCfg->m_AutoShutdownPower) {
|
||
m_IOCfgWrapper->m_Laser->SetActive(false);
|
||
}
|
||
|
||
}
|
||
m_PurifierClient->HandlePrintStop();
|
||
CtrlIoWhenExit();
|
||
}
|
||
|
||
void ScannerCtrl::GetInitErrorInfos(vector<string>& vec)
|
||
{
|
||
for (size_t i = 0; i < m_InitErrorInfos.size(); ++i) {
|
||
vec.push_back(m_InitErrorInfos[i]);
|
||
}
|
||
}
|
||
|
||
void ScannerCtrl::DispatchDataBlock()
|
||
{
|
||
if (!m_job_controller)return;
|
||
FileProcessor* job = m_job_controller->GetJob();
|
||
if (job == NULL) {
|
||
g_Toast->AddToast(new ToastBean(_(u8"没有可打印的任务").c_str(), 3000));
|
||
return;
|
||
}
|
||
MetaData* job_meta_data = job->GetMetaData();
|
||
if (job_meta_data == NULL)return;
|
||
|
||
size_t layerindex = job->GetStartIndex();
|
||
|
||
//m_Camera->SetDemandCatpure(true); //wxxtest
|
||
bool nodebug = !g_isDebug;
|
||
|
||
//job->UpdateJobBeanWhenStart();
|
||
JobBean* jobBean = job->GetJobbean();
|
||
// g_log->m_LogDao->LogJobStart(jobBean);
|
||
//g_log->m_LogDao->LogImageBeforePrint(jobBean->m_Id, jobBean->m_IsContinue);
|
||
vector<MetaData::Layer*> &layers = job_meta_data->GetLayersVec();
|
||
//unsigned int memorySize = GetMemorySize();
|
||
g_SystemInfo->m_StateBean.maxLayerIndex = job->GetLayerCount();
|
||
g_SystemInfo->m_StateBean.layerThick = job->GetLayerThickness();
|
||
|
||
uint32_t startPos = jobBean->m_StartMoldPos;
|
||
uint32_t firstStartIndex = jobBean->m_FirstStartIndex;
|
||
int fix = 0;
|
||
if (firstStartIndex < layers.size())
|
||
{
|
||
fix = startPos - layers[firstStartIndex]->z;
|
||
}
|
||
for (size_t i = 0; i < layers.size(); i++) {
|
||
layers[i]->realZ = layers[i]->z + fix;
|
||
}
|
||
|
||
job_meta_data->CalcRealPower();
|
||
|
||
job_meta_data->ReCalcEvaTime();
|
||
g_SystemInfo->m_StateBean.jobCostMil = job_meta_data->GetEvaTime();
|
||
|
||
//if (job->m_StartTime == 0L)job->m_StartTime = GetTickCount64();
|
||
bool isbreak = false;
|
||
|
||
map<MetaData::DataBlock*, int>* DBRefScanLaser = job_meta_data->GetDBRefScanLaser();
|
||
map<MetaData::DataBlock*, int>::iterator dbsIt;
|
||
map<int, Scanner*> scanMap;
|
||
for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
|
||
Scanner* scanner = m_scan[scanIndex];
|
||
scanner->m_JobStartTime = job->m_FirstStartTime;
|
||
scanMap[scanner->GetConfig()->m_SeqNo] = scanner;
|
||
}
|
||
|
||
m_DownSkinStopFlag = 1;
|
||
m_IsDownSkinContinue = false;
|
||
|
||
bool isCoverFirst = true;
|
||
//short lastPowderGrid = 0;
|
||
|
||
int linearAccDis = 0;
|
||
float lastLinearPos = 0.0f;
|
||
for (; layerindex < layers.size(); layerindex++) {//遍历层
|
||
bool hasDownSkin = false;
|
||
if (BaseCtrl::IsStop() || BaseCtrl::IsPause()) {
|
||
if (BaseCtrl::IsStop()) {
|
||
job->SetStartIndex(0);
|
||
}
|
||
if (BaseCtrl::IsPause()) {
|
||
job->SetStartIndex(layerindex);
|
||
}
|
||
isbreak = true;
|
||
break;
|
||
}
|
||
|
||
if (!job_meta_data->LoadLayerByIndex(layerindex)) continue;
|
||
job_meta_data->CalcRemainTime(layerindex);
|
||
g_SystemInfo->m_StateBean.layerIndex = layerindex;
|
||
g_SystemInfo->m_StateBean.jobProgress = (float)layerindex / (float)g_SystemInfo->m_StateBean.maxLayerIndex;
|
||
MetaData::Layer* layer = layers[layerindex];
|
||
bool hasPrintPart = false;
|
||
for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
|
||
MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
|
||
if (!datablock)continue;
|
||
MetaData::Part* part = job_meta_data->GetPart(datablock->references->part);
|
||
if (part) {
|
||
if (part->print_enable) {
|
||
hasPrintPart = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (!hasPrintPart)break;
|
||
|
||
// if (!g_isDebug) {
|
||
int ptickcount = 0;
|
||
while (m_MachineCtrl->IsCovering() && IsStart() && !g_isDebug) {
|
||
ptickcount++;
|
||
Sleep(20);
|
||
}
|
||
|
||
//AxisLog* lc = NULL;
|
||
if (m_ServoManager) {
|
||
m_ServoManager->StartLog(jobBean->m_Id, layerindex, m_CoverCfg->m_CoverDirection);
|
||
//lc = new AxisLog(jobBean->m_Id, layerindex, m_CoverCfg->m_CoverDirection);
|
||
//if (m_ServoManager)m_ServoManager->StartLog(lc);
|
||
}
|
||
|
||
bool windalaemEnable = m_AlarmCfgWrapper->m_WindOverLimitAlarm->m_IsEnable;
|
||
bool isSlowWindSet = false;
|
||
if (m_ExtCfg->m_AutoCoverSlowWind && m_PurifierClient->IsWindActive())
|
||
{
|
||
if(m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d开始铺粉降风速").c_str(), layerindex + 1);
|
||
if (windalaemEnable)m_AlarmCfgWrapper->m_WindOverLimitAlarm->m_IsEnable = false;
|
||
m_PurifierClient->SetCoverWind(true);
|
||
isSlowWindSet = true;
|
||
int windcount = 0;
|
||
while (IsStart() && windcount < 300) {
|
||
if (m_PurifierClient->IsCoverWindSlow()) {
|
||
break;
|
||
}
|
||
windcount++;
|
||
Sleep(100);
|
||
}
|
||
if (m_RunCfg->m_UseCoverWindSignal)
|
||
{
|
||
m_PurifierClient->ResetSlwoWindSignal(true);
|
||
}
|
||
}
|
||
|
||
bool isOK = true;
|
||
int retry = m_RecoatCheckCfg->m_RetryTimes;
|
||
float layerThick = layer->layer_thickness;
|
||
|
||
g_SystemInfo->LockInfo();
|
||
int32_t premoldPos = g_SystemInfo->m_MoldMainPos;
|
||
g_SystemInfo->UnlockInfo();
|
||
|
||
float layerYmin = FLT_MAX;
|
||
float layerYmax = -FLT_MAX;
|
||
for (map<int, MetaData::Part*>::iterator pit = layer->parts.begin(); pit != layer->parts.end(); pit++) {
|
||
MetaData::Part* tempPart = pit->second;
|
||
if (!tempPart->print_enable)continue;
|
||
if (layerYmin > tempPart->layerDimensions->ymin)layerYmin = tempPart->layerDimensions->ymin;
|
||
if (layerYmax < tempPart->layerDimensions->ymax)layerYmax = tempPart->layerDimensions->ymax;
|
||
}
|
||
|
||
if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d开始铺粉").c_str(), layerindex + 1);
|
||
do {
|
||
if (BaseCtrl::IsStop() || BaseCtrl::IsPause()) {
|
||
if (BaseCtrl::IsStop()) {
|
||
job->SetStartIndex(0);
|
||
}
|
||
if (BaseCtrl::IsPause()) {
|
||
job->SetStartIndex(layerindex);
|
||
}
|
||
isbreak = true;
|
||
break;
|
||
}
|
||
|
||
m_MachineCtrl->ResetCoverFinishedCanPrint();
|
||
|
||
if (m_RunCfg->m_SmartCoverEnable) {
|
||
m_MachineCtrl->ExecuteDataSizeY(ceil(layerYmin) * 1000, ceil(layerYmax) * 1000);
|
||
}
|
||
|
||
short powderGrid = ceil((float)layer->powder / m_PowderEstimateCfg->m_PowderPerGrid);
|
||
if (isCoverFirst) {
|
||
m_MachineCtrl->ExecuteCover(layerThick, powderGrid, false, isCoverFirst);
|
||
if (isCoverFirst) {
|
||
isCoverFirst = !isCoverFirst;
|
||
}
|
||
}
|
||
else {
|
||
m_MachineCtrl->ExecuteCover(layerThick, powderGrid, false, false);
|
||
}
|
||
|
||
//lastPowderGrid = powderGrid;
|
||
Sleep(500);
|
||
|
||
while (!m_MachineCtrl->IsCoverFinishedCanPrint() && !g_isDebug && IsStart()) {
|
||
if (m_MachineCtrl->IsCoverFinishedCanPrint()) {
|
||
break;
|
||
}
|
||
Sleep(10);
|
||
}
|
||
|
||
/*while (m_MachineCtrl->IsCovering() && !g_isDebug && IsStart()) {
|
||
if (!m_MachineCtrl->IsCovering()) {
|
||
break;
|
||
}
|
||
Sleep(10);
|
||
}*/
|
||
Sleep(100);
|
||
|
||
m_MachineCtrl->ResetCoverFinishedCanPrint();
|
||
if (/*m_RecoatCheck == nullptr ||*/ !m_RecoatCheckCfg->m_Enable || (layerindex < 5) || m_CoverCfg->IsNoCover())
|
||
break;
|
||
if (layer->powder == 0)break;
|
||
unsigned char* img = nullptr;
|
||
int width = 0, height = 0;
|
||
//isOK = m_RecoatCheck->CheckWP2(job_meta_data, layerindex); //wxxtest
|
||
//if (!isOK) {
|
||
// layerThick = 0.0f;
|
||
//}
|
||
//else
|
||
// break;
|
||
} while (!isOK && retry--);
|
||
if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d铺粉完成").c_str(), layerindex + 1);
|
||
if (isSlowWindSet&& m_PurifierClient->IsWindActive())
|
||
{
|
||
m_PurifierClient->SetCoverWind(false);
|
||
int windcount = 0;
|
||
while (IsStart() && windcount < 300) {
|
||
if (m_PurifierClient->IsCoverWindRecover()) {
|
||
break;
|
||
}
|
||
windcount++;
|
||
Sleep(100);
|
||
}
|
||
if (m_RunCfg->m_UseCoverWindSignal)
|
||
{
|
||
m_PurifierClient->ResetSlwoWindSignal(false);
|
||
}
|
||
}
|
||
if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d风速已经恢复").c_str(), layerindex + 1);
|
||
m_AlarmCfgWrapper->m_WindOverLimitAlarm->m_IsEnable = windalaemEnable;
|
||
//ResetEvent(m_PowderEvent);
|
||
if (m_ServoManager ) {
|
||
m_ServoManager->StopLog();
|
||
}
|
||
|
||
if (m_RunCfg->m_CoverLayerDelay != 0)
|
||
{
|
||
uint64_t tb = GetTickCount64();
|
||
while (true)
|
||
{
|
||
Sleep(300);
|
||
uint64_t tt = GetTickCount64();
|
||
unsigned int difs = tt - tb;
|
||
if (difs > (m_RunCfg->m_CoverLayerDelay * 1000))
|
||
{
|
||
break;
|
||
}
|
||
if (BaseCtrl::IsStop() || BaseCtrl::IsPause()) {
|
||
if (BaseCtrl::IsStop()) {
|
||
job->SetStartIndex(0);
|
||
}
|
||
if (BaseCtrl::IsPause()) {
|
||
job->SetStartIndex(layerindex);
|
||
}
|
||
isbreak = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (BaseCtrl::IsStop() || BaseCtrl::IsPause()) {
|
||
if (BaseCtrl::IsStop()) {
|
||
job->SetStartIndex(0);
|
||
}
|
||
if (BaseCtrl::IsPause()) {
|
||
job->SetStartIndex(layerindex);
|
||
}
|
||
m_MachineCtrl->MoldMoveUp(layer->layer_thickness, false);
|
||
isbreak = true;
|
||
break;
|
||
}
|
||
|
||
|
||
//if (m_Camera->IsConnect()) { //wxxtest
|
||
// if (m_Camera->GenLogImage()) {
|
||
// LogImage image;
|
||
// time(&image.m_InsertTime);
|
||
// image.m_JobId = jobBean->m_Id;
|
||
// image.m_LayerIndex = layerindex;
|
||
// image.m_Type = LogImage::COVERED;
|
||
// image.m_Image = m_Camera->GetLogImage();
|
||
// image.m_ImageLength = m_Camera->GetLogImageSize();
|
||
// g_log->m_LogDao->AddImage(image);
|
||
// }
|
||
//}
|
||
// }
|
||
|
||
linearAccDis -= (layer->powder == 0 ? 0 : layer->layer_thickness);
|
||
float linearTheoryPos=lastLinearPos- (layer->powder==0?0:layer->layer_thickness);
|
||
float layerJudgeValue = m_RunCfg->m_LayerLinearPosAlarmOffset;
|
||
g_SystemInfo->LockInfo();
|
||
float nowDis = g_SystemInfo->m_EnvState.m_LinearActDistance;
|
||
int32_t nowPDis = g_SystemInfo->m_EnvState.m_LinearActPulse*g_SystemInfo->m_EnvState.m_LineEncPulseEqu;
|
||
int32_t moldPos = g_SystemInfo->m_MoldMainPos;
|
||
g_SystemInfo->UnlockInfo();
|
||
|
||
if (abs(nowDis - linearTheoryPos) > layerJudgeValue) {
|
||
char buffer[256];
|
||
sprintf_s(buffer, sizeof(buffer), _(u8"%zu层光栅位置为%.3f mm，理论值应为%.3f mm").c_str(), layerindex + 1, nowDis / 1000.0f, linearTheoryPos / 1000.0f);
|
||
m_AlarmCfgWrapper->m_LayerLinearPosAlarm->m_AlarmInfo = string(buffer);
|
||
SignalService::GetInstance().SetAlarm(m_AlarmCfgWrapper->m_LayerLinearPosAlarm, true);
|
||
}
|
||
|
||
if (abs(layer->realZ - moldPos) > m_RunCfg->m_MoldServoPosWarnOffset) {
|
||
char buffer[256];
|
||
sprintf_s(buffer, sizeof(buffer), _(u8"%zu层的理论伺服位置为%.3f mm，当前值为%.3f mm").c_str(), layerindex + 1, (float)layer->realZ / 1000.0f, (float)moldPos / 1000.0f);
|
||
m_AlarmCfgWrapper->m_MoldServoPosWarn->m_AlarmInfo = string(buffer);
|
||
SignalService::GetInstance().SetAlarm(m_AlarmCfgWrapper->m_MoldServoPosWarn, true);
|
||
}
|
||
else {
|
||
SignalService::GetInstance().SetAlarm(m_AlarmCfgWrapper->m_MoldServoPosWarn, false);
|
||
}
|
||
|
||
if (abs(linearAccDis - nowPDis) > m_RunCfg->m_PrintLinearAccDevAlarmOffset) {
|
||
char buffer[256];
|
||
sprintf_s(buffer, sizeof(buffer), _(u8"%zu层的理论光栅位置为%.3f mm，当前值为%.3f mm").c_str(), layerindex + 1, (float)linearAccDis / 1000.0f, (float)nowPDis / 1000.0f);
|
||
m_AlarmCfgWrapper->m_PrintLinnearAccDevAlarm->m_AlarmInfo = string(buffer);
|
||
SignalService::GetInstance().SetAlarm(m_AlarmCfgWrapper->m_PrintLinnearAccDevAlarm, true);
|
||
}
|
||
else {
|
||
SignalService::GetInstance().SetAlarm(m_AlarmCfgWrapper->m_PrintLinnearAccDevAlarm, false);
|
||
}
|
||
lastLinearPos = nowDis;
|
||
// unsigned int scan_field_num = job_meta_data->GetNumOfScanField();
|
||
|
||
if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d准备扫描").c_str(), layerindex + 1);
|
||
map<int, Scanner*> useScanner;
|
||
for (int times = 0; times < layer->scan_times && !BaseCtrl::IsStop(); times++) {
|
||
for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
|
||
MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
|
||
if (!datablock)continue;
|
||
MetaData::Part* part = job_meta_data->GetPart(datablock->references->part);
|
||
if (part) {
|
||
if (!part->print_enable) {
|
||
continue;
|
||
}
|
||
}
|
||
BPBinary::BinDataBlock* pdb = job_meta_data->GetDataBlock(datablock);
|
||
MetaData::ParameterSet* paramSet = job_meta_data->GetParameterSet(datablock->references->process);
|
||
dbsIt = DBRefScanLaser->find(datablock);
|
||
//LaserCfg* laserCfg = (*fieldRefScanLaser)[paramSet->scan_field];
|
||
if (dbsIt == DBRefScanLaser->end()) continue;
|
||
if (paramSet->set_type.find("Down") != string::npos && m_RunCfg->m_DownSkinStopTimes > 0) {
|
||
hasDownSkin = true;
|
||
if ((m_DownSkinStopFlag % (m_RunCfg->m_DownSkinStopTimes + 1)) == 0) {
|
||
continue;
|
||
}
|
||
}
|
||
float laserPower = paramSet->laser_set->laser_real_power;
|
||
if (laserPower == 0.0f) {
|
||
continue;
|
||
}
|
||
|
||
if (!pdb)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
int sno = (*DBRefScanLaser)[datablock];
|
||
Scanner* scanner = scanMap[sno];
|
||
if (!scanner)continue;
|
||
scanner->AddDataBlock(pdb, part, paramSet, datablock->order,datablock->scanTime);
|
||
useScanner[sno] = scanner;
|
||
}
|
||
|
||
Scanner::ResetScaningLimit();
|
||
|
||
for (auto sc : useScanner) {
|
||
sc.second->BeginWork();
|
||
}
|
||
|
||
for (auto sc : useScanner) {
|
||
sc.second->WaitFinish();
|
||
}
|
||
|
||
Scanner::ResetScaningLimit();
|
||
//OutputDebugString("end\n");
|
||
}
|
||
if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d扫描完成").c_str(), layerindex + 1);
|
||
jobBean->m_PrintedLayerIndex = layerindex;
|
||
g_SystemInfo->LockInfo();
|
||
jobBean->m_MoldPos = g_SystemInfo->m_MoldMainPos/1000.0f;
|
||
g_SystemInfo->UnlockInfo();
|
||
time(&jobBean->m_StopTime);
|
||
g_log->m_LogDao->UpdateJobAfterPrintLayer(jobBean);
|
||
/*if (m_Camera->IsConnect()) { //wxxtest
|
||
if (m_Camera->GenLogImage()) {
|
||
LogImage image;
|
||
time(&image.m_InsertTime);
|
||
image.m_JobId = jobBean->m_Id;
|
||
image.m_LayerIndex = layerindex;
|
||
image.m_Type = LogImage::PRINTED;
|
||
image.m_Image = m_Camera->GetLogImage();
|
||
image.m_ImageLength = m_Camera->GetLogImageSize();
|
||
g_log->m_LogDao->AddImage(image);
|
||
}
|
||
}*/
|
||
if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"层%d扫描图像记录完成").c_str(), layerindex + 1);
|
||
m_IsDownSkinContinue = hasDownSkin;
|
||
if (m_IsDownSkinContinue)m_DownSkinStopFlag++;
|
||
else m_DownSkinStopFlag = 1;
|
||
|
||
if (m_MachineCfg->m_IsIntelli) {
|
||
|
||
vector<ScannerStatus*> scannerStatus;
|
||
vector<FocusStatus*> focusStatus;
|
||
for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
|
||
m_scan[scanIndex]->UpdateScannerInfo();
|
||
ScannerStatus* sstatus = new ScannerStatus();
|
||
ScanStateXY sxy;
|
||
m_scan[scanIndex]->GetXYScanState(&sxy, sstatus->m_InsertTime);
|
||
sstatus->m_ScanTempX = sxy.m_X.m_GalvanometerScannerTemp;
|
||
sstatus->m_ScanServoTempX = sxy.m_X.m_ServoBoardTemp;
|
||
sstatus->m_ScanTempY = sxy.m_Y.m_GalvanometerScannerTemp;
|
||
sstatus->m_ScanServoTempY = sxy.m_Y.m_ServoBoardTemp;
|
||
sstatus->m_ScanId = m_scan[scanIndex]->GetConfig()->m_SeqNo;
|
||
sstatus->m_JobId = jobBean->m_Id;
|
||
sstatus->m_LayerIndex = layerindex;
|
||
sstatus->m_ActualPositionX = sxy.m_X.m_ActualPosition;
|
||
sstatus->m_SetPositionX = sxy.m_X.m_SetPosition;
|
||
sstatus->m_PositionErrorX = sxy.m_X.m_PositionError;
|
||
sstatus->m_ActualPositionY = sxy.m_Y.m_ActualPosition;
|
||
sstatus->m_SetPositionY = sxy.m_Y.m_SetPosition;
|
||
sstatus->m_PositionErrorY = sxy.m_Y.m_PositionError;
|
||
sstatus->m_LowStateX = sxy.m_X.m_LowState;
|
||
sstatus->m_LowStateY = sxy.m_Y.m_LowState;
|
||
sstatus->m_HighStateX = sxy.m_X.m_HighState;
|
||
sstatus->m_HighStateY = sxy.m_Y.m_HighState;
|
||
scannerStatus.push_back(sstatus);
|
||
|
||
if (m_scan[scanIndex]->GetConfig()->m_ScanCfgWrapper.m_CorrectParamCfg.m_IsDynamicFocus) {
|
||
FocusStatus* fs = new FocusStatus();
|
||
fs->m_ScanId = m_scan[scanIndex]->GetConfig()->m_SeqNo;
|
||
fs->m_JobId = jobBean->m_Id;
|
||
fs->m_LayerIndex = layerindex;
|
||
time(&fs->m_InsertTime);
|
||
fs->m_ScanServoTemp = sxy.m_Focus.m_ServoBoardTemp;
|
||
fs->m_PDSupplyVoltage = sxy.m_Focus.m_PDSupplyVoltage;
|
||
fs->m_DSPCoreSupplyVoltage = sxy.m_Focus.m_DSPCoreSupplyVoltage;
|
||
fs->m_DSPIOVoltage = sxy.m_Focus.m_DSPIOVoltage;
|
||
fs->m_AnalogSectionVoltage = sxy.m_Focus.m_AnalogSectionVoltage;
|
||
fs->m_ADConverterSupplyVoltage = sxy.m_Focus.m_ADConverterSupplyVoltage;
|
||
fs->m_PDSupplyCurrent = sxy.m_Focus.m_PDSupplyCurrent;
|
||
fs->m_LowState = sxy.m_Focus.m_LowState;
|
||
fs->m_HighState = sxy.m_Focus.m_HighState;
|
||
fs->m_StopEven = sxy.m_Focus.m_StopEven;
|
||
focusStatus.push_back(fs);
|
||
}
|
||
}
|
||
g_log->m_LogDao->LogScannerStatus(scannerStatus);
|
||
for (size_t ssindex = 0; ssindex < scannerStatus.size(); ssindex++) {
|
||
delete scannerStatus[ssindex];
|
||
}
|
||
scannerStatus.clear();
|
||
if (!focusStatus.empty()) {
|
||
g_log->m_LogDao->LogFocusStatus(focusStatus);
|
||
for (size_t ssindex = 0; ssindex < focusStatus.size(); ssindex++) {
|
||
delete focusStatus[ssindex];
|
||
}
|
||
focusStatus.clear();
|
||
}
|
||
}
|
||
|
||
if (m_RunCfg->m_PrintLayerDelay != 0)
|
||
{
|
||
uint64_t tb = GetTickCount64();
|
||
while (true)
|
||
{
|
||
Sleep(300);
|
||
uint64_t tt = GetTickCount64();
|
||
unsigned int difs = tt - tb;
|
||
if (difs > (m_RunCfg->m_PrintLayerDelay * 1000))
|
||
{
|
||
break;
|
||
}
|
||
if (BaseCtrl::IsStop() || BaseCtrl::IsPause()) {
|
||
if (BaseCtrl::IsStop()) {
|
||
job->SetStartIndex(0);
|
||
}
|
||
if (BaseCtrl::IsPause()) {
|
||
job->SetStartIndex(layerindex + 1);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
if (!isbreak) {
|
||
job->SetFinished(true);
|
||
time(&jobBean->m_StopTime);
|
||
jobBean->m_IsFinished = true;
|
||
jobBean->m_PrintedLayerIndex = layerindex-1;
|
||
g_log->m_LogDao->UpdateJobAfterPrintLayer(jobBean);
|
||
BaseCtrl::SetFinish();
|
||
g_SystemInfo->m_StateBean.jobProgress = 1.0f;
|
||
job->GetMetaData()->SetRemainTime(0);
|
||
g_SystemInfo->m_StateBean.remainMil = 0;
|
||
//jobBean->m_StopTime = 0;
|
||
jobBean->m_IsFinished = false;
|
||
}
|
||
else {
|
||
if (BaseCtrl::IsPause())
|
||
{
|
||
time(&jobBean->m_LastPauseTime);
|
||
g_log->m_LogDao->UpdateJobPauseTime(jobBean);
|
||
}
|
||
}
|
||
//m_Camera->SetDemandCatpure(false); //wxxtest
|
||
if (m_RunCfg->m_LogDebugInfo)g_log->TraceInfo(_(u8"退出打印流程").c_str(), layerindex + 1);
|
||
}
|
||
|
||
|
||
|
||
void ScannerCtrl::DispatchTestDataBlock()
|
||
{
|
||
for (size_t i = 0; i < m_RedTestDBS.size(); i++) {
|
||
delete m_RedTestDBS[i];
|
||
m_RedTestDBS[i] = NULL;
|
||
}
|
||
m_RedTestDBS.clear();
|
||
if (!m_job_controller)return;
|
||
FileProcessor* job = m_job_controller->GetJob();
|
||
if (job == NULL) {
|
||
g_Toast->AddToast(new ToastBean(_(u8"没有可打印的任务").c_str(), 3000));
|
||
return;
|
||
}
|
||
//SetDefocus(0);
|
||
MetaData* job_meta_data = job->GetMetaData();
|
||
if (job_meta_data == NULL)return;
|
||
job_meta_data->CalcRealPower();
|
||
bool nodebug = !g_isDebug;
|
||
|
||
vector<MetaData::Layer*> layers = job_meta_data->GetLayersVec();
|
||
unsigned int layerindex = job->GetPreviewLayerIndex();
|
||
//unsigned int memorySize = GetMemorySize();
|
||
if (layerindex >= layers.size())return;
|
||
if (!job_meta_data->LoadLayerByIndex(layerindex)) return;
|
||
MetaData::Layer* layer = job_meta_data->GetLayer(layerindex);
|
||
|
||
//MetaData::Layer* layer = job_meta_data->GetPreviewLayer();
|
||
map<int, Scanner*> useScanner;
|
||
map<MetaData::DataBlock*, int>* DBRefScanLaser = job_meta_data->GetDBRefScanLaser();
|
||
map<MetaData::DataBlock*, int>::iterator dbsIt;
|
||
map<int, Scanner*> scanMap;
|
||
|
||
for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
|
||
Scanner* scanner = m_scan[scanIndex];
|
||
scanMap[scanner->GetConfig()->m_SeqNo] = scanner;
|
||
m_scan[scanIndex]->Clean();
|
||
}
|
||
for (size_t i = 0; i < m_scan.size(); i++)
|
||
{
|
||
m_scan[i]->SetAutoUpdateScanInfo(false);
|
||
m_scan[i]->m_IsOrderSeqV2 = m_job_controller->GetJob()->GetMetaData()->m_IsScanOrderSeqV2;
|
||
}
|
||
for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
|
||
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
|
||
if (!datablock)continue;
|
||
MetaData::Part* part = job_meta_data->GetPart(datablock->references->part);
|
||
if (part) {
|
||
if (!part->print_enable) continue;
|
||
}
|
||
BPBinary::BinDataBlock* pdb = job_meta_data->GetDataBlock(datablock);
|
||
if (!pdb)continue;
|
||
MetaData::ParameterSet* paramSet = job_meta_data->GetParameterSet(datablock->references->process);
|
||
if (!paramSet)continue;
|
||
if (paramSet->laser_set->laser_power == 0.0f)
|
||
{
|
||
continue;
|
||
}
|
||
dbsIt = DBRefScanLaser->find(datablock);
|
||
//LaserCfg* laserCfg = (*fieldRefScanLaser)[paramSet->scan_field];
|
||
if (dbsIt == DBRefScanLaser->end()) continue;
|
||
int sno = (*DBRefScanLaser)[datablock];
|
||
Scanner* scanner = scanMap[sno];
|
||
if (!scanner)continue;
|
||
BPBinary::BinDataBlock* pbindb = new BPBinary::BinDataBlock;
|
||
pdb->Copy(pbindb);
|
||
m_RedTestDBS.push_back(pbindb);
|
||
scanner->AddDataBlock(pbindb, part, paramSet,datablock->order, datablock->scanTime);
|
||
useScanner[sno] = scanner;
|
||
}
|
||
Scanner::ResetScaningLimit();
|
||
for (auto scanner : useScanner)
|
||
scanner.second->BeginWork();
|
||
|
||
for (auto scanner : useScanner)
|
||
scanner.second->WaitFinish();
|
||
|
||
Scanner::ResetScaningLimit();
|
||
|
||
for (size_t i = 0; i < m_RedTestDBS.size(); i++) {
|
||
delete m_RedTestDBS[i];
|
||
}
|
||
m_RedTestDBS.clear();
|
||
for (size_t i = 0; i < m_scan.size(); i++)
|
||
{
|
||
m_scan[i]->SetAutoUpdateScanInfo(true);
|
||
}
|
||
}
|
||
|
||
|
||
void ScannerCtrl::ModelScan(void)
|
||
{
|
||
if (m_RedPrintTestThread != INVALID_HANDLE_VALUE)
|
||
return;
|
||
m_RedPrintTestThread = AtlCreateThread(ModelScanProc, this);
|
||
}
|
||
|
||
void ScannerCtrl::StopModelScan(void)
|
||
{
|
||
PrintState printStateTemp = BaseCtrl::GetState();
|
||
BaseCtrl::SetState(BaseCtrl::STOP);
|
||
EnterCriticalSection(&m_LayerTestCs);
|
||
if (m_RedPrintTestThread != INVALID_HANDLE_VALUE) {
|
||
for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
|
||
Scanner* scanner = m_scan[scanIndex];
|
||
scanner->StopWork();
|
||
}
|
||
if (WaitForSingleObject(m_RedPrintTestThread, 1000) == WAIT_TIMEOUT) {
|
||
TerminateThread(m_RedPrintTestThread, 0);
|
||
}
|
||
CloseHandle(m_RedPrintTestThread);
|
||
m_RedPrintTestThread = INVALID_HANDLE_VALUE;
|
||
}
|
||
LeaveCriticalSection(&m_LayerTestCs);
|
||
BaseCtrl::SetState(printStateTemp);
|
||
for (size_t i = 0; i < m_scan.size(); i++) {
|
||
m_scan[i]->Clean();
|
||
}
|
||
}
|
||
|
||
|
||
DWORD WINAPI ScannerCtrl::ModelScanProc(thisClass* _this)
|
||
{
|
||
if (_this)
|
||
{
|
||
ExtCfg* stc = ConfigManager::GetInstance()->GetExtCfg();
|
||
if (stc->m_model_scan_mode == 0) {}
|
||
//_this->m_gc->StartLaser(true);
|
||
else {
|
||
//_this->m_gc->StopLaser(true);
|
||
if (!_this->m_IOCfgWrapper->m_Laser->IsActive()) {
|
||
_this->m_IOCfgWrapper->m_Laser->SetActive(true);
|
||
Sleep(_this->m_ExtCfg->m_AftLaserPowerWaitSecond*1000);
|
||
}
|
||
vector<ScannerControlCfg*>* laserCfgs = ConfigManager::GetInstance()->GetMatchScannerControlCfg();
|
||
for (size_t lrIndex = 0; lrIndex < laserCfgs->size(); lrIndex++) {
|
||
ScannerControlCfg* laserCfg = (*laserCfgs)[lrIndex];
|
||
if (laserCfg->m_LaserRed && !laserCfg->m_LaserRed->IsActive()) {
|
||
laserCfg->m_LaserRed->SetActive(true);
|
||
}
|
||
}
|
||
}
|
||
g_Toast->AddToast(new ToastBean(_(u8"开始扫描").c_str(), 2000, ImVec4(0, 1, 0, 1)));
|
||
|
||
_this->DispatchModelDataBlock(stc->m_model_scan_part_id, stc->m_model_scan_type, stc->m_model_laser_power, stc->m_model_laser_speed);
|
||
EnterCriticalSection(&_this->m_LayerTestCs);
|
||
if (_this->m_RedPrintTestThread != INVALID_HANDLE_VALUE) {
|
||
CloseHandle(_this->m_RedPrintTestThread);
|
||
_this->m_RedPrintTestThread = INVALID_HANDLE_VALUE;
|
||
}
|
||
LeaveCriticalSection(&_this->m_LayerTestCs);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void ScannerCtrl::DispatchModelDataBlock(int partId, string scanType, float power, float speed)
|
||
{
|
||
for (size_t i = 0; i < m_ModeTestDBS.size(); i++) {
|
||
delete m_ModeTestDBS[i];
|
||
}
|
||
m_ModeTestDBS.clear();
|
||
|
||
if (!m_job_controller)return;
|
||
FileProcessor* job = m_job_controller->GetJob();
|
||
if (job == NULL) {
|
||
g_Toast->AddToast(new ToastBean(_(u8"没有可打印的任务").c_str(), 3000));
|
||
return;
|
||
}
|
||
|
||
MetaData* job_meta_data = job->GetMetaData();
|
||
if (job_meta_data == NULL)return;
|
||
job_meta_data->CalcRealPower();
|
||
bool nodebug = !g_isDebug;
|
||
|
||
vector<MetaData::Part*> parts = job_meta_data->GetPartVec();
|
||
if (partId > parts.size())
|
||
return;
|
||
|
||
if (scanType != "Border" && scanType != "Hatching")
|
||
return;
|
||
|
||
vector<MetaData::Layer*> layers = job_meta_data->GetLayersVec();
|
||
size_t layerindex = job->GetStartIndex();
|
||
if (layerindex >= layers.size())return;
|
||
|
||
map<int, Scanner*> useScanner;
|
||
map<MetaData::DataBlock*, int>* DBRefScanLaser = job_meta_data->GetDBRefScanLaser();
|
||
map<MetaData::DataBlock*, int>::iterator dbsIt;
|
||
map<int, Scanner*> scanMap;
|
||
for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
|
||
Scanner* scanner = m_scan[scanIndex];
|
||
scanMap[scanner->GetConfig()->m_SeqNo] = scanner;
|
||
}
|
||
|
||
if (!job_meta_data->LoadLayerByIndex(layerindex)) return;
|
||
MetaData::Layer* layer = job_meta_data->GetLayer(layerindex);
|
||
|
||
vector<MetaData::ParameterSet*> params;
|
||
|
||
for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
|
||
if (BaseCtrl::IsStop()) {
|
||
break;
|
||
}
|
||
|
||
MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
|
||
if (!datablock)continue;
|
||
if (datablock->references->part != partId)
|
||
continue;
|
||
|
||
|
||
MetaData::Part* part = job_meta_data->GetPart(datablock->references->part);
|
||
if (part) {
|
||
if (!part->print_enable) continue;
|
||
}
|
||
|
||
MetaData::ParameterSet* ps = job_meta_data->GetParameterSet(datablock->references->process);
|
||
if (ps->laser_set->laser_power == 0.0f)
|
||
{
|
||
continue;
|
||
}
|
||
if (scanType == "Border") {
|
||
switch (m_ExtCfg->m_model_border_type) {
|
||
case ExtCfg::All_Border: {
|
||
if (ps->set_type.find("Border") == ps->set_type.npos) {
|
||
continue;
|
||
}
|
||
}break;
|
||
case ExtCfg::Border: {
|
||
if (ps->set_type != "Border" && ps->set_type != "InBorder" && ps->set_type != "InBorderJ")continue;
|
||
}break;
|
||
case ExtCfg::BorderDown: {
|
||
if (ps->set_type != "BorderDown" && ps->set_type != "DownBorder" && ps->set_type != "DownBorderJ")continue;
|
||
}break;
|
||
case ExtCfg::BorderAdditionalDown: {
|
||
if (ps->set_type != "BorderAdditionalDown" && ps->set_type != "DownBorderAd" && ps->set_type != "DownBorderAdJ")continue;
|
||
}break;
|
||
case ExtCfg::BorderBlockedDown: {
|
||
if (ps->set_type != "BorderBlockedDown")continue;
|
||
}break;
|
||
case ExtCfg::BorderAdditional: {
|
||
if (ps->set_type != "BorderAdditional" && ps->set_type != "InBorderAd" && ps->set_type != "InBorderAdJ")continue;
|
||
}break;
|
||
case ExtCfg::BorderBlocked: {
|
||
if (ps->set_type != "BorderBlocked")continue;
|
||
}break;
|
||
case ExtCfg::BorderUp: {
|
||
if (ps->set_type != "BorderUp" && ps->set_type != "UpBorder")continue;
|
||
}break;
|
||
case ExtCfg::BorderAdditionalUp: {
|
||
if (ps->set_type != "BorderAdditionalUp" && ps->set_type != "UpBorderAd")continue;
|
||
}break;
|
||
case ExtCfg::BorderBlockedUp: {
|
||
if (ps->set_type != "BorderBlockedUp")continue;
|
||
}break;
|
||
case ExtCfg::BorderSupport: {
|
||
if (ps->set_type != "BorderSupport" && ps->set_type != "SupportBorder")continue;
|
||
}break;
|
||
case ExtCfg::BorderAdditionalSupport: {
|
||
if (ps->set_type != "BorderAdditionalSupport")continue;
|
||
}break;
|
||
}
|
||
|
||
}
|
||
else {
|
||
if (ps->set_type != "Hatching" && ps->set_type != "InHatching")
|
||
continue;
|
||
}
|
||
|
||
BPBinary::BinDataBlock* pdb = job_meta_data->GetDataBlock(datablock);
|
||
if (!pdb)continue;
|
||
dbsIt = DBRefScanLaser->find(datablock);
|
||
if (dbsIt == DBRefScanLaser->end()) continue;
|
||
int sno = (*DBRefScanLaser)[datablock];
|
||
Scanner* scanner = scanMap[sno];
|
||
if (!scanner)continue;
|
||
BPBinary::BinDataBlock* pbindb = new BPBinary::BinDataBlock;
|
||
pdb->Copy(pbindb);
|
||
m_ModeTestDBS.push_back(pbindb);
|
||
|
||
MetaData::ParameterSet* newParam = new MetaData::ParameterSet();
|
||
newParam->laser_speed = speed;
|
||
newParam->laser_set->laser_diameter = ps->laser_set->laser_diameter;
|
||
newParam->laser_set->laser_power = power;
|
||
newParam->laser_set->laser_real_power = scanner->GetConfig()->m_ScanCfgWrapper.m_PowerCompensateCfg.CalcPowerCompensate(power);
|
||
params.push_back(newParam);
|
||
scanner->AddDataBlock(pbindb, part, newParam,datablock->order, datablock->scanTime);
|
||
useScanner[sno] = scanner;
|
||
}
|
||
Scanner::ResetScaningLimit();
|
||
for (auto scanner : useScanner)
|
||
scanner.second->BeginWork();
|
||
|
||
for (auto scanner : useScanner)
|
||
scanner.second->WaitFinish();
|
||
|
||
Scanner::ResetScaningLimit();
|
||
for (size_t i = 0; i < params.size(); i++) {
|
||
delete params[i];
|
||
}
|
||
params.clear();
|
||
for (size_t i = 0; i < m_ModeTestDBS.size(); i++) {
|
||
delete m_ModeTestDBS[i];
|
||
}
|
||
m_ModeTestDBS.clear();
|
||
}
|
||
|
||
DWORD WINAPI ScannerCtrl::ReleasePressureProc(thisClass* _this)
|
||
{
|
||
if (_this) {
|
||
_this->m_IOCfgWrapper->SetSystemCtrlPressure(false);
|
||
Sleep(100);
|
||
uint64_t tflag = GetTickCount64();
|
||
_this->m_IOCfgWrapper->m_PressureRelease->SetActive(true);
|
||
while (true && _this->m_PressureCtrlFlag) {
|
||
|
||
uint64_t tnow = GetTickCount64();
|
||
if ((tnow-tflag) > (_this->m_RunCfg->m_ReleasePressureSeconds*1000)) {
|
||
break;
|
||
}
|
||
|
||
if (g_SystemInfo->m_EnvState.m_PrintPressureAnalog <= _this->m_RunCfg->m_ReleasePressureTargeValue) {
|
||
break;
|
||
}
|
||
Sleep(500);
|
||
}
|
||
_this->m_IOCfgWrapper->m_PressureRelease->SetActive(false);
|
||
CloseHandle(_this->m_PressureThread);
|
||
_this->m_PressureThread = INVALID_HANDLE_VALUE;
|
||
_this->m_IOCfgWrapper->SetSystemCtrlPressure(true);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
bool ScannerCtrl::IsHeatingScannerEnable()
|
||
{
|
||
bool rel = false;
|
||
for (size_t scanIndex = 0; scanIndex < m_scan.size(); ++scanIndex) {
|
||
Scanner* scanner = m_scan[scanIndex];
|
||
|
||
if (scanner->GetConfig()->m_ScanCfgWrapper.m_ScanTestCfg.m_IsAutoHeatingScanner)
|
||
{
|
||
rel = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
return rel;
|
||
}
|
||
|
||
|
||
void ScannerCtrl::StartHeatingMotion()
|
||
{
|
||
if (!m_IOCfgWrapper->m_Heating) return;
|
||
if (!m_RunCfg->m_UseHeatingMotion)return;
|
||
if (BaseCtrl::IsStart())return;
|
||
if (BaseCtrl::IsPause())return;
|
||
if (BaseCtrl::IsStop())return;
|
||
if (m_HeatingMotionThread != INVALID_HANDLE_VALUE)return;
|
||
m_HeatingMotionFlag = true;
|
||
m_HeatingMotionThread = AtlCreateThread(HeatingMotionProc, this);
|
||
}
|
||
|
||
void ScannerCtrl::StopHeatingMotion(bool iswait)
|
||
{
|
||
m_HeatingMotionFlag = false;
|
||
if (iswait) {
|
||
while (true) {
|
||
if (m_HeatingMotionThread == INVALID_HANDLE_VALUE) {
|
||
break;
|
||
}
|
||
Sleep(200);
|
||
}
|
||
}
|
||
}
|
||
|
||
DWORD WINAPI ScannerCtrl::HeatingMotionProc(ScannerCtrl* _this)
|
||
{
|
||
if (_this) {
|
||
_this->HeatingMotionRun();
|
||
CloseHandle(_this->m_HeatingMotionThread);
|
||
_this->m_HeatingMotionThread = INVALID_HANDLE_VALUE;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void ScannerCtrl::HeatingMotionRun()
|
||
{
|
||
uint64_t tflag = GetTickCount64();
|
||
Sleep(500);
|
||
while (m_HeatingMotionFlag) {
|
||
int count = 0;
|
||
while (m_HeatingMotionFlag && count < 10 && m_RunCfg->m_UseHeatingMotion) {
|
||
Sleep(100);
|
||
count++;
|
||
}
|
||
if (!m_HeatingMotionFlag || !m_RunCfg->m_UseHeatingMotion || !m_IOCfgWrapper->m_Heating->IsActive()) {
|
||
m_HeatingMotionFlag = false;
|
||
break;
|
||
}
|
||
if (BaseCtrl::IsStart()) {
|
||
m_HeatingMotionFlag = false;
|
||
break;
|
||
}
|
||
if (m_MachineCtrl->IsCovering())continue;
|
||
uint64_t tnow = GetTickCount64();
|
||
if (tnow - tflag > (m_RunCfg->m_HeatingMotionPeriodSecond * 1000))
|
||
{
|
||
m_MachineCtrl->MoldMoveDown(m_RunCfg->m_HeatingMotionDistance,true);
|
||
Sleep(500);
|
||
m_MachineCtrl->MoldMoveUp(m_RunCfg->m_HeatingMotionDistance,true);
|
||
Sleep(500);
|
||
tflag = tnow;
|
||
}
|
||
}
|
||
}
|
||
|
||
void ScannerCtrl::RemoveScanner(int seq)
|
||
{
|
||
for (vector<Scanner*>::iterator it = m_scan.begin(); it != m_scan.end();) {
|
||
Scanner* s = (*it);
|
||
if (s->GetConfig()->m_SeqNo == seq)
|
||
{
|
||
delete s;
|
||
it = m_scan.erase(it);
|
||
break;
|
||
}
|
||
else {
|
||
it++;
|
||
}
|
||
}
|
||
}
|
||
|
||
//void ScannerCtrl::DrawFinishReport()
|
||
//{
|
||
// if (!m_ShowFinishReport)return;
|
||
//
|
||
// if (m_RemoteClient->IsNeedSendFinish())
|
||
// {
|
||
// time_t tnow;
|
||
// time(&tnow);
|
||
// if (tnow - m_LastSendFinishReportTime > 5) {
|
||
// m_RemoteClient->SendStateChangeMsg();
|
||
// m_LastSendFinishReportTime = tnow;
|
||
// }
|
||
// }
|
||
//
|
||
// ImGui::OpenPopup(_(u8"打印报告").c_str());
|
||
// if (ImGui::BeginPopupModal(_(u8"打印报告").c_str(), NULL, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize)) {
|
||
// ImGui::Text(_(u8"任务 %s 已打印完成").c_str(), m_job_controller->GetJob()->GetJobTitle().c_str());
|
||
// ImGui::Text(_(u8"任务开始时间：%s").c_str(), TimeHelper::Time2Str(m_job_controller->GetJob()->GetJobbean()->m_StartTime).c_str());
|
||
// ImGui::Text(_(u8"任务结束时间：%s").c_str(), TimeHelper::Time2Str(m_job_controller->GetJob()->GetJobbean()->m_StopTime).c_str());
|
||
// int ss = m_job_controller->GetJob()->GetJobbean()->m_StopTime - m_job_controller->GetJob()->GetJobbean()->m_StartTime;
|
||
// int h = ss / 60 / 60;
|
||
// int m = (ss / 60) % 60;
|
||
// ImGui::Text(_(u8"耗时：%d小时%d分钟").c_str(), h, m);
|
||
//
|
||
// m_PurifierClient->DrawFinishReportRel();
|
||
// int ft = m_PurifierClient->GetFilterUseTime();
|
||
// if (ft > m_RunCfg->m_PurifierFilterNotifyHour) {
|
||
// ImGui::TextColored(Toast::COLOR_ORANGE, _(u8"注意：滤芯已使用%d小时").c_str(), ft);
|
||
// }
|
||
// ImGui::Separator();
|
||
// if (ImGui::Button(_(u8"确定").c_str(), ImVec2(120, 0))) {
|
||
// BaseCtrl::SetStandBy();
|
||
// m_RemoteClient->SetNeedSendAlarm(false);
|
||
// m_ShowFinishReport = false;
|
||
// m_job_controller->GetJob()->GetJobbean()->m_StopTime = 0;
|
||
// m_job_controller->GetJob()->GetJobbean()->m_IsFinished = false;
|
||
// ImGui::CloseCurrentPopup();
|
||
// }
|
||
// ImGui::EndPopup();
|
||
// }
|
||
//}
|