admin/geomative
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
df489d5640f2c690624c7995102ecde5511a4d56
geomative/GeomativeStudio/cpp/Views/DialOfflineDeviceTaskManager.cpp
T
coco df489d5640 a
2026-07-03 16:05:30 +08:00

2140 lines
72 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// CDialOfflineDeviceTaskManager.cpp : implementation file
//
#include "stdafx.h"
#include "GeoMative.h"
#include "DialOfflineDeviceTaskManager.h"
#include "DialUploadLoopTask.h"
#include "DialManageLoopTask.h"
#include "DialMeasureData.h"
#include "DialDeleteTaskOption.h"
#include "Lock\AutoLock.h"
#include "DownloadDataProgressDlg.h"
#include "FileOperTools.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
extern int g_UIOffset;
extern int g_iUILanguage;
extern CGeoMativeApp theApp;
extern CString g_strSaveTestingTaskID;
extern CString g_strSaveSuspendedTaskID;
extern BOOL g_bIsOnlineTransfer;
extern EN_TASK_TESTING_METHOD g_eTestingMethod;
extern CString OnLineTask(BYTE ucTaskStats);
extern CString OnLineLocalTaskState(BYTE ucTaskStats);
extern float tcp_ntohf(float f);
extern int GetSigTxPeriod(int iTestType, int iTestPeriod);
extern CString Tm2LocalStr(time_t t);
extern time_t Str2GmtTm(CString szTime);
extern time_t g_i64SaveQueryTaskStartTime;
extern time_t g_i64SaveQueryTaskEndTime;
extern char* U2G(const char* utf8);
extern CString GetTestFailedReason(UINT32 uiTestFailedReason);
#define MODULE_NAME _T("CDialOfflineDeviceTaskManager")
/////////////////////////////////////////////////////////////////////////////
// CDialOfflineDeviceTaskManager dialog
CDialOfflineDeviceTaskManager::CDialOfflineDeviceTaskManager(CWnd* pParent /*=NULL*/)
: CNetRequestDialog(CDialOfflineDeviceTaskManager::IDD, pParent), m_dialNew1DTask(&m_taskOper), m_dialNew2DTask(&m_taskOper), m_dialNew3DTask(&m_taskOper), m_dialRealTimeMeasuData(this)
{
//{{AFX_DATA_INIT(CDialOfflineDeviceTaskManager)
// NOTE: the ClassWizard will add member initialization here
//}}AFX_DATA_INIT
InitializeCriticalSection(&m_cs);
m_iSelTaskType = 0;
m_iTestType = -1;
m_dwDeviceSN = 0;
m_dwPLCID = 0;
m_bLastCancelTask = FALSE;
//m_bThreadIsRunning = false;
//m_bThreadIsPause = false;
//m_bThreadIsExit = false;
}
CDialOfflineDeviceTaskManager::~CDialOfflineDeviceTaskManager()
{
//KillTimer(ID_TIMER_HEARTBEAT_PACKET);
//重置保存的时间
g_i64SaveQueryTaskStartTime = 0;
g_i64SaveQueryTaskEndTime = 0;
DeleteCriticalSection(&m_cs);
}
void CDialOfflineDeviceTaskManager::DoDataExchange(CDataExchange* pDX)
{
CNetRequestDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CDialOfflineDeviceTaskManager)
DDX_Control(pDX, IDC_LIST_TASK_ATTR, m_listTaskAttr);
DDX_Control(pDX, IDC_LIST_TASK_DATA, m_listTaskData);
DDX_Control(pDX, IDC_TAB_TASK_CHG, m_tabTaskChg);
DDX_Control(pDX, IDC_DATETIMEPICKER_STARTTIME, m_StartTime);
DDX_Control(pDX, IDC_DATETIMEPICKER_ENDTIME, m_EndTime);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CDialOfflineDeviceTaskManager, CNetRequestDialog)
//{{AFX_MSG_MAP(CDialOfflineDeviceTaskManager)
ON_BN_CLICKED(IDC_BUTTON_CREATE_TASK, OnButtonCreateTask)
ON_BN_CLICKED(IDC_BUTTON_DEL_TASK, OnButtonDelTask)
ON_MESSAGE(WM_CLICK_TASK_TREE, OnClickTaskTree)
ON_MESSAGE(WM_MSG_DELETE_TASK, OnMsgDeleteTask)
ON_MESSAGE(WM_MSG_UPDATE_TASK_LIST, OnMsgTaskRefreshList)
ON_MESSAGE(WM_MSG_UPDATE_REALTIME_WND_BTN_STATUS, OnMsgUpdateRealTimeWndBtnStatus)
ON_MESSAGE(WM_MSG_SET_CURRENT_SELECT_TASK, OnMsgSetCurrentSelectTask)
//ON_MESSAGE(WM_TASK_LIST_TASK_INFO_SYN, OnMsgTaskListTaskInfoSyn)
ON_MESSAGE(WM_TASK_LIST_TASK_DATA_SYN, OnMsgTaskListTaskDataSyn)
ON_MESSAGE(WM_NET_RECV_REAL_TIME_DATA, OnRecvRealTimeDataResponse)
ON_NOTIFY(TCN_SELCHANGE, IDC_TAB_TASK_CHG, OnSelchangeTabTaskChg)
// ON_BN_CLICKED(IDC_BUTTON_EXP_TASK, OnButtonExpTask)
ON_BN_CLICKED(IDC_BUTTON_MEASURE_TASK, OnButtonMeasureTask)
ON_BN_CLICKED(IDC_BTN_DATA_DOWNLOAD, OnBtnDataDownload)
ON_BN_CLICKED(IDC_BTN_CREATE_TIMER_TASK, OnBtnCreateTimerTask)
ON_BN_CLICKED(IDC_BTN_MANAGER_TIMER_TASK, OnBtnManageTimerTask)
ON_BN_CLICKED(IDC_BTN_QUREY_TASK_LIST, OnBtnQueryTaskList)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BOOL CDialOfflineDeviceTaskManager::DestroyWindow()
{
// TODO: 在此添加专用代码和/或调用基类
theApp.m_NetWorkOper.UnRegeditRealMsgCall(this->m_hWnd);
return CDialog::DestroyWindow();
}
/////////////////////////////////////////////////////////////////////////////
// CDialOfflineDeviceTaskManager message handlers
LRESULT CDialOfflineDeviceTaskManager::OnMsgDeleteTask(WPARAM wParam, LPARAM lParam)
{
//SetPauseThread(true);
//删除本地及树型控件列表数据
m_taskOper.DeleteTaskArray(m_vtNeedDelLocalTaskID);
// int iFailedCount = m_vtFailedDelTaskID.size();
// if (iFailedCount > 0)
// {
// CString strMsg;
// if (LANG_ZHCN == g_iUILanguage)
// strMsg = _T("删除任务失败");
// else
// strMsg = _T("Failed to delete test task");
//
// for (int i = 0; i < iFailedCount; i++)
// {
// strMsg += m_vtFailedDelTaskID.at(i);
// if (i + 1 != iFailedCount)
// {
// strMsg += _T(",");
// }
// }
// AfxMessageBox(strMsg);
// }
// else
// {
// if (LANG_ZHCN == g_iUILanguage)
// AfxMessageBox(_T("删除任务成功"));
// else
// AfxMessageBox("Succeed to delete test task");
//
// }
//strLog.Empty();
CString strLog;
// int iDelTaskRunningCount = m_vtDelTaskRunning.size();
// if (m_vtDelTaskRunning.size() > 0)
// {
// if (g_iUILanguage == LANG_ZHCN)
// strLog = _T("任务正在运行中：");
// else
// strLog = _T("task is running: ");
//
// for (int i = 0; i < iDelTaskRunningCount; i++)
// {
// strLog += m_vtDelTaskRunning.at(i);
// if (i != iDelTaskRunningCount - 1)
// {
// strLog += _T(",");
// }
// else
// {
// strLog += _T(";");
// }
// }
// }
int iDelNoCancelTestCount = m_vtDelNoCancelTest.size();
if (m_vtDelNoCancelTest.size() > 0)
{
if (g_iUILanguage == LANG_ZHCN)
strLog += _T("请取消测试后删除任务：");
else
strLog += _T("Please cancel the test and delete the task: ");
for (int i = 0; i < iDelNoCancelTestCount; i++)
{
strLog += m_vtDelNoCancelTest.at(i);
if (i != iDelNoCancelTestCount - 1)
{
strLog += _T(",");
}
else
{
strLog += _T(";");
}
}
}
int iFailedDelTaskIDCount = m_vtFailedDelTaskID.size();
if (m_vtFailedDelTaskID.size() > 0)
{
if (g_iUILanguage == LANG_ZHCN)
strLog += _T("未知错误：");
else
strLog += _T("unknown error: ");
for (int i = 0; i < iFailedDelTaskIDCount; i++)
{
strLog += m_vtFailedDelTaskID.at(i);
if (i != iFailedDelTaskIDCount - 1)
{
strLog += _T(",");
}
else
{
strLog += _T(";");
}
}
}
if (iDelNoCancelTestCount <= 0 && iFailedDelTaskIDCount <= 0)
{
if (g_iUILanguage == LANG_ZHCN)
AfxMessageBox(_T("删除任务成功"));
else
MessageBoxEx(NULL, _T("Delete task success"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
}
else
{
CString strTips;
if (g_iUILanguage == LANG_ZHCN)
{
strTips.Format(_T("删除云端任务失败,%s"), strLog);
AfxMessageBox(strTips);
}
else
{
strTips.Format(_T("Delete cloud task failed,%s"), strLog);
MessageBoxEx(NULL, strTips, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
}
}
OnMsgTaskRefreshList(0,0);
return 0;
}
void CDialOfflineDeviceTaskManager::OnButtonCreateTask()
{
//SetPauseThread(true);
// TODO: Add your control notification handler code here
memset(&m_TaskArg, 0, sizeof(STRemTaskArg));
int iRet = -1;
CString strTaskCN = _T("");
CString strTmp;
//m_taskOper.m_uiDevID = m_uiDstDevID;
if (0 == m_iSelTaskType)
{
iRet = m_dialNew1DTask.DoModal();
if (IDOK == iRet)
{
strTaskCN = m_dialNew1DTask.m_strTaskCN;
//strcpy(m_TaskArg.ucTaskID, m_dialNew1DTask.m_strTaskCN);
strTmp.Format("%d", m_dialNew1DTask.m_iNewTaskID);
strcpy(m_TaskArg.ucTaskID, strTmp);
strcpy(m_TaskArg.ucTDName, m_dialNew1DTask.m_strTaskName);
strcpy(m_TaskArg.ucSciptName, m_dialNew1DTask.m_strSptName);
m_TaskArg.stMeasuArg.ucTestType = m_dialNew1DTask.m_iTestType;
m_TaskArg.stMeasuArg.ucArrayType = m_dialNew1DTask.m_iAR;
m_TaskArg.stMeasuArg.ucStacking = m_dialNew1DTask.m_iStacking;
m_TaskArg.stMeasuArg.ucTxPeriod = m_dialNew1DTask.m_iTxPeriod;
m_TaskArg.stMeasuArg.iSAInterval = m_dialNew1DTask.m_iSAInterval;
m_TaskArg.ucOrgFlg = 0;
}
}
else if (1 == m_iSelTaskType)
{
iRet = m_dialNew2DTask.DoModal();
if (IDOK == iRet)
{
strTaskCN = m_dialNew2DTask.m_strTaskCN;
//strcpy(m_TaskArg.ucTaskID, m_dialNew2DTask.m_strTaskCN);
strTmp.Format("%d", m_dialNew2DTask.m_iNewTaskID);
strcpy(m_TaskArg.ucTaskID, strTmp);
strcpy(m_TaskArg.ucTDName, m_dialNew2DTask.m_strTaskName);
strcpy(m_TaskArg.ucSciptName, m_dialNew2DTask.m_strSptName);
m_TaskArg.uiStartElec = m_dialNew2DTask.m_iStartElec;
m_TaskArg.uiEndElec = m_dialNew2DTask.m_iEndElec;
m_TaskArg.uiStartLayer = m_dialNew2DTask.m_iStatrLayer;
m_TaskArg.uiEndLayer = m_dialNew2DTask.m_iEndLayer;
m_TaskArg.stMeasuArg.ucTestType = m_dialNew2DTask.m_iTestType;
m_TaskArg.stMeasuArg.ucTxPeriod = m_dialNew2DTask.m_iTxPeriod;
m_TaskArg.stMeasuArg.ucSptType = m_dialNew2DTask.m_iSptID;
m_TaskArg.stMeasuArg.ucCableLayout = m_dialNew2DTask.m_iCableLayout;
m_TaskArg.stMeasuArg.ucStacking = m_dialNew2DTask.m_iStacking;
m_TaskArg.stMeasuArg.iSAInterval = m_dialNew2DTask.m_iSAInterval;
m_TaskArg.stMeasuArg.ucArrayType = m_dialNew2DTask.m_iAR;
//m_TaskArg.stMeasuArg.fElecSpace = m_dialNew2DTask.m_fEelcSpace;
m_TaskArg.stMeasuArg.fXElecDistance = m_dialNew2DTask.m_fEelcSpace;
m_TaskArg.ucOrgFlg = 0;
}
}
else if (2 == m_iSelTaskType)
{
iRet = m_dialNew3DTask.DoModal();
if (IDOK == iRet)
{
strTaskCN = m_dialNew3DTask.m_strTaskCN;
strTmp.Format("%d", m_dialNew3DTask.m_iNewTaskID);
strcpy(m_TaskArg.ucTaskID, strTmp);
strcpy(m_TaskArg.ucTDName, m_dialNew3DTask.m_strTaskName);
strcpy(m_TaskArg.ucSciptName, m_dialNew3DTask.m_strSptName);
m_TaskArg.stMeasuArg.ucTestType = m_dialNew3DTask.m_iTestType;
m_TaskArg.stMeasuArg.ucTxPeriod = m_dialNew3DTask.m_iTxPeriod;
m_TaskArg.stMeasuArg.ucSptType = m_dialNew3DTask.m_iSptID;
m_TaskArg.stMeasuArg.ucCableLayout = m_dialNew3DTask.m_iCableLayout;
m_TaskArg.stMeasuArg.ucStacking = m_dialNew3DTask.m_iStacking;
m_TaskArg.stMeasuArg.iSAInterval = m_dialNew3DTask.m_iSAInterval;
m_TaskArg.stMeasuArg.ucArrayType = m_dialNew3DTask.m_iAR;
m_TaskArg.ucOrgFlg = 0;
}
}
else
{
CString strErr = _T("");
strErr.Format(_T("Unknow task type(%d)"), m_iSelTaskType);
MessageBoxEx(NULL, strErr, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
if (IDOK == iRet)
{
//上传数据
CDownloadDataProgressDlg uploadDlg(&m_TaskArg, &m_taskOper,this);
uploadDlg.SetDeviceID(m_dwDeviceSN);
uploadDlg.DoModal();
}
}
void CDialOfflineDeviceTaskManager::UpdateRealTimeTaskListData(STRemTaskArg* ptTaskArg, STTaskListItem* pTaskItem)
{
//获取第一个任务信息
CString strLog;
strLog.Format(_T("zm:CDialOfflineDeviceTaskManager::UpdateRealTimeTaskListData begin"));
CFileOperTools::GetInstance()->WriteComLog(strLog);
m_stRealTimeTaskArg = *ptTaskArg;
if (EN_MEASURE_DATA != m_dialRealTimeMeasuData.GetMeasureType())
{
//从本地数据库获取GR
//m_dialRealTimeMeasuData.InitGrList(m_dialRealTimeMeasuData.m_dialListMeasuGR.m_listData, m_stRealTimeTaskArg.ucTaskID);
//实时从云端获取GR
m_dialRealTimeMeasuData.m_dialListMeasuGR.GetGRRequest(m_stRealTimeTaskArg);
return;
}
m_dialRealTimeMeasuData.m_dialListMeasuTask.m_listData.DeleteAllItems();
//只显示测试成功的数据
if (EN_TASK_STATE_FINISH == pTaskItem->byTestStatus || EN_TASK_STATE_STOP_TEST == pTaskItem->byTestStatus)
{
strLog.Format(_T("zm:taskid=%s, taskname=%s,syn status = %d,test status=%d"), pTaskItem->szTaskID, pTaskItem->szTDName, pTaskItem->eSynStatus, pTaskItem->byTestStatus);
CFileOperTools::GetInstance()->WriteComLog(strLog);
//实时窗口未测试中的任务，50个点同步线程
std::vector<STTaskDetailBasicData> vtData;
m_taskOper.QueryOnLineTdDataToCtrl(m_stRealTimeTaskArg, vtData);
SendMessage(WM_TASK_LIST_TASK_DATA_SYN, (WPARAM)&vtData, 0);
}
strLog.Format(_T("zm:CDialOfflineDeviceTaskManager::UpdateRealTimeTaskListData end"));
CFileOperTools::GetInstance()->WriteComLog(strLog);
}
void CDialOfflineDeviceTaskManager::OnButtonDelTask()
{
SetPauseThread(true);
m_vtNeedDelLocalTaskID.clear();
m_vtNeedDelClounTaskID.clear();
//m_vtNeedDelTreeItem.clear();
CString strLog;
CDialDeleteTaskOption taskOptionDlg;
if (IDOK == taskOptionDlg.DoModal())
{
if (!taskOptionDlg.m_DeleteLocal && !taskOptionDlg.m_DeleteCloud)
{
return;
}
//遍历所有节点，判断是否勾选
HTREEITEM rootItem = m_dialTaskTree.m_treeTask.GetRootItem();
if (m_dialTaskTree.m_treeTask.ItemHasChildren(rootItem))
{
HTREEITEM childItem = m_dialTaskTree.m_treeTask.GetChildItem(rootItem);
STTaskListItem* pTaskItem = NULL;
while (childItem != NULL)
{
if (m_dialTaskTree.m_treeTask.GetCheck(childItem))
{
pTaskItem = (STTaskListItem*)m_dialTaskTree.m_treeTask.GetItemData(childItem);
if (NULL == pTaskItem)
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("获取任务数据ID错误"));
else
MessageBoxEx(NULL, _T("Can not find the test task.please select the task firstly"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
//m_vtNeedDelTreeItem.push_back(childItem);
if (EN_TASK_NO_UPLOAD != pTaskItem->eSynStatus)
{
std::vector<CString>::iterator iter = m_vtNeedDelClounTaskID.begin();
iter = find(m_vtNeedDelClounTaskID.begin(), m_vtNeedDelClounTaskID.end(), pTaskItem->szTaskID);
if (iter != m_vtNeedDelClounTaskID.end())
{
strLog.Format(_T("zm:Add cloud delete tasks to the collection, Cloud filter repeat taskid=%s"), pTaskItem->szTaskID);
}
else
{
strLog.Format(_T("zm:Add cloud delete tasks to the collection taskid=%s"), pTaskItem->szTaskID);
m_vtNeedDelClounTaskID.push_back(pTaskItem->szTaskID);
}
CFileOperTools::GetInstance()->WriteComLog(strLog);
}
if (EN_TASK_NO_DOWNLOAD != pTaskItem->eSynStatus)
{
std::vector<CString>::iterator iter = m_vtNeedDelLocalTaskID.begin();
iter = find(m_vtNeedDelLocalTaskID.begin(), m_vtNeedDelLocalTaskID.end(), pTaskItem->szTaskID);
if (iter != m_vtNeedDelLocalTaskID.end())
{
strLog.Format(_T("zm:Add local database delete tasks to the collection, Cloud filter repeat taskid=%s"), pTaskItem->szTaskID);
}
else
{
strLog.Format(_T("zm:Add local database delete tasks to the collection taskid=%s"), pTaskItem->szTaskID);
m_vtNeedDelLocalTaskID.push_back(pTaskItem->szTaskID);
}
CFileOperTools::GetInstance()->WriteComLog(strLog);
}
}
childItem = m_dialTaskTree.m_treeTask.GetNextSiblingItem(childItem);
}
}
//删除云端数据
if (taskOptionDlg.m_DeleteCloud && taskOptionDlg.m_DeleteLocal)//勾选云端和本地
{
if (m_vtNeedDelLocalTaskID.size() == 0 && m_vtNeedDelClounTaskID.size() == 0)
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("请先勾选数据"));
else
MessageBoxEx(NULL, _T("Please choose one task first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
DeleteTask();
OnMsgDeleteTask(0, 0);
}
else
{
if (taskOptionDlg.m_DeleteCloud)
{
if (m_vtNeedDelClounTaskID.size() == 0)
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("未勾选云端的任务"));
else
MessageBoxEx(NULL, _T("The cloud task is not checked"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
else
{
DeleteTask();
CString strLog;
int iDelNoCancelTestCount = m_vtDelNoCancelTest.size();
if (m_vtDelNoCancelTest.size() > 0)
{
if (g_iUILanguage == LANG_ZHCN)
strLog += _T("请取消测试后删除任务：");
else
strLog += _T("Please cancel the test and delete the task: ");
for (int i = 0; i < iDelNoCancelTestCount; i++)
{
strLog += m_vtDelNoCancelTest.at(i);
if (i != iDelNoCancelTestCount - 1)
{
strLog += _T(",");
}
else
{
strLog += _T(";");
}
}
}
int iFailedDelTaskIDCount = m_vtFailedDelTaskID.size();
if (m_vtFailedDelTaskID.size() > 0)
{
if (g_iUILanguage == LANG_ZHCN)
strLog += _T("未知错误：");
else
strLog += _T("unknown error: ");
for (int i = 0; i < iFailedDelTaskIDCount; i++)
{
strLog += m_vtFailedDelTaskID.at(i);
if (i != iFailedDelTaskIDCount - 1)
{
strLog += _T(",");
}
else
{
strLog += _T(";");
}
}
}
if (iDelNoCancelTestCount <= 0 && iFailedDelTaskIDCount <= 0)
{
if (g_iUILanguage == LANG_ZHCN)
AfxMessageBox(_T("删除任务成功"));
else
MessageBoxEx(NULL, _T("Delete task success"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
}
else
{
CString strTips;
if (g_iUILanguage == LANG_ZHCN)
{
strTips.Format(_T("删除云端任务失败,%s"), strLog);
AfxMessageBox(strTips);
}
else
{
strTips.Format(_T("Delete cloud task failed,%s"), strLog);
MessageBoxEx(NULL, strTips, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
}
}
OnMsgTaskRefreshList(0, 0);
}
}
if (taskOptionDlg.m_DeleteLocal)//删除本地数据
{
//传递删除的参数，判断是否还需要删除
if (m_vtNeedDelLocalTaskID.size() == 0)
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("未勾选本地的任务"));
else
MessageBoxEx(NULL, _T("Local task not checked"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
else
{
OnMsgDeleteTask(0, 0);
}
}
}
}
}
extern SYSTEMTIME g_sysCurTime;
UINT CDialOfflineDeviceTaskManager::DeleteTask()
{
CAutoLock clsAutoLock(theApp.m_NetWorkOper.GetNetCriticalSection());
CString strLog;
CString strTaskID;
char chStr[20] = { 0 };
char chSendStr[MAX_NAME_LEN + 1] = { 0 };
int iLen = 0;
theApp.m_NetWorkOper.SetSuspendForThread(true);
m_vtFailedDelTaskID.clear();
//m_vtDelTaskRunning.clear();
m_vtDelNoCancelTest.clear();
//获取云端需要删除的TaskID
CString strTime;
strTime.Format("%04d%02d%02d%02d%02d%02d", g_sysCurTime.wYear, g_sysCurTime.wMonth, g_sysCurTime.wDay, \
g_sysCurTime.wHour, g_sysCurTime.wMinute, g_sysCurTime.wSecond);
for (int i = 0; i < m_vtNeedDelClounTaskID.size(); i++)
{
strTaskID = m_vtNeedDelClounTaskID.at(i);
strncpy(chSendStr, strTaskID, MAX_NAME_LEN * sizeof(BYTE));
if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_TASK_DEL, 0xFFFFFFFF, 1, (char*)chSendStr, MAX_NAME_LEN))
{
theApp.m_NetWorkOper.SetSuspendForThread(false);
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("删除任务发送失败"));
else
MessageBoxEx(NULL, _T("Msg delete task send failed"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return 0;
}
strLog.Format(_T("zm:system time=%s request delete task count(%d),Num(%d) taskID=%s\n"),strTime, m_vtNeedDelClounTaskID.size(), i, chSendStr);
CFileOperTools::GetInstance()->WriteComLog(strLog);
if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chStr, &iLen, 20, 5000))
{
switch (chStr[0])
{
case FAILED_NO_ERROR:
break;
// case FAILED_TASK_IS_RUNNING:
// {
// strLog.Format(_T("zm:cloud delete task failed, task is running error=%d taskid=%s"), chStr[0], strTaskID);
// CFileOperTools::GetInstance()->WriteComLog(strLog);
// m_vtDelTaskRunning.push_back(strTaskID);
// }
// break;
case FAILED_LOOP_TASK_NO_CANCEL_TEST://正在测试中的任务和在等待的定时任务都是返回4
{
strLog.Format(_T("zm:cloud delete task failed, loop task is waitting error=%d taskid=%s"), chStr[0], strTaskID);
CFileOperTools::GetInstance()->WriteComLog(strLog);
m_vtDelNoCancelTest.push_back(strTaskID);
}
break;
default:
{
strLog.Format(_T("zm:cloud delete task failed, unknown error=%d taskid=%s"), chStr[0], strTaskID);
CFileOperTools::GetInstance()->WriteComLog(strLog);
m_vtFailedDelTaskID.push_back(strTaskID);
}
break;
}
}
}
theApp.m_NetWorkOper.SetSuspendForThread(false);
return 0;
}
BOOL CDialOfflineDeviceTaskManager::OnInitDialog()
{
CNetRequestDialog::OnInitDialog();
CString strTitle;
strTitle.Format(_T("SN%u"), m_dwDeviceSN);
this->SetWindowText(strTitle);
// TODO: Add extra initialization here
m_tabTaskChg.InsertItem(0, _T("VES TASK"));
m_tabTaskChg.InsertItem(1, _T("2D TASK"));
m_tabTaskChg.InsertItem(2, _T("3D TASK"));
m_iSelTaskType = 1;//默认选中二维任务列表
CRect rect;
m_tabTaskChg.GetClientRect(&rect);
rect.top += 2;
rect.left += 2;
rect.right -= 2;
rect.bottom -= 23;
m_dialTaskTree.m_uiGD10DevID = m_dwDeviceSN;
m_dialTaskTree.SetSptType(m_iSelTaskType);
m_dialTaskTree.Create(IDD_DIALOG_TASK_TREE, &m_tabTaskChg);
m_dialTaskTree.RegisterWnd(this);
m_dialTaskTree.MoveWindow(&rect);
m_dialTaskTree.ShowWindow(SW_SHOW);
CString strLog;
strLog.Format(_T("zm://////////CDialOfflineDeviceTaskManager::OnInitDialog init task list g_strSaveTestingTaskID=%s"), g_strSaveTestingTaskID);
CFileOperTools::GetInstance()->WriteComLog(strLog);
m_tabTaskChg.SetCurSel(m_iSelTaskType);
//初始化任务属性
InitialTaskListAttr();
//初始化任务数据
CRect rect2;
m_listTaskData.ShowWindow(FALSE);
m_dialRealTimeMeasuData.SetSptType(m_iSelTaskType);
m_dialRealTimeMeasuData.SetTaksID(0);
m_dialRealTimeMeasuData.SetDeviceID(0);
m_dialRealTimeMeasuData.Create(IDD_DIALOG_REAL_TIME_MEASURE_DATA, this);
m_listTaskData.GetWindowRect(&rect2);
ScreenToClient(&rect2);
m_dialRealTimeMeasuData.MoveWindow(&rect2);
// m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_NOT_SELECT_TASK);
m_dialRealTimeMeasuData.ShowWindow(SW_SHOW);
//隐藏实时窗口按钮
m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_OFFLINE_DEVICE);
m_strTaskStatusTips = _T("Task Data: ");
if (LANG_ZHCN == g_iUILanguage)
{
GetDlgItem(IDC_STATIC_START_TIME)->SetWindowTextA(_T("开始时间:"));
GetDlgItem(IDC_STATIC_END_TIME)->SetWindowTextA(_T("结束时间:"));
GetDlgItem(IDC_STATIC_TASK_LIST)->SetWindowText(_T("查询时间:"));
GetDlgItem(IDC_BTN_QUREY_TASK_LIST)->SetWindowTextA(_T("查询"));
m_strTaskStatusTips = _T("任务数据: ");
GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowText(m_strTaskStatusTips);
GetDlgItem(IDC_BUTTON_CREATE_TASK)->SetWindowText(_T("创建任务"));
GetDlgItem(IDC_BUTTON_DEL_TASK)->SetWindowText(_T("删除任务"));
GetDlgItem(IDC_BUTTON_MEASURE_TASK)->SetWindowText(_T("调试测量"));
GetDlgItem(IDC_BTN_DATA_DOWNLOAD)->SetWindowText(_T("数据下载"));
GetDlgItem(IDC_BTN_CREATE_TIMER_TASK)->SetWindowText(_T("新建定时任务"));
GetDlgItem(IDC_BTN_MANAGER_TIMER_TASK)->SetWindowText(_T("定时任务管理"));
}
CTime time;
CTime TDate;
time_t tTime;
CString strTime;
CString strDate;
m_StartTime.GetTime(TDate);
//strDate = TDate.Format("%Y-%m-%d"); //获取到的为日期 如：2010-03-05
strDate.Format("%4d-%2d-%2d", TDate.GetYear(), TDate.GetMonth(), TDate.GetDay() - 7);
strTime = time.Format(" 00:00:00");
strDate += strTime;
tTime = Str2GmtTm(strDate);
m_StartTime.SetTime(tTime);
m_EndTime.GetTime(TDate);
//strDate.Format(_T("%d-%d-%d"), TDate.GetYear(), TDate.GetMonth(), TDate.GetDay() + 3); //获取到的为日期 如：2010-03-05
strDate = TDate.Format("%Y-%m-%d");
strTime = time.Format(" 23:59:59");
strDate += strTime;
tTime = Str2GmtTm(strDate);
m_EndTime.SetTime(tTime);
m_taskOper.m_uiDevID = m_dwDeviceSN;
CString str;
str.Format(_T("zm:---------------theApp.m_NetWorkOper.RegeditRealMsgCall(this->m_hWnd=%0x)"), this->m_hWnd);
CFileOperTools::GetInstance()->WriteComLog(str);
theApp.m_NetWorkOper.RegeditRealMsgCall(this->m_hWnd);
//180s刷新一次任务列表
//SetTimer(ID_TIMER_HEARTBEAT_PACKET, HEARTBEAT_INTERVAL, NULL);
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
/*void CDialOfflineDeviceTaskManager::InitialTaskListData(int iTestType)
{
if (iTestType == m_iTestType)
{
return;
}
m_listTaskData.DeleteAllItems();
int iColumnCount = m_listTaskData.GetHeaderCtrl()->GetItemCount();
for(int i=0; i < iColumnCount; i++)
{
m_listTaskData.DeleteColumn(0);
}
m_iTestType = iTestType;
int iColIndex = 0;
m_listTaskData.InsertColumn(iColIndex++, _T("A"), LVCFMT_CENTER, 80);
m_listTaskData.InsertColumn(iColIndex++, _T("B"), LVCFMT_CENTER, 80);
m_listTaskData.InsertColumn(iColIndex++, _T("M"), LVCFMT_CENTER, 80);
m_listTaskData.InsertColumn(iColIndex++, _T("N"), LVCFMT_CENTER, 80);
m_listTaskData.InsertColumn(iColIndex++, _T("Stack"), LVCFMT_CENTER, 80);
m_listTaskData.InsertColumn(iColIndex++, "K", LVCFMT_CENTER, 120);
m_listTaskData.InsertColumn(iColIndex++, "V(mV)", LVCFMT_CENTER, 120);
m_listTaskData.InsertColumn(iColIndex++, "I(mA)", LVCFMT_CENTER, 120);
if (0 == iTestType)
{
m_listTaskData.InsertColumn(iColIndex++, "R(Ohm)", LVCFMT_CENTER, 120);
}
m_listTaskData.InsertColumn(iColIndex++, "R0(Ohm*m)", LVCFMT_CENTER, 120);
m_listTaskData.InsertColumn(iColIndex++, "SP(mV)", LVCFMT_CENTER, 120);
}
*/
void CDialOfflineDeviceTaskManager::InitialTaskListAttr()
{
CString strColTitle;
m_listTaskAttr.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP
| LVS_EX_ONECLICKACTIVATE | LVS_EX_GRIDLINES);
CRect rectTask;
m_listTaskAttr.GetClientRect(&rectTask);
int iListWidth = rectTask.right - rectTask.left;
m_listTaskAttr.InsertColumn(0, _T(""), LVCFMT_RIGHT, 1);
if (LANG_ENUS == g_iUILanguage)
{
m_listTaskAttr.InsertColumn(1, _T("Attribute"), LVCFMT_RIGHT, 150);
m_listTaskAttr.InsertColumn(2, _T("Value"), LVCFMT_LEFT, iListWidth-170);
}
else
{
m_listTaskAttr.InsertColumn(1, _T("任务属性"), LVCFMT_RIGHT, 150);
m_listTaskAttr.InsertColumn(2, _T("属性值"), LVCFMT_LEFT, iListWidth - 170);
}
int iItemIndex = 0;
strColTitle.Empty();
strColTitle.LoadString(IDS_DB_TD_TDNAME + g_UIOffset);
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);
iItemIndex++;
strColTitle.Empty();
strColTitle.LoadString(IDS_DB_TD_CN + g_UIOffset);
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);
iItemIndex++;
strColTitle.Empty();
strColTitle.LoadString(IDS_DB_SCON_SNAME + g_UIOffset);
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);
iItemIndex++;
strColTitle.Empty();
strColTitle.LoadString(IDS_DB_SCON_STYPE + g_UIOffset);
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);
iItemIndex++;
strColTitle.Empty();
strColTitle.LoadString(IDS_DB_TD_TMODE + g_UIOffset);
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);
iItemIndex++;
strColTitle.Empty();
strColTitle.LoadString(IDS_ARRAY_TYPE + g_UIOffset);
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);
iItemIndex++;
strColTitle.Empty();
strColTitle.LoadString(IDS_DB_SCON_EAMOUNT + g_UIOffset);
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);
iItemIndex++;
strColTitle.Empty();
strColTitle.LoadString(IDS_DB_SCON_TPAMOUNT + g_UIOffset);
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);
iItemIndex++;
strColTitle.Empty();
strColTitle.LoadString(IDS_DB_SCRIPT_N + g_UIOffset);
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);
iItemIndex++;
strColTitle.Empty();
strColTitle.LoadString(IDS_DB_TD_TRWAVE + g_UIOffset);
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);
iItemIndex++;
strColTitle.Empty();
strColTitle.LoadString(IDS_DB_TD_TRFREQUENCY + g_UIOffset);
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);
iItemIndex++;
strColTitle.Empty();
strColTitle.LoadString(IDS_DB_TD_CLAYOUT + g_UIOffset);
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);
iItemIndex++;
strColTitle.Empty();
strColTitle.LoadString(IDS_DB_TD_EDISTANCE + g_UIOffset);
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);
if (LANG_ZHCN == g_iUILanguage)
{
iItemIndex++;
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, _T("数据下载记录"));
iItemIndex++;
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, _T("最近任务下载时间"));
iItemIndex++;
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, _T("云端最近测试时间"));
iItemIndex++;
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, _T("创建任务时间"));
iItemIndex++;
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, _T("是否测试接地电阻"));
iItemIndex++;
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, _T("测试失败的原因"));
}
else
{
iItemIndex++;
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, _T("Data download record"));
iItemIndex++;
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, _T("Latest download time"));
iItemIndex++;
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, _T("Clouding lastest time"));
iItemIndex++;
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, _T("Create time"));
iItemIndex++;
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, _T("Whether the GR test?"));
iItemIndex++;
m_listTaskAttr.InsertItem(iItemIndex, _T(""));
m_listTaskAttr.SetItemText(iItemIndex, 1, _T("Test failed reason"));
}
}
LRESULT CDialOfflineDeviceTaskManager::OnClickTaskTree(WPARAM wParam, LPARAM lParam)
{
//SetPauseThread(true);
m_vtNeedSynTaskID.clear();
STTaskListItem* pTaskItem = (STTaskListItem*)wParam;
if (NULL == pTaskItem)
{
return 0;
}
m_dialRealTimeMeasuData.SetTaksID(pTaskItem->szTaskID);
m_dialRealTimeMeasuData.SetTaskListSelectItem(pTaskItem);
m_dialRealTimeMeasuData.SetTestingTaskID(g_strSaveTestingTaskID);
CString strLog;
strLog.Format(_T("zm://////////CDialOfflineDeviceTaskManager::OnClickTaskTree select task Item g_strSaveTestingTaskID=%s"), g_strSaveTestingTaskID);
CFileOperTools::GetInstance()->WriteComLog(strLog);
m_dialRealTimeMeasuData.m_uiPlcID = m_dwPLCID;
m_dialRealTimeMeasuData.m_uiDevID = m_dwDeviceSN;
if (g_strSaveTestingTaskID.IsEmpty())
{
//调试测量按钮状态可点击
GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips);
GetDlgItem(IDC_BUTTON_MEASURE_TASK)->EnableWindow(TRUE);
//m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_SELECT_TASK);
}
else
{
//调试测量按钮状态不可点击
GetDlgItem(IDC_BUTTON_MEASURE_TASK)->EnableWindow(FALSE);
if (strcmp(g_strSaveTestingTaskID, pTaskItem->szTaskID) != 0)
{
GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips);
//m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_NOT_TESTING_TASK);
}
else
{
//正在测试中的任务清空实时窗口之前的数据
if (pTaskItem->byTestStatus == 10)//任务初始化状态
{
if (LANG_ZHCN == g_iUILanguage)
{
GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips + _T("任务初始化..."));
}
else
{
GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips + _T("Task initialization..."));
}
}
else if (pTaskItem->byTestStatus == 11)
{
if (LANG_ZHCN == g_iUILanguage)
{
GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips + _T("测试接地电阻和测试数据中..."));
}
else
{
GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips + _T("Test ground resistance and test data..."));
}
}
else
{
GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips);
}
m_dialRealTimeMeasuData.m_dialListMeasuTask.m_listData.DeleteAllItems();
//m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_MEASU_ALL);
}
}
memcpy(&m_dialRealTimeMeasuData.m_stTaskItem, pTaskItem, sizeof(STTaskListItem));
if (EN_TASK_NO_UPLOAD == pTaskItem->eSynStatus)//本地未上传任务
{
m_taskOper.QueryTdAttrToCtrl(m_listTaskAttr, atoi(pTaskItem->szTaskID));
//int iTtype = m_taskOper.GetCurSelTdTestType();
//InitialTaskListData(iTtype);
//m_taskOper.QueryTdDataToCtrl(m_listTaskData, atoi(pTaskItem->szTaskID), m_iSelTaskType, iTtype);
}
else
{
//点击任务列表某个任务，同步任务信息
m_vtNeedSynTaskID.push_back(*pTaskItem);
//AfxBeginThread(DealTaskInfoSynThread, this);
OnSynCouldTaskInfoRequest(m_vtNeedSynTaskID);
}
return 0;
}
//实时接收测试中任务点信息
/*UINT CDialOfflineDeviceTaskManager::DealTaskTestingSynThread(LPVOID pParam)
{
return 1;
CDialOfflineDeviceTaskManager* pThis = (CDialOfflineDeviceTaskManager*)pParam;
if (NULL == pThis)
{
return 0;
}
Sleep(200);
//CAutoLock autoLock(&pThis->m_cs);
int iMaxSynNum = 50;
char chStr[500];
int iLen = 0;
UINT32 uiStartID = 0;
BYTE ucPointNum = 0;
char szTaskID[MAX_NAME_LEN];
STRemTaskArg stTaskArg; //记录上一次任务以防任务变更
bool bPauseFlg = false; //记录上一次线程暂停标志
char *pData = (char *)malloc(sizeof(char)*4096);
if (NULL == pData)
{
return 0;
}
std::vector<STTaskDetailBasicData> vtData;
theApp.m_NetWorkOper.SetSuspendForThread(true);
while (pThis->m_bThreadIsRunning)
{
if (pThis->m_bThreadIsPause)
{
bPauseFlg = true;
theApp.m_NetWorkOper.SetSuspendForThread(false);
Sleep(30);
continue;
}
if (true == bPauseFlg)
{
theApp.m_NetWorkOper.SetSuspendForThread(true);
bPauseFlg = false;
}
// if (pThis->m_bThreadIsExit)
// {
// break;
// }
if (0 != strcmp(stTaskArg.ucTaskID, pThis->m_stRealTimeTaskArg.ucTaskID))
{
memcpy(&stTaskArg, &pThis->m_stRealTimeTaskArg, sizeof(STRemTaskArg));
}
if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chStr, &iLen, sizeof(chStr), 1000))
{
ucPointNum = chStr[sizeof(char)*MAX_NAME_LEN];
int iPackLen = (ucPointNum*sizeof(STMeasuDataResBasic))+sizeof(char)*MAX_NAME_LEN + sizeof(char);
if (0 >= iLen || iLen != iPackLen || 0 >= ucPointNum) //长度和转发点数判断
{
Sleep(10);
continue;
}
STMeasuDataResBasic *pMeasuDataRes = (STMeasuDataResBasic *)&chStr[sizeof(char)*MAX_NAME_LEN + sizeof(char)];
memcpy(szTaskID, chStr, sizeof(sizeof(char)*MAX_NAME_LEN));
if ((0 >= ntohl(pMeasuDataRes->iID) || 100000 < ntohl(pMeasuDataRes->iID))
|| 0 != strcmp(szTaskID, stTaskArg.ucTaskID))//点数ID和任务ID判断
{
Sleep(10);
continue;
}
if (0 == uiStartID || ntohl(pMeasuDataRes->iID) > uiStartID + iMaxSynNum) //从云端获取ABMN信息，便于动态显示，每50点获取一次
{
int i;
for (i = 0; i < 3; i++)//失败获取三次
{
if (true == pThis->m_taskOper.QueryOnLineTdDataFromSev(stTaskArg, pMeasuDataRes->iID, pMeasuDataRes->iID + iMaxSynNum, pData))
{
uiStartID = ntohl(pMeasuDataRes->iID);
break;
}
Sleep(10);
}
theApp.m_NetWorkOper.SetSuspendForThread(true);
if (3 <= i) //未获取数据信息
{
break;
}
}
vtData.clear();
for (int i = 0; i < ucPointNum; i++)
{
int iSevDataIndex = pMeasuDataRes->iID - uiStartID + i;
STTaskDataRes *ptTaskData = (STTaskDataRes *)&pData[MAX_NAME_LEN * sizeof(BYTE)+sizeof(UINT32)+iSevDataIndex*sizeof(STTaskDataRes)];
STMeasuDataResBasic *pMeasuData = &pMeasuDataRes[sizeof(STMeasuDataResBasic)*i];
STTaskDataRes stMeasuBasicData;
stMeasuBasicData.dwID = ntohl(ptTaskData->dwID);
stMeasuBasicData.fA = tcp_ntohf(ptTaskData->fA);
stMeasuBasicData.fB = tcp_ntohf(ptTaskData->fB);
stMeasuBasicData.fM = tcp_ntohf(ptTaskData->fM);
stMeasuBasicData.fN = tcp_ntohf(ptTaskData->fN);
stMeasuBasicData.fK = tcp_ntohf(stMeasuBasicData.fK);
stMeasuBasicData.fV = tcp_ntohf(stMeasuBasicData.fV);
stMeasuBasicData.fI = tcp_ntohf(stMeasuBasicData.fI);
stMeasuBasicData.fR0 = tcp_ntohf(stMeasuBasicData.fR0);
stMeasuBasicData.fSP = tcp_ntohf(stMeasuBasicData.fSP);
stMeasuBasicData.ucAlram = stMeasuBasicData.ucAlram;
stMeasuBasicData.ucStack = stMeasuBasicData.ucStack;
stMeasuBasicData.fR0_LC = tcp_ntohf(stMeasuBasicData.fR0_LC);
STTaskDetailBasicData stTaskDetailData;
stTaskDetailData.iID = stMeasuBasicData.dwID;
stTaskDetailData.iA = stMeasuBasicData.fA;
stTaskDetailData.iB = stMeasuBasicData.fB;
stTaskDetailData.iM = stMeasuBasicData.fM;
stTaskDetailData.iN = stMeasuBasicData.fN;
stTaskDetailData.fK = stMeasuBasicData.fK;
stTaskDetailData.fV = stMeasuBasicData.fV;
stTaskDetailData.fI = stMeasuBasicData.fI;
stTaskDetailData.fR0 = stMeasuBasicData.fR0;
stTaskDetailData.fSP = stMeasuBasicData.fSP;
stTaskDetailData.ucStack = stMeasuBasicData.ucStack;
stTaskDetailData.ucIsUse = 1;// stMeasuBasicData.ucAlram;
vtData.push_back(stTaskDetailData);
}
pThis->SendMessage(WM_TASK_LIST_TASK_DATA_SYN, (WPARAM)&vtData, 1);
}
Sleep(10);
}
theApp.m_NetWorkOper.SetSuspendForThread(false);
if (NULL != pData)
{
free(pData);
}
return 0;
}*/
LRESULT CDialOfflineDeviceTaskManager::OnMsgTaskListTaskDataSyn(WPARAM wParam, LPARAM lParam)
{
std::vector<STTaskDetailBasicData>* vtData = (std::vector<STTaskDetailBasicData>*)wParam;
int iTeatingFlg = (int)lParam;//==1为测试中的任务
int iTaskCount = vtData->size();
if (iTaskCount <= 0)
{
return 0;
}
if (1 != iTeatingFlg)
{
m_dialRealTimeMeasuData.m_dialListMeasuTask.OnShowTdData(*vtData);
}
else
{
CFileOperTools::GetInstance()->WriteComLog(_T("zm: CDialOfflineDeviceTaskManager::OnMsgTaskListTaskDataSyn iTeatingFlg == 1 testing data"));
m_dialRealTimeMeasuData.m_dialListMeasuTask.SetRealTimeCurrentTaskArg(this->m_hWnd, m_stRealTimeTaskArg);
//EN_TASK_TESTING_METHOD eTestting = m_dialRealTimeMeasuData.GetTestingMethod();
if (g_eTestingMethod == EN_TASK_FROM_CURRENT_POINT_TEST || g_eTestingMethod == EN_TASK_CURRENT_ONE_POINT_TEST)//单点测量和从当前测量，如果已经测了的点，直接修改值
{
//遍历修改点
//m_dialRealTimeMeasuData.m_dialListMeasuTask.SetTestingMethod(g_eTestingMethod);
m_dialRealTimeMeasuData.m_dialListMeasuTask.OnShowTdDataUpdate(*vtData);
}
else
{
//追加
m_dialRealTimeMeasuData.m_dialListMeasuTask.OnShowTdDataAppend(*vtData);
}
}
return 0;
}
LRESULT CDialOfflineDeviceTaskManager::OnMsgTaskRefreshList(WPARAM wParam, LPARAM lParam)
{
m_dialTaskTree.ShowTaskTree(m_iSelTaskType);
OnMsgUpdateRealTimeWndBtnStatus(0, 0);
return 0;
}
/*
*lParam 0需要更新实时窗口的按钮状态，反之非0
*/
LRESULT CDialOfflineDeviceTaskManager::OnMsgUpdateRealTimeWndBtnStatus(WPARAM wParam, LPARAM lParam)
{
CString strLog;
strLog.Format(_T("zm:update realtime wnd button status g_strSaveTestingTaskID=%s"), g_strSaveTestingTaskID);
CFileOperTools::GetInstance()->WriteComLog(strLog);
if (lParam == 0)
{
if (g_strSaveTestingTaskID.IsEmpty())
{
//调试测量按钮状态可点击
GetDlgItem(IDC_BUTTON_MEASURE_TASK)->EnableWindow(TRUE);
//m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_SELECT_TASK);
}
else
{
//调试测量按钮状态不可点击
GetDlgItem(IDC_BUTTON_MEASURE_TASK)->EnableWindow(FALSE);
if (g_eTestingMethod == EN_TASK_SUSPENDED)
{
//调试测量按钮状态可点击
GetDlgItem(IDC_BUTTON_MEASURE_TASK)->EnableWindow(TRUE);
//m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_SELECT_TASK);
}
else
{
CString strSelectTask = _T("");
HTREEITEM hSelectItem = m_dialTaskTree.m_treeTask.GetSelectedItem();
if (hSelectItem != NULL)
{
STTaskListItem* pTaskItem = (STTaskListItem*)m_dialTaskTree.m_treeTask.GetItemData(hSelectItem);
if (pTaskItem != NULL)
{
strSelectTask = pTaskItem->szTaskID;
}
}
if (strcmp(g_strSaveTestingTaskID, strSelectTask) != 0)
{
//m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_NOT_TESTING_TASK);
}
else
{
//正在测试中的任务清空实时窗口之前的数据
//m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_MEASU_ALL);
}
}
}
}
else
{
//本地操作后服务器没有那么快响应
// if (g_strSaveTestingTaskID.IsEmpty())
// {
// //调试测量按钮状态可点击
// GetDlgItem(IDC_BUTTON_MEASURE_TASK)->EnableWindow(TRUE);
// }
// else
// {
//调试测量按钮状态不可点击
GetDlgItem(IDC_BUTTON_MEASURE_TASK)->EnableWindow(FALSE);
// }
}
return 0;
}
LRESULT CDialOfflineDeviceTaskManager::OnMsgSetCurrentSelectTask(WPARAM wParam, LPARAM lParam)
{
if (wParam == NULL)
{
ASSERT(wParam != NULL);
return 0;
}
STTaskListItem* pTaskItem = (STTaskListItem*)wParam;
if (pTaskItem != NULL)
{
//memcpy(&m_SelectTaskItem, pTaskItem, sizeof(STTaskListItem));
m_dialRealTimeMeasuData.SetTaksID(pTaskItem->szTaskID);
m_dialRealTimeMeasuData.SetTaskListSelectItem(pTaskItem);
m_dialRealTimeMeasuData.SetTestingTaskID(g_strSaveTestingTaskID);
CString strLog;
strLog.Format(_T("zm:CDialOfflineDeviceTaskManager::OnMsgSetCurrentSelectTask select task notify realtime wnd g_strSaveTestingTaskID=%s，test status =%d"), g_strSaveTestingTaskID,pTaskItem->szTaskID);
CFileOperTools::GetInstance()->WriteComLog(strLog);
m_dialRealTimeMeasuData.m_uiPlcID = m_dwPLCID;
m_dialRealTimeMeasuData.m_uiDevID = m_dwDeviceSN;
}
return 0;
}
void CDialOfflineDeviceTaskManager::OnCmdTaskCancelTest()
{
HTREEITEM hItem = m_dialTaskTree.m_treeTask.GetSelectedItem();
if (NULL == hItem)
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("请先选择数据"));
else
MessageBoxEx(NULL, _T("Please select data first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
//遍历所有节点，判断是否勾选
std::vector<CString> vtCancelTestTaskID;
std::vector<CString> vtNoCancelTestTaskID;//不能取消测试的任务
HTREEITEM rootItem = m_dialTaskTree.m_treeTask.GetRootItem();
if (m_dialTaskTree.m_treeTask.ItemHasChildren(rootItem))
{
HTREEITEM childItem = m_dialTaskTree.m_treeTask.GetChildItem(rootItem);
STTaskListItem* pTaskItem = NULL;
while (childItem != NULL)
{
if (m_dialTaskTree.m_treeTask.GetCheck(childItem))
{
pTaskItem = (STTaskListItem*)m_dialTaskTree.m_treeTask.GetItemData(childItem);
if (NULL == pTaskItem)
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("获取任务数据ID错误"));
else
MessageBoxEx(NULL, _T("Can not find the test task.please select the task firstly"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
if (pTaskItem->byTestStatus == EN_TASK_STATE_TEST_FAILED || pTaskItem->byTestStatus == EN_TASK_STATE_FINISH) //测试完成或测试失败的不能取消测试
{
vtNoCancelTestTaskID.push_back(pTaskItem->szTaskID);
}
else
{
vtCancelTestTaskID.push_back(pTaskItem->szTaskID);
}
}
childItem = m_dialTaskTree.m_treeTask.GetNextSiblingItem(childItem);
}
}
int iTaskCount = 0;
//不能取消测试的任务提示
iTaskCount = vtNoCancelTestTaskID.size();
if (iTaskCount > 0)
{
if (g_iUILanguage == LANG_ZHCN)
{
AfxMessageBox(_T("测试完成或测试失败的任务，不能取消测试"), MB_OK);
}
else
{
MessageBoxEx(NULL, _T("Tests that complete or fail cannot be canceled"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
}
return;
}
iTaskCount = vtCancelTestTaskID.size();
if (iTaskCount == 0)
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("请先勾选数据"));
else
MessageBoxEx(NULL, _T("Please choose one task first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
theApp.m_NetWorkOper.SetSuspendForThread(true);
CString strTaskCN;
CString szMsg;
char chStr[20] = { 0 };
char chSendStr[MAX_NAME_LEN + sizeof(UINT32) + 1] = { 0 };
int iLen = 0;
m_bLastCancelTask = FALSE;
for (int i = 0; i < iTaskCount; i++)
{
strTaskCN = vtCancelTestTaskID.at(i);
if (strcmp(strTaskCN, g_strSaveTestingTaskID) == 0)
{
m_bCancelTestingTask = TRUE;
}
else
{
m_bCancelTestingTask = FALSE;
}
if (i == iTaskCount - 1)
{
m_bLastCancelTask = TRUE;
}
strncpy(chSendStr, strTaskCN, MAX_NAME_LEN * sizeof(BYTE));
PostNetRequest(EN_CANCEL_COLLOCATION, this->m_hWnd, (char*)chSendStr, MAX_NAME_LEN);
// if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_CANCEL_COLLOCATION, 0xFFFFFFFF, 1, (char*)chSendStr, MAX_NAME_LEN))
// {
// theApp.m_NetWorkOper.SetSuspendForThread(false);
// AfxMessageBox(_T("Cancel task send failed."));
// continue;
// }
// if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chStr, &iLen, 20, 5000))
// {
// if ((iLen < iLen) || (EN_RECV_SUCCESS != chStr[0]))
// {
// theApp.m_NetWorkOper.SetSuspendForThread(false);
// szMsg.Format(_T("Task '%s' cancel trustee to failed."), strTaskCN);
// AfxMessageBox(szMsg);
// continue;
// }
// }
}
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("任务取消测试成功"));
else
MessageBoxEx(NULL, _T("Task cancel trustee to succeed"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
theApp.m_NetWorkOper.SetSuspendForThread(false);
}
void CDialOfflineDeviceTaskManager::OnSelchangeTabTaskChg(NMHDR* pNMHDR, LRESULT* pResult)
{
//SetPauseThread(true);
// TODO: Add your control notification handler code here
if (m_iSelTaskType == m_tabTaskChg.GetCurSel())
{
return;
}
m_iSelTaskType = m_tabTaskChg.GetCurSel();
OnMsgTaskRefreshList(0, 0);
//m_dialTaskTree.ShowTaskTree(m_iSelTaskType);
CString strLog;
strLog.Format(_T("zm://////////CDialOfflineDeviceTaskManager::OnSelchangeTabTaskChg g_strSaveTestingTaskID=%s"), g_strSaveTestingTaskID);
CFileOperTools::GetInstance()->WriteComLog(strLog);
//m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_NOT_SELECT_TASK);
*pResult = 0;
}
void CDialOfflineDeviceTaskManager::OnBtnQueryTaskList()
{
CTime time;
CTime TDate;
time_t tStartTime,tEndTime;
CString strTime;
CString strDate;
m_StartTime.GetTime(TDate);
//m_CDTTimeStart.GetTime(time);
strDate = TDate.Format("%Y-%m-%d"); //获取到的为日期 如：2010-03-05
strTime = time.Format(" 00:00:00");
strDate += strTime;
tStartTime = Str2GmtTm(strDate);
//request.uStartTime = htonl(tTime); //开始测试时间
CString strLog;
//strLog.Format(_T("zm:PLC status:strDate=%s,stLoopTaskInfo.uiStartTime=%u"), strDate, request.uStartTime);
//CFileOperTools::GetInstance()->WriteComLog(strLog);
m_EndTime.GetTime(TDate);
//m_CDTTimeEnd.GetTime(time);
strDate = TDate.Format("%Y-%m-%d"); //获取到的为日期 如：2010-03-05
strTime = time.Format(" 23:59:59");
strDate += strTime;
tEndTime = Str2GmtTm(strDate);
if (tStartTime > tEndTime)
{
if (g_iUILanguage == LANG_ZHCN)
AfxMessageBox(_T("开始时间大于结束时间"));
else
MessageBoxEx(NULL, _T("Start time is greater than end time"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
m_dialTaskTree.ShowTaskTree(m_iSelTaskType, tStartTime, tEndTime);
//request.uEndTime = htonl(tTime); //结束测试时间
}
void CDialOfflineDeviceTaskManager::OnButtonMeasureTask()
{
// TODO: Add your control notification handler code here
//SetPauseThread(true);
HTREEITEM hItem = m_dialTaskTree.m_treeTask.GetSelectedItem();
if (NULL == hItem || m_dialTaskTree.m_treeTask.GetRootItem() == hItem)
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("请先选择任务"));
else
MessageBoxEx(NULL, _T("Please select task firstly"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return ;
}
STTaskListItem* pTaskItem = (STTaskListItem *)m_dialTaskTree.m_treeTask.GetItemData(hItem);
if (pTaskItem == NULL)
{
ASSERT(pTaskItem != NULL);
return;
}
//if ()//需区分ID进行判断
// {
// dwTdID = atoi(Task->szTaskID);
// }
//else
{
//已同步的需查库获取ID
}
if (EN_TASK_NO_DOWNLOAD == pTaskItem->eSynStatus)
{
if (g_iUILanguage == LANG_ZHCN)
AfxMessageBox(_T("请下载后调试"));
else
MessageBoxEx(NULL, _T("Please choose a downloaded task"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
g_bIsOnlineTransfer = FALSE;
CDialMeasureData dialMeasuData;
dialMeasuData.SetTaksID(0);
dialMeasuData.SetTaskID(pTaskItem->szTaskID);
dialMeasuData.SetDeviceID(m_dwDeviceSN);
theApp.m_NetWorkOper.UnRegeditRealMsgCall(this->m_hWnd);
dialMeasuData.DoModal();
theApp.m_NetWorkOper.RegeditRealMsgCall(this->m_hWnd);
g_bIsOnlineTransfer = TRUE;
//m_taskOper.QueryTdDataToCtrl(m_listTaskData, dwTdID, m_iSelTaskType, m_iTestType);
}
//数据下载
void CDialOfflineDeviceTaskManager::OnBtnDataDownload()
{
HTREEITEM hItem = m_dialTaskTree.m_treeTask.GetSelectedItem();
if (NULL == hItem)
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("请先选择任务"));
else
MessageBoxEx(NULL, _T("Please select the task first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
//遍历所有节点，判断是否勾选
HTREEITEM rootItem = m_dialTaskTree.m_treeTask.GetRootItem();
std::vector<STTaskListItem> vtDownloadTaskItem;
if (m_dialTaskTree.m_treeTask.ItemHasChildren(rootItem))
{
HTREEITEM childItem = m_dialTaskTree.m_treeTask.GetChildItem(rootItem);
STTaskListItem* pTaskItem;
std::vector<HTREEITEM> vtDelTreeItem;
while (childItem != NULL)
{
if (m_dialTaskTree.m_treeTask.GetCheck(childItem))
{
pTaskItem = (STTaskListItem*)m_dialTaskTree.m_treeTask.GetItemData(childItem);
if (NULL == pTaskItem)
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("获取任务数据ID错误"));
else
MessageBoxEx(NULL, _T("Can not find the test task.please select the task firstly"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
vtDelTreeItem.push_back(childItem);
vtDownloadTaskItem.push_back(*pTaskItem);
}
childItem = m_dialTaskTree.m_treeTask.GetNextSiblingItem(childItem);
}
if (vtDownloadTaskItem.size() == 0)
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("请先勾选数据"));
else
MessageBoxEx(NULL, _T("Please choose one task first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
//下载数据
CDownloadDataProgressDlg downloadProcessDlg(&vtDownloadTaskItem,&m_taskOper,this);
downloadProcessDlg.SetDeviceID(m_dwDeviceSN);
downloadProcessDlg.DoModal();
//刷新列表
OnMsgTaskRefreshList(0, 0);
}
}
//新建定时任务
void CDialOfflineDeviceTaskManager::OnBtnCreateTimerTask()
{
//SetPauseThread(true);
HTREEITEM hItem = m_dialTaskTree.m_treeTask.GetSelectedItem();
if (NULL == hItem)
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("请先勾选已上传的任务"));
else
MessageBoxEx(NULL, _T("Please choose one task first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
DialUploadLoopTask* pUploadLoopTaskDlg = new DialUploadLoopTask();
if (pUploadLoopTaskDlg == NULL)
{
return;
}
//遍历所有节点，判断是否勾选
HTREEITEM rootItem = m_dialTaskTree.m_treeTask.GetRootItem();
if (m_dialTaskTree.m_treeTask.ItemHasChildren(rootItem))
{
HTREEITEM childItem = m_dialTaskTree.m_treeTask.GetChildItem(rootItem);
CString strTips;
STTaskListItem* pTaskItem = NULL;
while (childItem != NULL)
{
if (m_dialTaskTree.m_treeTask.GetCheck(childItem))
{
pTaskItem = (STTaskListItem*)m_dialTaskTree.m_treeTask.GetItemData(childItem);
if (pTaskItem && EN_TASK_NO_UPLOAD == pTaskItem->eSynStatus)
{
if (LANG_ZHCN == g_iUILanguage)
{
strTips.Format(_T("任务：%s未上传，创建定时任务失败"), pTaskItem->szTDName);
AfxMessageBox(strTips);
}
else
{
strTips.Format(_T("Task：%s no upload，create timer task failed"), pTaskItem->szTDName);
MessageBoxEx(NULL, strTips, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
}
return;
}
pUploadLoopTaskDlg->m_TaskList.AddTail(*pTaskItem);
}
childItem = m_dialTaskTree.m_treeTask.GetNextSiblingItem(childItem);
}
}
int iTaskCount = pUploadLoopTaskDlg->m_TaskList.GetCount();
if (0 == iTaskCount)
{
if (LANG_ZHCN == g_iUILanguage)
{
AfxMessageBox(_T("请先勾选已上传的任务"));
}
else
{
MessageBoxEx(NULL, _T("Please choose one task first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
}
delete pUploadLoopTaskDlg;
return;
}
else if (iTaskCount > 20)
{
CString strTips;
if (LANG_ZHCN == g_iUILanguage)
{
strTips.Format(_T("定时任务最多不超过20个"));
AfxMessageBox(strTips);
}
else
{
strTips.Format(_T("No more than 20 scheduled tasks"));
MessageBoxEx(NULL, strTips, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
}
delete pUploadLoopTaskDlg;
return;
}
pUploadLoopTaskDlg->SetDeviceID(m_dwDeviceSN);
pUploadLoopTaskDlg->SetPLCID(m_dwPLCID);
pUploadLoopTaskDlg->DoModal();
if (pUploadLoopTaskDlg != NULL)
{
delete[] pUploadLoopTaskDlg;
pUploadLoopTaskDlg = NULL;
}
}
//管理定时任务
void CDialOfflineDeviceTaskManager::OnBtnManageTimerTask()
{
//SetPauseThread(true);
CDialManageLoopTask manageTimerTask;
manageTimerTask.SetDeviceID(m_dwDeviceSN);
manageTimerTask.SetPLCID(m_dwPLCID);
manageTimerTask.DoModal();
}
void CDialOfflineDeviceTaskManager::PreNetResponse(WPARAM wParam, LPARAM lParam)
{
LPRESPONSEPACKET pResponsePacket = (LPRESPONSEPACKET)lParam;
if (pResponsePacket == NULL)
{
return;
}
switch (pResponsePacket->clsPacketBase.ucCmd)
{
case EN_REQ_TASK_DEL://删除任务响应
{
//删除本地及树型控件列表数据,如果客户端不想保存数据的话，需要服务器返回删除的ID
OnDeleteTaskResponse(wParam, lParam);
}
break;
case EN_REQ_DOWNLOAD_TASK_ARG://任务参数信息响应
{
OnSynCouldTaskInfoResponse(wParam, lParam);
}
break;
case EN_CANCEL_COLLOCATION:
{
if ((pResponsePacket->wDataLen < 0) || (EN_RECV_SUCCESS != pResponsePacket->pData[0]))
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("任务取消测试失败"));
else
MessageBoxEx(NULL, _T("Task cancel trustee to failed."), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
return;
}
//取消测试正在运行中的任务后,更新值
if (m_bCancelTestingTask)
{
g_strSaveTestingTaskID.Empty();
}
//刷新列表
if (m_bLastCancelTask)
{
OnMsgTaskRefreshList(0, 0);
}
CString strLog;
strLog.Format(_T("zm://////////CDialOfflineDeviceTaskManager::PreNetResponse cancel trust task g_strSaveTestingTaskID=%s"), g_strSaveTestingTaskID);
CFileOperTools::GetInstance()->WriteComLog(strLog);
}
break;
/*case EN_REQ_HEART_BEAT_PACKET:
{
CString strLog, strTime;
CTime t = CTime::GetCurrentTime();
strTime = t.Format("%Y-%m-%d,%H:%M:%S:");
strLog.Format(_T("zm:time:%s Geomative recv heart beat from Sever"), strTime);
OutputDebugString(strLog);
}*/
break;
default:
break;
}
}
BOOL CDialOfflineDeviceTaskManager::OnSynCouldTaskInfoRequest(std::vector<STTaskListItem> vtSynTaskID)
{
int iTaskNum = vtSynTaskID.size();
if (iTaskNum <= 0)
{
return FALSE;
}
int iSendLen = sizeof(UINT32) + iTaskNum*sizeof(BYTE)*MAX_NAME_LEN;
char chSendStr[210] = { 0 };
chSendStr[3] = iTaskNum;
int iLenIndex = sizeof(UINT32);
STTaskListItem taskItem;
for (int i = 0; i < iTaskNum; i++)
{
taskItem = vtSynTaskID.at(i);
strncpy(&chSendStr[iLenIndex + i*MAX_NAME_LEN], taskItem.szTaskID, MAX_NAME_LEN*sizeof(BYTE));
}
CString strLog;
strLog.Format(_T("zm:click treectrl item(taskid=%s) request download task arg"), taskItem.szTaskID);
OutputDebugString(strLog);
CFileOperTools::GetInstance()->WriteComLog(strLog);
PostNetRequest(EN_REQ_DOWNLOAD_TASK_ARG, this->m_hWnd, chSendStr, iSendLen, 6000);
return TRUE;
}
BOOL CDialOfflineDeviceTaskManager::OnSynCouldTaskInfoResponse(WPARAM wParam, LPARAM lParam)
{
CString strLog;
strLog.Format(_T("zm:click treectrl item response download task arg"));
OutputDebugString(strLog);
CFileOperTools::GetInstance()->WriteComLog(strLog);
if (wParam != 0)
{
CString strLog;
strLog.Format(_T("zm:任务信息同步报错(%d)"), wParam);
CFileOperTools::GetInstance()->WriteComLog(strLog);
return FALSE;
}
LPRESPONSEPACKET pResponsePacket = (LPRESPONSEPACKET)lParam;
if (NULL == pResponsePacket || pResponsePacket->clsPacketBase.ucCmd != EN_REQ_DOWNLOAD_TASK_ARG)
{
return FALSE;
}
//std::vector<STRemTaskArg> vtSaveSynTaskArg;
char chMsgSyn[MAX_RECV_MEASURE] = { 0 };
memcpy(chMsgSyn, pResponsePacket->pData, pResponsePacket->wDataLen);
UINT32* uiRevData = (UINT32*)(chMsgSyn);
UINT32 uiRevDataNum = ntohl(uiRevData[0]);
if ((uiRevDataNum < 1) || (pResponsePacket->wDataLen < (sizeof(UINT32) + uiRevDataNum * sizeof(STRemTaskArg))))
{
CString strLog;
strLog.Format(_T("[%s][%d]zm:wDataLen=%d,real recv len= %d"), MODULE_NAME, __LINE__, pResponsePacket->wDataLen, sizeof(UINT32) + uiRevDataNum * sizeof(STRemTaskArg));
CFileOperTools::GetInstance()->WriteComLog(strLog);
theApp.m_NetWorkOper.SetSuspendForThread(false);
return 0;
}
time_t ttNormalTime = Str2GmtTm(_T("2018-01-01 00:00:00"));
CString strCreateTime;
CString strDownloadTime;
CString strEndTestTime;
UINT32 tmTime = 0;
CString str;
CString strSql = _T("");
_RecordsetPtr pRecCm = NULL;
_RecordsetPtr pRecTd = NULL;
char chSptType[][10] = { "VES", "2D", "3D" };
STRemTaskArg *ptTaskArg = (STRemTaskArg *)(chMsgSyn + sizeof(UINT32));
for (int iIndex = 0; iIndex < uiRevDataNum; iIndex++)
{
ptTaskArg = (STRemTaskArg *)(chMsgSyn + sizeof(UINT32) + iIndex*sizeof(STRemTaskArg));
ptTaskArg->stMeasuArg.iSAInterval = ntohl(ptTaskArg->stMeasuArg.iSAInterval);
//ptTaskArg->stMeasuArg.fElecSpace = tcp_ntohf(ptTaskArg->stMeasuArg.fElecSpace);
ptTaskArg->stMeasuArg.fXElecDistance = tcp_ntohf(ptTaskArg->stMeasuArg.fXElecDistance);
ptTaskArg->stMeasuArg.fYElecDistance = tcp_ntohf(ptTaskArg->stMeasuArg.fYElecDistance);
ptTaskArg->stMeasuArg.fXElecStep = tcp_ntohf(ptTaskArg->stMeasuArg.fXElecStep);
ptTaskArg->stMeasuArg.fYElecStep = tcp_ntohf(ptTaskArg->stMeasuArg.fYElecStep);
ptTaskArg->stMeasuArg.rcGridSize.left = ntohl(ptTaskArg->stMeasuArg.rcGridSize.left);
ptTaskArg->stMeasuArg.rcGridSize.top = ntohl(ptTaskArg->stMeasuArg.rcGridSize.top);
ptTaskArg->stMeasuArg.rcGridSize.right = ntohl(ptTaskArg->stMeasuArg.rcGridSize.right);
ptTaskArg->stMeasuArg.rcGridSize.bottom = ntohl(ptTaskArg->stMeasuArg.rcGridSize.bottom);
ptTaskArg->stMeasuArg.byLineDirection = ntohl(ptTaskArg->stMeasuArg.byLineDirection);
ptTaskArg->uiStartElec = ntohl(ptTaskArg->uiStartElec);
ptTaskArg->uiEndElec = ntohl(ptTaskArg->uiEndElec);
ptTaskArg->uiStartLayer = ntohl(ptTaskArg->uiStartLayer);
ptTaskArg->uiEndLayer = ntohl(ptTaskArg->uiEndLayer);
ptTaskArg->uiStartTime = ntohl(ptTaskArg->uiStartTime);
ptTaskArg->uiEndTime = ntohl(ptTaskArg->uiEndTime);
ptTaskArg->uiTimerTime = ntohl(ptTaskArg->uiTimerTime);
ptTaskArg->uiTotalNum = ntohl(ptTaskArg->uiTotalNum);
ptTaskArg->uiCurrentPoint = ntohl(ptTaskArg->uiCurrentPoint);
ptTaskArg->uiFailedReason = ntohl(ptTaskArg->uiFailedReason);
//ptTaskArg->ucTestGRFlag = ntohl(ptTaskArg->ucTestGRFlag);
//pThis->m_vtSaveSynTaskArg.push_back(*ptTaskArg);
//更新到界面任务属性
m_listTaskAttr.SetItemText(0, 2, (LPCTSTR)(_bstr_t)U2G(ptTaskArg->ucTDName));
m_listTaskAttr.SetItemText(1, 2, (LPCTSTR)(_bstr_t)ptTaskArg->ucTaskID);
m_listTaskAttr.SetItemText(2, 2, (LPCTSTR)(_bstr_t)U2G(ptTaskArg->ucSciptName));
m_listTaskAttr.SetItemText(3, 2, (LPCTSTR)(_bstr_t)chSptType[ptTaskArg->stMeasuArg.ucSptType]);
str.Empty(); str.Format(_T("%d"), ptTaskArg->uiEndElec - ptTaskArg->uiStartElec + 1);
m_listTaskAttr.SetItemText(6, 2, (LPCTSTR)(_bstr_t)str);
str.Empty(); str.Format(_T("%d"), ptTaskArg->uiTotalNum);
m_listTaskAttr.SetItemText(7, 2, (LPCTSTR)(_bstr_t)str);
m_listTaskAttr.SetItemText(8, 2, (LPCTSTR)(_bstr_t)ptTaskArg->stMeasuArg.ucStacking);
str.Empty();
m_iTestType = ptTaskArg->stMeasuArg.ucTestType;
if (0 == m_iTestType)
str = _T("0+0-");
else if (1 == m_iTestType)
str = _T("+0-0");
else
str = _T("0");
m_listTaskAttr.SetItemText(9, 2, str);
//只有激电才有发射周期
str.Empty();
//0：电阻率，1：激电
if (1 == ptTaskArg->stMeasuArg.ucTestType || 0 == ptTaskArg->stMeasuArg.ucTestType)
str.Format(_T("%.1f"), GetSigTxPeriod(ptTaskArg->stMeasuArg.ucTestType, ptTaskArg->stMeasuArg.ucTxPeriod) / 1000.0);
m_listTaskAttr.SetItemText(10, 2, str);
//三维
if (2 == ptTaskArg->stMeasuArg.ucSptType)
str.Format(_T("%.2f,%.2f"), ptTaskArg->stMeasuArg.fXElecDistance, ptTaskArg->stMeasuArg.fYElecDistance);
else
str.Format(_T("%.2f"), ptTaskArg->stMeasuArg.fXElecDistance);
m_listTaskAttr.SetItemText(12, 2, str);
//listAttr.SetItemText(5, 2, (LPCTSTR)(_bstr_t)ptTaskArg->stMeasuArg.ucArrayType);
//listAttr.SetItemText(4, 2, (LPCTSTR)(_bstr_t)ptTaskArg->stMeasuArg.ucCableLayout(LPCTSTR)(_bstr_t)pRecCm->GetCollect(_T("Clabel")));
//listAttr.SetItemText(11, 2, (LPCTSTR)(_bstr_t)pRecCm->GetCollect(_T("Clabel")));
pRecCm.CreateInstance(_uuidof(Recordset));
strSql.Empty();
strSql.Format(_T("select MEname from medium where AR = %d and LANG = %d"), ptTaskArg->stMeasuArg.ucArrayType, g_iUILanguage);
pRecCm->Open(strSql.AllocSysString(), _variant_t((IDispatch*)theApp.m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);
if (pRecCm->GetRecordCount() > 0)
{
m_listTaskAttr.SetItemText(5, 2, (LPCTSTR)(_bstr_t)pRecCm->GetCollect(_T("MEname")));
}
pRecCm->Close();
strSql.Empty();
strSql.Format(_T("select Clabel from cm where Cname = 'Ttype' and Cvalue = %d and LANG = %d"), m_iTestType, g_iUILanguage);
pRecCm->Open(strSql.AllocSysString(), _variant_t((IDispatch*)theApp.m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);
if (pRecCm->GetRecordCount() > 0)
{
m_listTaskAttr.SetItemText(4, 2, (LPCTSTR)(_bstr_t)pRecCm->GetCollect(_T("Clabel")));
}
pRecCm->Close();
if (ptTaskArg->stMeasuArg.ucCableLayout >= 0)
{
strSql.Empty();
strSql.Format(_T("select Clabel from cm where Cname = 'Clayout' and Cvalue = %d and LANG = %d"), ptTaskArg->stMeasuArg.ucCableLayout, g_iUILanguage);
pRecCm->Open(strSql.AllocSysString(), _variant_t((IDispatch*)theApp.m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);
if (pRecCm->GetRecordCount() > 0)
{
m_listTaskAttr.SetItemText(11, 2, (LPCTSTR)(_bstr_t)pRecCm->GetCollect(_T("Clabel")));
}
pRecCm->Close();
}
//填状态信息
pRecTd.CreateInstance(_uuidof(Recordset));
CString strTaskId = ptTaskArg->ucTaskID;
strTaskId.TrimLeft(); strTaskId.TrimRight();
strSql.Empty();
strSql.Format(_T("select DownloadTime,CreateTime from td where TDCN = '%s'"), ptTaskArg->ucTaskID);
pRecTd->Open(strSql.AllocSysString(), _variant_t((IDispatch*)theApp.m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);
strDownloadTime.Empty();
strEndTestTime.Empty();
strCreateTime.Empty();
if (pRecTd->GetRecordCount() > 0)
{
tmTime = (VT_NULL == pRecTd->GetCollect(_T("DownloadTime")).vt) ? 0 : pRecTd->GetCollect(_T("DownloadTime")).uintVal;
str.Format(_T("zm:task args :download time = %u\n"), tmTime);
CFileOperTools::GetInstance()->WriteComLog(str);
if (tmTime > ttNormalTime)
{
strDownloadTime = Tm2LocalStr(tmTime);
}
tmTime = (VT_NULL == pRecTd->GetCollect(_T("CreateTime")).vt) ? 0 : pRecTd->GetCollect(_T("CreateTime")).uintVal;
if (tmTime > ttNormalTime)
{
strCreateTime = Tm2LocalStr(tmTime);
}
}
pRecTd->Close();
if (ptTaskArg->uiEndTime > ttNormalTime)
{
strEndTestTime = Tm2LocalStr(ptTaskArg->uiEndTime);
}
if (strDownloadTime.IsEmpty())
{
if (g_iUILanguage == LANG_ZHCN)
{
m_listTaskAttr.SetItemText(13, 2, _T("未下载"));
}
else
{
m_listTaskAttr.SetItemText(13, 2, _T("not download"));
}
}
else
{
if (g_iUILanguage == LANG_ZHCN)
{
m_listTaskAttr.SetItemText(13, 2, _T("已下载"));
}
else
{
m_listTaskAttr.SetItemText(13, 2, _T("downloaded"));
}
}
m_listTaskAttr.SetItemText(14, 2, strDownloadTime);
m_listTaskAttr.SetItemText(15, 2, strEndTestTime);
if (!strCreateTime.IsEmpty())
{
m_listTaskAttr.SetItemText(16, 2, strCreateTime);
}
else
{
strCreateTime = Tm2LocalStr(ntohl(ptTaskArg->uiCreateTime));
m_listTaskAttr.SetItemText(16, 2, strCreateTime);
}
if (0 == ptTaskArg->ucTestGRFlag)
{
if (g_iUILanguage == LANG_ZHCN)
m_listTaskAttr.SetItemText(17, 2, _T("否"));
else
m_listTaskAttr.SetItemText(17, 2, _T("no"));
}
else if (1 == ptTaskArg->ucTestGRFlag)
{
if (g_iUILanguage == LANG_ZHCN)
m_listTaskAttr.SetItemText(17, 2, _T("是"));
else
m_listTaskAttr.SetItemText(17, 2, _T("yes"));
}
CString strReason = GetTestFailedReason(ptTaskArg->uiFailedReason);
m_listTaskAttr.SetItemText(18, 2, strReason);
}
//取最后一个Item,当前实时窗口显示的任务
memcpy(&m_dialRealTimeMeasuData.m_stTaskArg, ptTaskArg, sizeof(STRemTaskArg));
UpdateRealTimeTaskListData(ptTaskArg, (STTaskListItem*)&m_vtNeedSynTaskID.at(0));
return TRUE;
}
BOOL CDialOfflineDeviceTaskManager::OnDeleteTaskResponse(WPARAM wParam, LPARAM lParam)
{
LPRESPONSEPACKET pResponsePacket = (LPRESPONSEPACKET)lParam;
if (pResponsePacket == NULL)
{
return FALSE;
}
//删除本地及树型控件列表数据
if (EN_RECV_SUCCESS == wParam)
{
if (m_taskOper.DeleteTaskArray(m_CurDelTaskID))
{
//m_listTaskData.DeleteAllItems();
int iItemCnt = m_listTaskAttr.GetItemCount();
for (int i = 0; i < iItemCnt; i++)
{
m_listTaskAttr.SetItemText(i, 2, _T(""));
}
//for (int i = 0; i < m_vtNeedDelTreeItem.size(); i++)
// m_dialTaskTree.m_treeTask.DeleteItem(m_vtNeedDelTreeItem.at(i));
m_dialTaskTree.m_treeTask.DeleteItem(m_CurDelTreeItem);
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("删除任务成功"));
else
MessageBoxEx(NULL, _T("Succeed to delete test task"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
//m_vtNeedDelTaskID.clear();
//m_vtNeedDelTreeItem.clear();
}
}
else
{
if (LANG_ZHCN == g_iUILanguage)
AfxMessageBox(_T("删除任务失败"));
else
MessageBoxEx(NULL, _T("Failed to delete test task"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
}
return TRUE;
}
LRESULT CDialOfflineDeviceTaskManager::OnRecvRealTimeDataResponse(WPARAM wParam, LPARAM lParam)
{
CString strLog;
CFileOperTools::GetInstance()->WriteComLog("zm:CDialOfflineDeviceTaskManager::OnRecvRealTimeDataResponse() recv real time data begin----------------");
char *chStr = (char*)wParam;
if (chStr == NULL)
{
return 0;
}
//获取任务名
char szTaskID[MAX_NAME_LEN] = {0};
memcpy(szTaskID, chStr, MAX_NAME_LEN);
// if ((0 >= ntohl(pMeasuDataRes->iID) || 100000 < ntohl(pMeasuDataRes->iID))
// || 0 != strcmp(szTaskID, m_stRealTimeTaskArg.ucTaskID))//点数ID和任务ID判断
if (0 != strcmp(szTaskID, m_stRealTimeTaskArg.ucTaskID))
{
strLog.Format(_T("zm:recv real time data[0 != strcmp(szTaskID=%s, m_stRealTimeTaskArg.ucTaskID=%s])"), szTaskID, m_stRealTimeTaskArg.ucTaskID);
CFileOperTools::GetInstance()->WriteComLog(strLog);
return 0;
}
strLog.Format(_T("zm:recv real time data [uiTotalNum=%d]"), m_stRealTimeTaskArg.uiTotalNum);
CFileOperTools::GetInstance()->WriteComLog(strLog);
//获取总点数
BYTE ucPointNum = chStr[MAX_NAME_LEN];
if (ucPointNum <= 0)
{
CFileOperTools::GetInstance()->WriteComLog(_T("zm:recv real time data ucPointNum <= 0"));
return 0;
}
//char *pData = (char *)malloc(sizeof(char) * 4096);
std::vector<STTaskDetailBasicData> vtData;
int iLen = lParam;
UINT32 uiStartID = 0;
//int iMaxSynNum = 50;
int iPackLen = (ucPointNum*sizeof(STMeasuDataResBasicEx)) + MAX_NAME_LEN + sizeof(char);
if (0 >= iLen /*|| iLen != iPackLen*/ || 0 >= ucPointNum) //长度和转发点数判断
{
CFileOperTools::GetInstance()->WriteComLog("zm:recv real time data [0 >= iLen || iLen != iPackLen || 0 >= ucPointNum]");
return 0;
}
//接收到数据后，清空状态
GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips);
//char *pData = new char[4096];
STMeasuDataResBasicEx *pMeasuDataRes = (STMeasuDataResBasicEx *)&chStr[sizeof(char)*MAX_NAME_LEN + sizeof(char)];
//if (0 == uiStartID || ntohl(pMeasuDataRes->iID) > uiStartID + iMaxSynNum) //从云端获取ABMN信息，便于动态显示，每50点获取一次
/*{
int i;
for (i = 0; i < 3; i++)//失败获取三次
{
//if (true == m_taskOper.QueryOnLineTdDataFromSev(m_stRealTimeTaskArg, pMeasuDataRes->iID, pMeasuDataRes->iID + iMaxSynNum, pData))
if (true == m_taskOper.QueryOnLineTdDataFromSev(m_stRealTimeTaskArg, pMeasuDataRes->iID, pMeasuDataRes->iID + ucPointNum, pData))
{
uiStartID = ntohl(pMeasuDataRes->iID);
break;
}
Sleep(10);
}
if (3 == i) //未获取数据信息
{
OutputDebugString("zm:enter CDialOfflineDeviceTaskManager::OnRecvRealTimeDataResponse 3 == i");
if (pData != NULL)
{
delete[] pData;
pData = NULL;
}
return 0;
}
}*/
STTaskDataRes stMeasuBasicData;
int iSevDataIndex = 0;
STMeasuDataResBasicEx pMeasuData;
STTaskDetailBasicData stTaskDetailData;
for (int i = 0; i < ucPointNum; i++)
{
//iSevDataIndex = pMeasuDataRes->iID - uiStartID + i;
// STTaskDataRes *ptTaskData = (STTaskDataRes *)&pData[MAX_NAME_LEN * sizeof(BYTE) + sizeof(UINT32) + i*sizeof(STTaskDataRes)];
memcpy(&pMeasuData, &pMeasuDataRes[i], sizeof(STMeasuDataResBasicEx));
memset(&stMeasuBasicData, 0, sizeof(STTaskDataRes));
stMeasuBasicData.dwID = ntohl(pMeasuData.iID);
stMeasuBasicData.fA = tcp_ntohf(pMeasuData.fA);
stMeasuBasicData.fB = tcp_ntohf(pMeasuData.fB);
stMeasuBasicData.fM = tcp_ntohf(pMeasuData.fM);
stMeasuBasicData.fN = tcp_ntohf(pMeasuData.fN);
stMeasuBasicData.fV = tcp_ntohf(pMeasuData.fV);
stMeasuBasicData.fI = tcp_ntohf(pMeasuData.fI);
stMeasuBasicData.fR0 = tcp_ntohf(pMeasuData.fR0);
stMeasuBasicData.fSP = tcp_ntohf(pMeasuData.fSP);
stMeasuBasicData.fK = tcp_ntohf(pMeasuData.fK);
stMeasuBasicData.ucAlram = pMeasuData.ucAlram;
stMeasuBasicData.ucStack = pMeasuData.ucStack;
stMeasuBasicData.fR0_LC = tcp_ntohf(pMeasuData.fR0_LC);
memset(&stTaskDetailData, 0, sizeof(STTaskDetailBasicData));
stTaskDetailData.iID = stMeasuBasicData.dwID;
stTaskDetailData.iA = stMeasuBasicData.fA;
stTaskDetailData.iB = stMeasuBasicData.fB;
stTaskDetailData.iM = stMeasuBasicData.fM;
stTaskDetailData.iN = stMeasuBasicData.fN;
stTaskDetailData.fK = stMeasuBasicData.fK;
stTaskDetailData.fV = stMeasuBasicData.fV;
stTaskDetailData.fI = stMeasuBasicData.fI;
stTaskDetailData.fR0 = stMeasuBasicData.fR0;
stTaskDetailData.fSP = stMeasuBasicData.fSP;
stTaskDetailData.ucStack = stMeasuBasicData.ucStack;
stTaskDetailData.ucIsUse = 1;// stMeasuBasicData.ucAlram;
strLog.Format(_T("zm:reve point num=%d, %d: id=%d,A=%.f,B=%.f,M=%.f,N=%.f,k=%.2f,v=%.2f,i=%.2f,R0=%.2f,SP=%.2f"), ucPointNum, i, stTaskDetailData.iID, stTaskDetailData.iA, stTaskDetailData.iB, stTaskDetailData.iM, stTaskDetailData.iN, stTaskDetailData.fK, stTaskDetailData.fV, stTaskDetailData.fI, stTaskDetailData.fR0, stTaskDetailData.fSP);
CFileOperTools::GetInstance()->WriteComLog(strLog);
vtData.push_back(stTaskDetailData);
}
SendMessage(WM_TASK_LIST_TASK_DATA_SYN, (WPARAM)&vtData, 1);
/*if (pData != NULL)
{
delete[] pData;
pData = NULL;
} */
CFileOperTools::GetInstance()->WriteComLog("zm:CDialOfflineDeviceTaskManager::OnRecvRealTimeDataResponse() recv real time data end----------------------");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink