|
// SGMeasurementDlg.cpp: 实现文件
|
//
|
|
#include "pch.h"
|
#include "framework.h"
|
#include "SGMeasurement.h"
|
#include "SGMeasurementDlg.h"
|
#include "afxdialogex.h"
|
#include "SGIF.h"
|
#include "Logger.h"
|
|
#ifdef _DEBUG
|
#define new DEBUG_NEW
|
#endif
|
|
#define DeviceID 0
|
|
// 托盘图标 ID 与消息宏
|
#define ID_TRAY_RESTORE 2001 // 恢复窗口
|
#define ID_TRAY_EXIT 2002 // 退出程序
|
#define WM_TRAY_ICON_NOTIFY (WM_USER + 1000) // 托盘图标回调消息 ID
|
|
// 托盘提示文本宏
|
#define TRAY_ICON_TOOLTIP_TEXT _T("SGMeasurement")
|
|
// 日志颜色宏定义
|
#define LOG_COLOR_NORMAL RGB(0, 0, 0) // 普通：黑色
|
#define LOG_COLOR_SUCCESS RGB(0, 128, 0) // 成功：绿色
|
#define LOG_COLOR_ERROR RGB(255, 0, 0) // 错误：红色
|
#define LOG_COLOR_WARNING RGB(255, 165, 0) // 警告：橙色
|
#define LOG_COLOR_TIME RGB(0, 0, 255) // 时间戳：蓝色
|
|
// 定时器相关宏定义
|
#define TIMER_INTERVAL_MS 500
|
#define TIMER_ID_OUTPUT_UPDATE 1
|
|
// 计时宏定义
|
#define MEASURE_FUNC_START() \
|
clock_t __startClock = clock();
|
|
#define MEASURE_FUNC_END() \
|
do { \
|
clock_t __endClock = clock(); \
|
double __elapsedMs = 1000.0 * (__endClock - __startClock) / CLOCKS_PER_SEC; \
|
CString __strElapsed; \
|
__strElapsed.Format(_T("%s 执行耗时：%.1f ms"), _T(__FUNCTION__), __elapsedMs); \
|
AppendLogLineRichStyled(__strElapsed, LOG_COLOR_SUCCESS); \
|
} while (0)
|
|
class CAboutDlg : public CDialogEx
|
{
|
public:
|
CAboutDlg();
|
|
// 对话框数据
|
#ifdef AFX_DESIGN_TIME
|
enum { IDD = IDD_ABOUTBOX };
|
#endif
|
|
protected:
|
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
|
|
// 实现
|
protected:
|
DECLARE_MESSAGE_MAP()
|
};
|
|
CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
|
{
|
}
|
|
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
|
{
|
CDialogEx::DoDataExchange(pDX);
|
}
|
|
BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
|
END_MESSAGE_MAP()
|
|
CSGMeasurementDlg::CSGMeasurementDlg(CWnd* pParent /*=nullptr*/)
|
: CDialogEx(IDD_SGMEASUREMENT_DIALOG, pParent)
|
, m_bConnected(false)
|
, m_bSaving(false)
|
, m_dOutValues{ 0.0, 0.0, 0.0, 0.0 }
|
, m_nUseTrigger(0)
|
, m_nSavePointCount(100000)
|
, m_fJumpThreshold(0.2f)
|
, m_nJumpWindow(3)
|
, m_nValleyMargin(0)
|
, m_nMinGlass1Count(10)
|
, m_nFixedCount(5)
|
, m_fMaxDelta(0.05f)
|
, m_nTrayIconID(0)
|
, m_bTrayIconCreated(FALSE)
|
, m_bExitingFromTray(FALSE)
|
{
|
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
|
}
|
|
void CSGMeasurementDlg::DoDataExchange(CDataExchange* pDX)
|
{
|
CDialogEx::DoDataExchange(pDX);
|
DDX_Text(pDX, IDC_EDIT_OUT1, m_dOutValues[0]);
|
DDX_Text(pDX, IDC_EDIT_OUT2, m_dOutValues[1]);
|
DDX_Text(pDX, IDC_EDIT_OUT3, m_dOutValues[2]);
|
DDX_Text(pDX, IDC_EDIT_OUT4, m_dOutValues[3]);
|
DDX_Control(pDX, IDC_RICHEDIT_LOG, m_editLog);
|
DDX_Check(pDX, IDC_CHECK_USE_TRIGGER, m_nUseTrigger);
|
DDX_Control(pDX, IDC_COMBO_OUTPUT_PORT, m_comboOutputPort);
|
DDX_Text(pDX, IDC_EDIT_STORE_COUNT, m_nSavePointCount);
|
DDX_Text(pDX, IDC_EDIT_JUMP_WINDOW, m_nJumpWindow);
|
DDX_Text(pDX, IDC_EDIT_VALLEY_MARGIN, m_nValleyMargin);
|
DDX_Text(pDX, IDC_EDIT_MIN_GLASS_COUNT, m_nMinGlass1Count);
|
DDX_Text(pDX, IDC_EDIT_FIXED_COUNT, m_nFixedCount);
|
DDX_Text(pDX, IDC_EDIT_JUMP_THRESHOLD, m_fJumpThreshold);
|
DDX_Text(pDX, IDC_EDIT_MAX_DELTA, m_fMaxDelta);
|
}
|
|
void CSGMeasurementDlg::ExitApplication()
|
{
|
// 断开设备连接（如已连接）
|
if (m_bConnected) {
|
DisconnectFromDevice();
|
}
|
|
// 删除托盘图标（如已添加）
|
if (m_bTrayIconCreated) {
|
Shell_NotifyIcon(NIM_DELETE, &m_trayIconData);
|
m_bTrayIconCreated = FALSE;
|
}
|
|
m_plcListener.Stop();
|
|
DestroyWindow();
|
CDialogEx::OnClose();
|
}
|
|
void CSGMeasurementDlg::UpdateControlStatus(BOOL bConnected, BOOL bStoring/* = FALSE*/)
|
{
|
// 连接按钮和断开按钮状态互斥
|
GetDlgItem(IDC_BUTTON_CONNECT)->EnableWindow(!bConnected);
|
GetDlgItem(IDC_BUTTON_DISCONNECT)->EnableWindow(bConnected);
|
|
// IP地址输入只允许在未连接时修改
|
GetDlgItem(IDC_IPADDRESS)->EnableWindow(!bConnected);
|
|
// 存储配置控件仅在已连接且未开始存储时允许操作
|
BOOL bCanConfigure = bConnected && !bStoring;
|
/*GetDlgItem(IDC_CHECK_USE_TRIGGER)->EnableWindow(bCanConfigure);*/
|
GetDlgItem(IDC_COMBO_OUTPUT_PORT)->EnableWindow(bCanConfigure);
|
GetDlgItem(IDC_EDIT_STORE_COUNT)->EnableWindow(bCanConfigure);
|
GetDlgItem(IDC_EDIT_JUMP_THRESHOLD)->EnableWindow(bCanConfigure);
|
GetDlgItem(IDC_EDIT_JUMP_WINDOW)->EnableWindow(bCanConfigure);
|
GetDlgItem(IDC_EDIT_VALLEY_MARGIN)->EnableWindow(bCanConfigure);
|
GetDlgItem(IDC_EDIT_MIN_GLASS_COUNT)->EnableWindow(bCanConfigure);
|
GetDlgItem(IDC_EDIT_FIXED_COUNT)->EnableWindow(bCanConfigure);
|
GetDlgItem(IDC_EDIT_MAX_DELTA)->EnableWindow(bCanConfigure);
|
|
// 存储相关按钮
|
GetDlgItem(IDC_BUTTON_RECEIVE_FROM_CTRL)->EnableWindow(bCanConfigure);
|
GetDlgItem(IDC_BUTTON_SEND_TO_CTRL)->EnableWindow(bCanConfigure);
|
GetDlgItem(IDC_BUTTON_CLEAR_STORE)->EnableWindow(bCanConfigure);
|
GetDlgItem(IDC_BUTTON_START_STORE)->EnableWindow(bCanConfigure);
|
GetDlgItem(IDC_BUTTON_STOP_STORE)->EnableWindow(bStoring);
|
}
|
|
void CSGMeasurementDlg::AppendLogLineBatchBegin()
|
{
|
m_editLog.SetRedraw(FALSE);
|
m_editLog.SetEventMask(0); // 防止触发不必要的通知
|
}
|
|
void CSGMeasurementDlg::AppendLogLineBatchEnd()
|
{
|
m_editLog.SetRedraw(TRUE);
|
m_editLog.Invalidate(); // 强制重绘
|
m_editLog.SetEventMask(ENM_CHANGE | ENM_SELCHANGE);
|
}
|
|
void CSGMeasurementDlg::TrimRichEditLineLimit(int nMaxLines)
|
{
|
int nLineCount = m_editLog.GetLineCount();
|
if (nLineCount < nMaxLines) {
|
return;
|
}
|
|
// 获取多余行的字符数范围
|
int charIndex = m_editLog.LineIndex(nMaxLines);
|
m_editLog.SetSel(0, charIndex); // 选中多余内容
|
m_editLog.ReplaceSel(_T("")); // 删除
|
}
|
|
void CSGMeasurementDlg::AppendLogLineRichStyled(const CString& strContent, COLORREF color /*= RGB(0, 0, 0)*/)
|
{
|
if (!::IsWindow(GetSafeHwnd()) || !::IsWindow(m_editLog.GetSafeHwnd())) {
|
return;
|
}
|
|
// 时间戳
|
CString strTimestamp;
|
CTime now = CTime::GetCurrentTime();
|
strTimestamp.Format(_T("[%02d:%02d:%02d] "), now.GetHour(), now.GetMinute(), now.GetSecond());
|
|
// 插入点移到最后（也可以设为 0 表示顶部）
|
m_editLog.SetSel(-1, -1);
|
|
// 插入时间（蓝色）
|
CHARFORMAT2 cfTime = {};
|
cfTime.cbSize = sizeof(cfTime);
|
cfTime.dwMask = CFM_COLOR;
|
cfTime.crTextColor = LOG_COLOR_TIME;
|
m_editLog.SetSelectionCharFormat(cfTime);
|
m_editLog.ReplaceSel(strTimestamp);
|
|
// 生成日志级别标签
|
CString strLevel;
|
if (color == LOG_COLOR_WARNING) {
|
strLevel = _T("[警告]");
|
}
|
else if (color == LOG_COLOR_ERROR) {
|
strLevel = _T("[错误]");
|
}
|
else if (color == LOG_COLOR_NORMAL) {
|
strLevel = _T("[信息]");
|
}
|
else if (color == LOG_COLOR_SUCCESS) {
|
strLevel = _T("[成功]");
|
}
|
else {
|
strLevel = _T("[未知]");
|
}
|
|
// 插入日志正文（传入颜色）
|
CHARFORMAT2 cfMsg = {};
|
cfMsg.cbSize = sizeof(cfMsg);
|
cfMsg.dwMask = CFM_COLOR;
|
cfMsg.crTextColor = color;
|
m_editLog.SetSelectionCharFormat(cfMsg);
|
m_editLog.ReplaceSel(strLevel + strContent + _T("\r\n"));
|
|
// 限制最大行数
|
TrimRichEditLineLimit(100);
|
|
// 拼接完整日志行
|
CString strFullLogLine;
|
strFullLogLine.Format(_T("%s %s"), strLevel, strContent);
|
|
// 写入日志文件
|
LOG_LINE(strFullLogLine);
|
}
|
|
void CSGMeasurementDlg::HighlightAllMatches(const CString& strSearch, COLORREF clrHighlight/* = RGB(255, 165, 0)*/)
|
{
|
if (strSearch.IsEmpty()) {
|
return;
|
}
|
|
long nStart = 0;
|
long nEnd = m_editLog.GetTextLength();
|
FINDTEXTEX ft = { 0 };
|
ft.chrg.cpMin = 0;
|
ft.chrg.cpMax = nEnd;
|
ft.lpstrText = strSearch.GetString();
|
|
// 高亮前不清除全文颜色，避免历史多色混淆
|
while (m_editLog.FindText(FR_DOWN, &ft) != -1) {
|
m_editLog.SetSel(ft.chrgText.cpMin, ft.chrgText.cpMax);
|
|
CHARFORMAT2 cf = {};
|
cf.cbSize = sizeof(cf);
|
cf.dwMask = CFM_COLOR;
|
cf.crTextColor = clrHighlight;
|
m_editLog.SetSelectionCharFormat(cf);
|
|
// 下次搜索从后面开始
|
ft.chrg.cpMin = ft.chrgText.cpMax;
|
}
|
m_editLog.SetSel(-1, 0);
|
}
|
|
void CSGMeasurementDlg::PrintSampleData(int nOutNo, const std::vector<float>& vecBuffer)
|
{
|
int nReceived = static_cast<int>(vecBuffer.size());
|
if (vecBuffer.empty() || nReceived < 0) {
|
CString strError;
|
strError.Format(_T("OUT%d: 接收数据为空或无效，无法打印。"), nOutNo);
|
AppendLogLineRichStyled(strError, LOG_COLOR_WARNING);
|
return;
|
}
|
|
CString strLine;
|
for (int i = 0; i < nReceived; ++i) {
|
CString strOne;
|
strOne.Format(_T("%10.3f "), vecBuffer[i]);
|
strLine += strOne;
|
|
// 每 7 个值输出一行
|
if ((i + 1) % 7 == 0 || i == nReceived - 1) {
|
AppendLogLineRichStyled(strLine, LOG_COLOR_NORMAL);
|
strLine.Empty();
|
}
|
}
|
}
|
|
bool CSGMeasurementDlg::ConnectToDevice()
|
{
|
if (m_bConnected) {
|
AppendLogLineRichStyled(_T("设备已连接，请先断开连接。"), LOG_COLOR_WARNING);
|
return false;
|
}
|
|
SGIF_OPENPARAM_ETHERNET stIpAddress = { 0 };
|
|
CIPAddressCtrl* pIPCtrl = (CIPAddressCtrl*)GetDlgItem(IDC_IPADDRESS);
|
if (!::IsWindow(pIPCtrl->GetSafeHwnd())) {
|
AppendLogLineRichStyled(_T("IP 控件无效，连接失败！"), LOG_COLOR_ERROR);
|
return false;
|
}
|
|
pIPCtrl->GetAddress(
|
stIpAddress.IPAddress.S_un.S_un_b.s_b1,
|
stIpAddress.IPAddress.S_un.S_un_b.s_b2,
|
stIpAddress.IPAddress.S_un.S_un_b.s_b3,
|
stIpAddress.IPAddress.S_un.S_un_b.s_b4
|
);
|
|
RC nRet = SGIF_OpenDeviceETHER(DeviceID, &stIpAddress);
|
if (nRet == RC_OK) {
|
AppendLogLineRichStyled(_T("打开连接成功！"), LOG_COLOR_SUCCESS);
|
|
m_bConnected = TRUE;
|
UpdateControlStatus(TRUE, FALSE);
|
SetTimer(TIMER_ID_OUTPUT_UPDATE, TIMER_INTERVAL_MS, nullptr);
|
return true;
|
}
|
else {
|
CString strError;
|
strError.Format(_T("打开连接失败，错误码：%#X"), nRet);
|
AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);
|
|
m_bConnected = FALSE;
|
UpdateControlStatus(FALSE, FALSE);
|
return false;
|
}
|
}
|
|
bool CSGMeasurementDlg::DisconnectFromDevice()
|
{
|
if (!m_bConnected) {
|
AppendLogLineRichStyled(_T("设备未连接，无需断开。"), LOG_COLOR_WARNING);
|
return false;
|
}
|
|
// 停止定时器，避免在断开后仍尝试更新输出数据
|
KillTimer(TIMER_ID_OUTPUT_UPDATE);
|
|
// 先停止数据存储（如果正在进行）
|
RC nRet;
|
if (m_bConnected && m_bSaving) {
|
nRet = SGIF_DataStorageStop(DeviceID);
|
if (nRet == RC_OK) {
|
m_bSaving = FALSE;
|
AppendLogLineRichStyled(_T("数据存储已停止。"), LOG_COLOR_SUCCESS);
|
}
|
else {
|
CString strError;
|
strError.Format(_T("停止数据存储失败，错误码：%#X"), nRet);
|
AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);
|
}
|
}
|
|
// 断开设备连接
|
nRet = SGIF_CloseDevice(DeviceID);
|
if (nRet == RC_OK) {
|
AppendLogLineRichStyled(_T("断开连接成功！"), LOG_COLOR_SUCCESS);
|
|
m_bConnected = FALSE;
|
UpdateControlStatus(FALSE, FALSE);
|
return true;
|
}
|
else {
|
CString strError;
|
strError.Format(_T("断开连接失败，错误码：%#X"), nRet);
|
AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);
|
AppendLogLineRichStyled(_T("保持当前状态，断开失败。"), LOG_COLOR_ERROR);
|
|
UpdateControlStatus(m_bConnected, m_bSaving);
|
return false;
|
}
|
}
|
|
void CSGMeasurementDlg::CleanInvalidValuesInPlace(int nOutNo, std::vector<float>& vecData, float fInvalid/* = -999.0f*/)
|
{
|
MEASURE_FUNC_START();
|
|
// 找到第一个有效值
|
auto itStart = std::find_if(vecData.begin(), vecData.end(), [=](float v) { return v > fInvalid; });
|
|
// 找到最后一个有效值
|
auto itEnd = std::find_if(vecData.rbegin(), vecData.rend(), [=](float v) { return v > fInvalid; }).base();
|
|
// 检查是否有有效数据
|
if (itStart < itEnd) {
|
// 先裁边
|
std::vector<float> vecTrimmed(itStart, itEnd);
|
|
// 再移除中间的无效值
|
auto itNewEnd = std::remove_if(vecTrimmed.begin(), vecTrimmed.end(), [=](float v) { return v == fInvalid; });
|
vecTrimmed.erase(itNewEnd, vecTrimmed.end());
|
|
vecData = std::move(vecTrimmed);
|
|
CString strLog;
|
strLog.Format(_T("OUT%d: 已裁剪无效边界数据，剩余有效数据 %d 个。"), nOutNo, static_cast<int>(vecData.size()));
|
AppendLogLineRichStyled(strLog, LOG_COLOR_NORMAL);
|
|
if (vecData.size() < 20) {
|
AppendLogLineRichStyled(_T("警告：有效数据量过少，可能影响后续处理。"), LOG_COLOR_WARNING);
|
}
|
else {
|
CString strInfo;
|
strInfo.Format(_T("OUT%d: 有效数据范围 [%f, %f]"), nOutNo, *std::min_element(vecData.begin(), vecData.end()), *std::max_element(vecData.begin(), vecData.end()));
|
AppendLogLineRichStyled(strInfo, LOG_COLOR_NORMAL);
|
}
|
|
PrintSampleData(nOutNo, vecData);
|
}
|
else {
|
vecData.clear();
|
}
|
|
MEASURE_FUNC_END();
|
}
|
|
bool CSGMeasurementDlg::SplitGlassSegments(int nOutNo, const std::vector<float>& vecData, std::vector<float>& vecGlass1, std::vector<float>& vecGlass2, float fJumpThreshold /*= 0.2f*/, int nWindow /*= 3*/, int nValleyMargin /*= 0*/, int nMinGlassCount /*= 10*/)
|
{
|
MEASURE_FUNC_START();
|
|
CString strLog;
|
const int nTotal = static_cast<int>(vecData.size());
|
|
if (nTotal < 2 * nWindow + 1 + nMinGlassCount) {
|
strLog.Format(_T("OUT%d: 数据量不足，至少需要 %d 个点才能切割。"), nOutNo, 2 * nWindow + 1 + nMinGlassCount);
|
AppendLogLineRichStyled(strLog, LOG_COLOR_WARNING);
|
return false;
|
}
|
|
// 从中间向两边查找 valley 候选点
|
int nMid = nTotal / 2;
|
int nValleyLeft = -1, nValleyRight = -1;
|
|
// 向左查找 valley
|
for (int i = nMid; i >= nWindow; --i) {
|
float fDelta = std::fabs(vecData[i] - vecData[i - nWindow]);
|
if (fDelta > fJumpThreshold &&
|
vecData[i] < vecData[i - 1] &&
|
vecData[i] < vecData[i + 1]) {
|
nValleyLeft = i;
|
break;
|
}
|
}
|
|
// 向右查找 valley
|
for (int i = nMid; i <= nTotal - nWindow - 2; ++i) {
|
float fDelta = std::fabs(vecData[i + nWindow] - vecData[i]);
|
if (fDelta > fJumpThreshold &&
|
vecData[i] < vecData[i - 1] &&
|
vecData[i] < vecData[i + 1]) {
|
nValleyRight = i;
|
break;
|
}
|
}
|
|
// 选定 valley 点
|
int nValleyIdx = -1;
|
if (nValleyLeft > 0 && nValleyRight > 0) {
|
nValleyIdx = (vecData[nValleyLeft] < vecData[nValleyRight]) ? nValleyLeft : nValleyRight;
|
}
|
else if (nValleyLeft > 0) {
|
nValleyIdx = nValleyLeft;
|
}
|
else if (nValleyRight > 0) {
|
nValleyIdx = nValleyRight;
|
}
|
|
// fallback: valley 未找到，使用中间切割法
|
if (nValleyIdx < 0) {
|
AppendLogLineRichStyled(_T("未找到 valley 跳变点，使用中间位置切割。"), LOG_COLOR_WARNING);
|
nValleyIdx = nMid;
|
}
|
|
// 应用切割位置，限制边界
|
int nCutPos = max(1, min(nTotal - 1, nValleyIdx + nValleyMargin));
|
|
vecGlass1.assign(vecData.begin(), vecData.begin() + nCutPos);
|
vecGlass2.assign(vecData.begin() + nCutPos, vecData.end());
|
|
int nGlass1Count = static_cast<int>(vecGlass1.size());
|
int nGlass2Count = static_cast<int>(vecGlass2.size());
|
|
// 日志输出
|
strLog.Format(_T("OUT%d: 切割成功，第一片玻璃 %d 点，第二片玻璃 %d 点。"), nOutNo, nGlass1Count, nGlass2Count);
|
AppendLogLineRichStyled(strLog, LOG_COLOR_SUCCESS);
|
|
if (nGlass1Count < nMinGlassCount) {
|
strLog.Format(_T("OUT%d: 第一片玻璃数据量少于 %d 点，可能影响计算。"), nOutNo, nMinGlassCount);
|
AppendLogLineRichStyled(strLog, LOG_COLOR_WARNING);
|
}
|
|
if (nGlass2Count < nMinGlassCount) {
|
strLog.Format(_T("OUT%d: 第二片玻璃数据量少于 %d 点，可能影响计算。"), nOutNo, nMinGlassCount);
|
AppendLogLineRichStyled(strLog, LOG_COLOR_WARNING);
|
}
|
|
AppendLogLineRichStyled(_T("第一片玻璃数据："), LOG_COLOR_NORMAL);
|
PrintSampleData(nOutNo, vecGlass1);
|
|
AppendLogLineRichStyled(_T("第二片玻璃数据："), LOG_COLOR_NORMAL);
|
PrintSampleData(nOutNo, vecGlass2);
|
|
MEASURE_FUNC_END();
|
|
return true;
|
}
|
|
bool CSGMeasurementDlg::FilterDominantGroup(int nOutNo, const std::vector<float>& vecInput, std::vector<float>& vecOutput)
|
{
|
MEASURE_FUNC_START();
|
|
if (vecInput.empty()) {
|
AppendLogLineRichStyled(_T("输入数据为空，无法进行分组筛选。"), LOG_COLOR_WARNING);
|
return false;
|
}
|
|
// 分组：map<int整数部分, vector<float>>
|
std::map<int, std::vector<float>> mapGroup;
|
for (float fVal : vecInput) {
|
int nKey = static_cast<int>(fVal);
|
mapGroup[nKey].push_back(fVal);
|
}
|
|
// 找出数量最多的那组
|
size_t nMaxCount = 0;
|
auto itMaxGroup = mapGroup.begin();
|
for (auto it = mapGroup.begin(); it != mapGroup.end(); ++it) {
|
if (it->second.size() > nMaxCount) {
|
nMaxCount = it->second.size();
|
itMaxGroup = it;
|
}
|
}
|
|
if (nMaxCount == 0) {
|
AppendLogLineRichStyled(_T("所有数据都被过滤或为空，无法筛选出主要分组。"), LOG_COLOR_WARNING);
|
return false;
|
}
|
|
vecOutput = itMaxGroup->second;
|
|
CString strLog;
|
strLog.Format(_T("成功从 %d 个组中筛选出主要分组：值约为 %d，共 %zu 个点。"), static_cast<int>(mapGroup.size()), itMaxGroup->first, nMaxCount);
|
AppendLogLineRichStyled(strLog, LOG_COLOR_SUCCESS);
|
|
// 打印筛选后的数据
|
AppendLogLineRichStyled(_T("筛选后的主要分组数据："), LOG_COLOR_NORMAL);
|
PrintSampleData(nOutNo, vecOutput);
|
|
MEASURE_FUNC_END();
|
|
return true;
|
}
|
|
bool CSGMeasurementDlg::ExtractStableRegionFixed(int nOutNo, const std::vector<float>& vecIn, std::vector<float>& vecOut, int nFixedCount/* = 5*/, float fMaxDelta/* = 0.04f*/)
|
{
|
MEASURE_FUNC_START();
|
|
const int n = static_cast<int>(vecIn.size());
|
if (n < nFixedCount) {
|
CString strError;
|
strError.Format(_T("OUT%d: 数据量不足，至少需要 %d 个点才能提取稳定区。"), nOutNo, nFixedCount);
|
return false;
|
}
|
|
int nBestStart = -1;
|
float fBestRange = FLT_MAX;
|
|
for (int i = 0; i <= n - nFixedCount; ++i) {
|
auto first = vecIn.begin() + i;
|
auto last = first + nFixedCount;
|
|
float fMinVal = *std::min_element(first, last);
|
float fMaxVal = *std::max_element(first, last);
|
float fRange = fMaxVal - fMinVal;
|
|
if (fRange <= fMaxDelta && fRange < fBestRange) {
|
fBestRange = fRange;
|
nBestStart = i;
|
}
|
}
|
|
if (nBestStart < 0) {
|
return false;
|
}
|
|
vecOut.assign(vecIn.begin() + nBestStart, vecIn.begin() + nBestStart + nFixedCount);
|
|
CString strLog;
|
strLog.Format(_T("OUT%d: 提取稳定区成功，起始点索引 %d，范围 %.3f。"), nOutNo, nBestStart, fBestRange);
|
AppendLogLineRichStyled(strLog, LOG_COLOR_SUCCESS);
|
|
if (vecOut.size() < nFixedCount) {
|
CString strWarning;
|
strWarning.Format(_T("OUT%d: 提取的稳定区数据量不足，可能影响后续处理。"), nOutNo);
|
AppendLogLineRichStyled(strWarning, LOG_COLOR_WARNING);
|
}
|
|
// 打印提取的稳定区数据
|
AppendLogLineRichStyled(_T("提取的稳定区数据："), LOG_COLOR_NORMAL);
|
PrintSampleData(nOutNo, vecOut);
|
|
MEASURE_FUNC_END();
|
|
return true;
|
}
|
|
bool CSGMeasurementDlg::CalcGlassOffset(const std::vector<float>& vecGlass1, const std::vector<float>& vecGlass2, float& fAvg1, float& fAvg2, float& fOffset)
|
{
|
MEASURE_FUNC_START();
|
|
if (vecGlass1.empty() || vecGlass2.empty()) {
|
AppendLogLineRichStyled(_T("稳定区数据为空，无法计算平均值和偏移。"), LOG_COLOR_WARNING);
|
return false;
|
}
|
|
auto CalcAverage = [](const std::vector<float>& data) -> float {
|
float sum = std::accumulate(data.begin(), data.end(), 0.0f);
|
return sum / static_cast<float>(data.size());
|
};
|
|
fAvg1 = CalcAverage(vecGlass1);
|
fAvg2 = CalcAverage(vecGlass2);
|
fOffset = fAvg2 - fAvg1; // 第二片 - 第一片
|
//fOffset = std::fabs(fAvg2 - fAvg1); // 第二片 - 第一片
|
|
CString strLog;
|
strLog.Format(_T("第一片玻璃平均值: %.3f，第二片玻璃平均值: %.3f，偏移量: %.3f"), fAvg1, fAvg2, fOffset);
|
AppendLogLineRichStyled(strLog, LOG_COLOR_SUCCESS);
|
|
MEASURE_FUNC_END();
|
|
return true;
|
}
|
|
bool CSGMeasurementDlg::InitDataStorage()
|
{
|
if (!m_bConnected) {
|
AppendLogLineRichStyled(_T("设备未连接，请先连接设备。"), LOG_COLOR_WARNING);
|
return false;
|
}
|
|
if (m_bSaving) {
|
AppendLogLineRichStyled(_T("数据存储正在进行中，请先停止存储。"), LOG_COLOR_WARNING);
|
return false;
|
}
|
|
RC nRet = SGIF_DataStorageInit(DeviceID);
|
if (nRet == RC_OK) {
|
AppendLogLineRichStyled(_T("数据存储已清除。"), LOG_COLOR_SUCCESS);
|
return true;
|
}
|
|
CString strError;
|
strError.Format(_T("清除数据存储失败，错误码：%#X"), nRet);
|
AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);
|
return false;
|
}
|
|
bool CSGMeasurementDlg::StartDataStorage()
|
{
|
if (m_bSaving) {
|
AppendLogLineRichStyled(_T("数据存储已在进行中，请先停止存储。"), LOG_COLOR_WARNING);
|
return false;
|
}
|
|
RC nRet = SGIF_DataStorageStart(DeviceID);
|
if (nRet == RC_OK) {
|
m_bSaving = TRUE;
|
AppendLogLineRichStyled(_T("数据存储已开始。"), LOG_COLOR_SUCCESS);
|
return true;
|
}
|
|
CString strError;
|
strError.Format(_T("开始数据存储失败，错误码：%#X"), nRet);
|
AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);
|
return false;
|
}
|
|
bool CSGMeasurementDlg::StopDataStorage()
|
{
|
if (!m_bSaving) {
|
AppendLogLineRichStyled(_T("数据存储未在进行中，请先开始存储。"), LOG_COLOR_WARNING);
|
return false;
|
}
|
|
RC nRet = SGIF_DataStorageStop(DeviceID);
|
if (nRet == RC_OK) {
|
m_bSaving = FALSE;
|
AppendLogLineRichStyled(_T("数据存储已停止。"), LOG_COLOR_SUCCESS);
|
return true;
|
}
|
|
CString strError;
|
strError.Format(_T("停止数据存储失败，错误码：%#X"), nRet);
|
AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);
|
return false;
|
}
|
|
float CSGMeasurementDlg::AnalyzeStoredData(int nOutNo)
|
{
|
MEASURE_FUNC_START();
|
|
UpdateData(TRUE);
|
|
if (m_nUseTrigger) {
|
UpdateControlStatus(m_bConnected, m_bSaving);
|
AfxMessageBox(_T("当前是硬触发模式，请检查触发器状态。"), MB_ICONINFORMATION);
|
return 0xFF;
|
}
|
|
if (!m_bConnected) {
|
AppendLogLineRichStyled(_T("设备未连接，请先连接设备。"), LOG_COLOR_WARNING);
|
return 0xFF;
|
}
|
|
if (m_bSaving) {
|
AppendLogLineRichStyled(_T("数据存储正在进行中，请先停止存储。"), LOG_COLOR_WARNING);
|
return 0xFF;
|
}
|
|
if (nOutNo < 1 || nOutNo > 4) {
|
AppendLogLineRichStyled(_T("输出端口编号无效，必须在 1 到 4 之间。"), LOG_COLOR_ERROR);
|
return 0xFF;
|
}
|
|
if (m_nSavePointCount < 0) {
|
AppendLogLineRichStyled(_T("数据点数必须大于 0。"), LOG_COLOR_ERROR);
|
return 0xFF;
|
}
|
|
std::vector<float> vecBuffer(m_nSavePointCount, 0.0f);
|
int nReceived = 0;
|
|
RC nRet = SGIF_DataStorageGetData(DeviceID, nOutNo, m_nSavePointCount, vecBuffer.data(), &nReceived);
|
if (nRet != RC_OK) {
|
CString strError;
|
strError.Format(_T("读取 OUT%d 数据失败，错误码：%#X"), nOutNo, nRet);
|
AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);
|
return 0xFF;
|
}
|
|
vecBuffer.resize(nReceived);
|
CleanInvalidValuesInPlace(nOutNo, vecBuffer);
|
|
std::vector<float> vecGlass1, vecGlass2;
|
if (!SplitGlassSegments(nOutNo, vecBuffer, vecGlass1, vecGlass2, m_fJumpThreshold, m_nJumpWindow, m_nValleyMargin, m_nMinGlass1Count)) {
|
AppendLogLineRichStyled(_T("未能识别出两片玻璃的数据。"), LOG_COLOR_WARNING);
|
return 0xFF;
|
}
|
|
std::vector<float> vecGlass1Filtered, vecGlass2Filtered;
|
bool bGlass1Filtered = FilterDominantGroup(nOutNo, vecGlass1, vecGlass1Filtered);
|
bool bGlass2Filtered = FilterDominantGroup(nOutNo, vecGlass2, vecGlass2Filtered);
|
|
if (!bGlass1Filtered) {
|
AppendLogLineRichStyled(_T("Glass1 分段中未能识别出主数据组，使用原始数据。"), LOG_COLOR_WARNING);
|
vecGlass1Filtered = vecGlass1;
|
}
|
else {
|
AppendLogLineRichStyled(_T("Glass1 主数据组已提取。"), LOG_COLOR_SUCCESS);
|
}
|
|
if (!bGlass2Filtered) {
|
AppendLogLineRichStyled(_T("Glass2 分段中未能识别出主数据组，使用原始数据。"), LOG_COLOR_WARNING);
|
vecGlass2Filtered = vecGlass2;
|
}
|
else {
|
AppendLogLineRichStyled(_T("Glass2 主数据组已提取。"), LOG_COLOR_SUCCESS);
|
}
|
|
std::vector<float> vecStable1, vecStable2;
|
bool bStable1 = ExtractStableRegionFixed(nOutNo, vecGlass1Filtered, vecStable1, m_nFixedCount, m_fMaxDelta);
|
bool bStable2 = ExtractStableRegionFixed(nOutNo, vecGlass2Filtered, vecStable2, m_nFixedCount, m_fMaxDelta);
|
|
float fAvg1 = 0.0f, fAvg2 = 0.0f, fOffset = 0.0f;
|
if (bStable1 && bStable2) {
|
AppendLogLineRichStyled(_T("成功提取到两片玻璃的稳定区数据。"), LOG_COLOR_SUCCESS);
|
CalcGlassOffset(vecStable1, vecStable2, fAvg1, fAvg2, fOffset);
|
}
|
else {
|
AppendLogLineRichStyled(_T("未能提取到稳定区数据，尝试使用原始分段数据计算偏移。"), LOG_COLOR_WARNING);
|
CalcGlassOffset(vecGlass1, vecGlass2, fAvg1, fAvg2, fOffset);
|
}
|
|
MEASURE_FUNC_END();
|
|
return fOffset;
|
}
|
|
BEGIN_MESSAGE_MAP(CSGMeasurementDlg, CDialogEx)
|
ON_WM_SYSCOMMAND()
|
ON_WM_PAINT()
|
ON_WM_QUERYDRAGICON()
|
ON_WM_TIMER()
|
ON_WM_MEASUREITEM()
|
ON_WM_DRAWITEM()
|
ON_WM_CLOSE()
|
ON_MESSAGE(WM_TRAY_ICON_NOTIFY, &CSGMeasurementDlg::OnTrayIconClick)
|
ON_COMMAND(ID_TRAY_RESTORE, &CSGMeasurementDlg::OnTrayRestore)
|
ON_COMMAND(ID_TRAY_EXIT, &CSGMeasurementDlg::OnTrayExit)
|
ON_BN_CLICKED(IDC_BUTTON_CONNECT, &CSGMeasurementDlg::OnBnClickedButtonConnect)
|
ON_BN_CLICKED(IDC_BUTTON_DISCONNECT, &CSGMeasurementDlg::OnBnClickedButtonDisconnect)
|
ON_BN_CLICKED(IDC_BUTTON_RECEIVE_FROM_CTRL, &CSGMeasurementDlg::OnBnClickedButtonReceiveFromCtrl)
|
ON_BN_CLICKED(IDC_BUTTON_SEND_TO_CTRL, &CSGMeasurementDlg::OnBnClickedButtonSendToCtrl)
|
ON_BN_CLICKED(IDC_BUTTON_CLEAR_STORE, &CSGMeasurementDlg::OnBnClickedButtonClearStore)
|
ON_BN_CLICKED(IDC_BUTTON_START_STORE, &CSGMeasurementDlg::OnBnClickedButtonStartStore)
|
ON_BN_CLICKED(IDC_BUTTON_STOP_STORE, &CSGMeasurementDlg::OnBnClickedButtonStopStore)
|
ON_BN_CLICKED(IDC_BUTTON_CLEAR_LOG, &CSGMeasurementDlg::OnBnClickedButtonClearLog)
|
END_MESSAGE_MAP()
|
|
BOOL CSGMeasurementDlg::OnInitDialog()
|
{
|
CDialogEx::OnInitDialog();
|
|
// 将“关于...”菜单项添加到系统菜单中。
|
|
// IDM_ABOUTBOX 必须在系统命令范围内。
|
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
|
ASSERT(IDM_ABOUTBOX < 0xF000);
|
|
CMenu* pSysMenu = GetSystemMenu(FALSE);
|
if (pSysMenu != nullptr)
|
{
|
BOOL bNameValid;
|
CString strAboutMenu;
|
bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
|
ASSERT(bNameValid);
|
if (!strAboutMenu.IsEmpty())
|
{
|
pSysMenu->AppendMenu(MF_SEPARATOR);
|
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
|
}
|
}
|
|
// 设置此对话框的图标。 当应用程序主窗口不是对话框时，框架将自动
|
// 执行此操作
|
SetIcon(m_hIcon, TRUE); // 设置大图标
|
SetIcon(m_hIcon, FALSE); // 设置小图标
|
|
// TODO: 在此添加额外的初始化代码
|
UpdateData(FALSE);
|
UpdateControlStatus(FALSE, FALSE);
|
|
// 托盘图标初始化
|
m_trayIconData.cbSize = sizeof(NOTIFYICONDATA); // 设置托盘图标数据结构的大小
|
m_trayIconData.hWnd = m_hWnd; // 设置窗口句柄
|
m_trayIconData.uID = m_nTrayIconID; // 设置托盘图标 ID
|
m_trayIconData.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP; // 设置托盘图标的标志（图标、消息、提示文本）
|
m_trayIconData.uCallbackMessage = WM_TRAY_ICON_NOTIFY; // 设置回调消息 WM_TRAY_ICON_NOTIFY
|
m_trayIconData.hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME); // 加载托盘图标
|
lstrcpy(m_trayIconData.szTip, TRAY_ICON_TOOLTIP_TEXT); // 设置托盘提示文本
|
|
// 添加托盘图标
|
Shell_NotifyIcon(NIM_ADD, &m_trayIconData);
|
m_bTrayIconCreated = TRUE;
|
|
for (int i = 0; i < 4; i++) {
|
CString str;
|
str.Format(_T("OUT%d"), i + 1);
|
m_comboOutputPort.AddString(str);
|
}
|
m_comboOutputPort.SetCurSel(0);
|
|
// 初始化IP地址控件，设置为默认IP地址
|
((CIPAddressCtrl*)GetDlgItem(IDC_IPADDRESS))->SetAddress(192, 168, 0, 10);
|
|
// 设置 PLC 监听器的日志回调函数
|
m_plcListener.SetLogCallback([this](const CString& msg, int type) {
|
if (type == -1) {
|
AppendLogLineRichStyled(msg, LOG_COLOR_ERROR);
|
}
|
else if (type == 0) {
|
AppendLogLineRichStyled(msg, LOG_COLOR_SUCCESS);
|
}
|
else if (type == 1) {
|
AppendLogLineRichStyled(msg, LOG_COLOR_WARNING);
|
}
|
else if (type == 2) {
|
AppendLogLineRichStyled(msg, LOG_COLOR_NORMAL);
|
}
|
});
|
|
// 初始化 PLC 监听器
|
m_plcListener.Initialize(StationIdentifier(0, 255), 200);
|
|
// 设置 PLC 监听器的开始采集回调函数
|
m_plcListener.SetStartCallback([this]() {
|
if (!m_bConnected) {
|
ConnectToDevice();
|
}
|
|
if (InitDataStorage()) {
|
StartDataStorage();
|
UpdateControlStatus(m_bConnected, m_bSaving);
|
}
|
});
|
|
// 设置 PLC 监听器的停止采集回调函数
|
m_plcListener.SetStopCallback([this]() {
|
StopDataStorage();
|
UpdateControlStatus(m_bConnected, m_bSaving);
|
});
|
|
// 设置 PLC 监听器的分析回调函数
|
m_plcListener.SetAnalyzeCallback([this]() {
|
if (!m_bConnected) {
|
AppendLogLineRichStyled(_T("设备未连接，请先连接设备。"), LOG_COLOR_WARNING);
|
return std::array<double, 4>{ 0xFF, 0xFF, 0xFF, 0xFF };
|
}
|
|
std::array<double, 4> result;
|
for (int i = 0; i < 4; ++i) {
|
result[i] = AnalyzeStoredData(i + 1); // OUT1 ~ OUT4
|
}
|
|
std::string strProductID;
|
m_plcListener.ReadProductID(strProductID);
|
m_resultStorage.SaveAnalyzeResult(CString(strProductID.c_str()), result);
|
|
CString strLog;
|
strLog.Format(_T("分析结果：OUT1: %.3f, OUT2: %.3f, OUT3: %.3f, OUT4: %.3f"), result[0], result[1], result[2], result[3]);
|
return result;
|
});
|
m_plcListener.Start();
|
|
// 初始化日志框
|
AppendLogLineRichStyled(_T("准备就绪..."), LOG_COLOR_SUCCESS);
|
|
return TRUE; // 除非将焦点设置到控件，否则返回 TRUE
|
}
|
|
void CSGMeasurementDlg::OnSysCommand(UINT nID, LPARAM lParam)
|
{
|
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
|
{
|
CAboutDlg dlgAbout;
|
dlgAbout.DoModal();
|
}
|
else
|
{
|
CDialogEx::OnSysCommand(nID, lParam);
|
}
|
}
|
|
void CSGMeasurementDlg::OnPaint()
|
{
|
if (IsIconic()) {
|
CPaintDC dc(this);
|
|
SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
|
|
// 使图标在工作区矩形中居中
|
int cxIcon = GetSystemMetrics(SM_CXICON);
|
int cyIcon = GetSystemMetrics(SM_CYICON);
|
CRect rect;
|
GetClientRect(&rect);
|
int x = (rect.Width() - cxIcon + 1) / 2;
|
int y = (rect.Height() - cyIcon + 1) / 2;
|
|
// 绘制图标
|
dc.DrawIcon(x, y, m_hIcon);
|
}
|
else {
|
CDialogEx::OnPaint();
|
}
|
}
|
|
//当用户拖动最小化窗口时系统调用此函数取得光标显示。
|
HCURSOR CSGMeasurementDlg::OnQueryDragIcon()
|
{
|
return static_cast<HCURSOR>(m_hIcon);
|
}
|
|
void CSGMeasurementDlg::OnTimer(UINT_PTR nIDEvent)
|
{
|
// TODO: 在此添加消息处理程序代码和/或调用默认值
|
if (nIDEvent == TIMER_ID_OUTPUT_UPDATE) {
|
SGIF_FLOATVALUE_OUT value[4] = { 0 };
|
RC nRet = SGIF_GetCalcDataALL(DeviceID, value);
|
if (nRet == RC_OK) {
|
for (int i = 0; i < 4; ++i) {
|
double dNew = value[i].Value;
|
if (fabs(m_dOutValues[i] - dNew) > 1e-6) {
|
m_dOutValues[i] = dNew;
|
|
CString str;
|
str.Format(_T("%.3f"), dNew);
|
|
switch (i) {
|
case 0: GetDlgItem(IDC_EDIT_OUT1)->SetWindowText(str); break;
|
case 1: GetDlgItem(IDC_EDIT_OUT2)->SetWindowText(str); break;
|
case 2: GetDlgItem(IDC_EDIT_OUT3)->SetWindowText(str); break;
|
case 3: GetDlgItem(IDC_EDIT_OUT4)->SetWindowText(str); break;
|
}
|
}
|
}
|
}
|
else {
|
CString strError;
|
strError.Format(_T("获取测量值失败，错误码：%#X"), nRet);
|
AppendLogLineRichStyled(strError, LOG_COLOR_ERROR);
|
|
// 断开连接
|
if (m_bConnected) {
|
DisconnectFromDevice();
|
}
|
}
|
}
|
|
CDialogEx::OnTimer(nIDEvent);
|
}
|
|
void CSGMeasurementDlg::OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT lpMeasureItemStruct)
|
{
|
if (lpMeasureItemStruct->CtlType == ODT_MENU) {
|
lpMeasureItemStruct->itemHeight = 24;
|
lpMeasureItemStruct->itemWidth = 140;
|
}
|
}
|
|
void CSGMeasurementDlg::OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct)
|
{
|
if (lpDrawItemStruct->CtlType != ODT_MENU) {
|
return;
|
}
|
|
CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
|
CRect rc = lpDrawItemStruct->rcItem;
|
UINT id = lpDrawItemStruct->itemID;
|
|
// 背景
|
COLORREF bgColor = (lpDrawItemStruct->itemState & ODS_SELECTED) ? RGB(200, 220, 255) : RGB(255, 255, 255);
|
pDC->FillSolidRect(rc, bgColor);
|
|
// 图标
|
HICON hIcon = nullptr;
|
if (id == ID_TRAY_RESTORE) {
|
hIcon = AfxGetApp()->LoadIcon(IDI_ICON_RESTORE);
|
}
|
|
if (id == ID_TRAY_EXIT) {
|
hIcon = AfxGetApp()->LoadIcon(IDI_ICON_EXIT);
|
}
|
|
if (hIcon) {
|
DrawIconEx(pDC->GetSafeHdc(), rc.left + 4, rc.top + 4, hIcon, 16, 16, 0, NULL, DI_NORMAL);
|
}
|
|
// 文本
|
CString str;
|
if (id == ID_TRAY_RESTORE) {
|
str = _T("恢复界面");
|
}
|
|
if (id == ID_TRAY_EXIT) {
|
str = _T("退出程序");
|
}
|
|
pDC->SetBkMode(TRANSPARENT);
|
pDC->SetTextColor(RGB(0, 0, 0));
|
pDC->DrawText(str, CRect(rc.left + 28, rc.top, rc.right, rc.bottom), DT_SINGLELINE | DT_VCENTER | DT_LEFT);
|
}
|
|
void CSGMeasurementDlg::OnClose()
|
{
|
// TODO: 在此添加消息处理程序代码和/或调用默认值
|
if (m_bExitingFromTray) {
|
// 从托盘退出流程
|
ExitApplication();
|
}
|
else {
|
// 正常关闭按钮
|
int nResult = AfxMessageBox(_T("是否最小化到托盘？"), MB_YESNO | MB_ICONQUESTION);
|
if (nResult == IDYES) {
|
ShowWindow(SW_HIDE);
|
}
|
else {
|
ExitApplication();
|
}
|
}
|
}
|
|
LRESULT CSGMeasurementDlg::OnTrayIconClick(WPARAM wParam, LPARAM lParam) {
|
if (wParam == m_nTrayIconID) {
|
if (LOWORD(lParam) == WM_LBUTTONUP) {
|
// 左键点击恢复窗口
|
ShowWindow(SW_SHOW);
|
SetForegroundWindow();
|
}
|
else if (LOWORD(lParam) == WM_RBUTTONUP) {
|
// 右键点击弹出菜单
|
CMenu menu;
|
menu.CreatePopupMenu();
|
menu.AppendMenu(MF_OWNERDRAW, ID_TRAY_RESTORE, (LPCTSTR)ID_TRAY_RESTORE);
|
menu.AppendMenu(MF_OWNERDRAW, ID_TRAY_EXIT, (LPCTSTR)ID_TRAY_EXIT);
|
|
// 加载图标
|
HICON hIconRestore = (HICON)::LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_ICON_RESTORE), IMAGE_ICON, 16, 16, LR_SHARED);
|
HICON hIconExit = (HICON)::LoadImage(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_ICON_EXIT), IMAGE_ICON, 16, 16, LR_SHARED);
|
|
// 设置图标到菜单项
|
MENUITEMINFO mii = { sizeof(MENUITEMINFO) };
|
mii.fMask = MIIM_BITMAP;
|
|
// 恢复菜单项图标
|
mii.hbmpItem = HBMMENU_CALLBACK;
|
menu.SetMenuItemInfo(ID_TRAY_RESTORE, &mii);
|
|
// 退出菜单项图标
|
mii.hbmpItem = HBMMENU_CALLBACK;
|
menu.SetMenuItemInfo(ID_TRAY_EXIT, &mii);
|
|
// 获取鼠标当前位置，并显示菜单
|
POINT pt;
|
GetCursorPos(&pt);
|
SetForegroundWindow();
|
menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, this);
|
}
|
}
|
return 0;
|
}
|
|
void CSGMeasurementDlg::OnTrayRestore()
|
{
|
ShowWindow(SW_SHOW); // 恢复窗口
|
SetForegroundWindow(); // 将窗口置于前端
|
}
|
|
void CSGMeasurementDlg::OnTrayExit()
|
{
|
// 从托盘图标菜单选择“退出程序”
|
if (AfxMessageBox(_T("确定要退出程序吗？"), MB_YESNO | MB_ICONQUESTION) == IDYES) {
|
m_bExitingFromTray = TRUE;
|
PostMessage(WM_CLOSE);
|
}
|
}
|
|
void CSGMeasurementDlg::OnBnClickedButtonConnect()
|
{
|
// TODO: 在此添加控件通知处理程序代码
|
ConnectToDevice();
|
}
|
|
void CSGMeasurementDlg::OnBnClickedButtonDisconnect()
|
{
|
// TODO: 在此添加控件通知处理程序代码
|
DisconnectFromDevice();
|
}
|
|
void CSGMeasurementDlg::OnBnClickedButtonReceiveFromCtrl()
|
{
|
// TODO: 在此添加控件通知处理程序代码
|
if (!m_bConnected) {
|
AppendLogLineRichStyled(_T("设备未连接，请先连接设备。"), LOG_COLOR_WARNING);
|
return;
|
}
|
}
|
|
void CSGMeasurementDlg::OnBnClickedButtonSendToCtrl()
|
{
|
// TODO: 在此添加控件通知处理程序代码
|
if (!m_bConnected) {
|
AppendLogLineRichStyled(_T("设备未连接，请先连接设备。"), LOG_COLOR_WARNING);
|
return;
|
}
|
}
|
|
void CSGMeasurementDlg::OnBnClickedButtonClearStore()
|
{
|
// TODO: 在此添加控件通知处理程序代码
|
InitDataStorage();
|
}
|
|
void CSGMeasurementDlg::OnBnClickedButtonStartStore()
|
{
|
// TODO: 在此添加控件通知处理程序代码
|
StartDataStorage();
|
UpdateControlStatus(m_bConnected, m_bSaving);
|
}
|
|
void CSGMeasurementDlg::OnBnClickedButtonStopStore()
|
{
|
// TODO: 在此添加控件通知处理程序代码
|
StopDataStorage();
|
UpdateControlStatus(m_bConnected, m_bSaving);
|
|
int nSel = m_comboOutputPort.GetCurSel();
|
if (CB_ERR == nSel) {
|
AppendLogLineRichStyled(_T("请选择一个有效的输出端口。"), LOG_COLOR_WARNING);
|
return;
|
}
|
|
int nOutNo = nSel + 1;
|
AnalyzeStoredData(nOutNo);
|
}
|
|
void CSGMeasurementDlg::OnBnClickedButtonClearLog()
|
{
|
// TODO: 在此添加控件通知处理程序代码
|
if (::IsWindow(m_editLog.GetSafeHwnd())) {
|
m_editLog.SetWindowText(_T(""));
|
}
|
}
|
