windows读取单片机开关状态显示波形图

// yiliaodemoDlg.cpp : 实现文件
//

#include "stdafx.h"
#include "yiliaodemo.h"
#include "yiliaodemoDlg.h"
#include "afxdialogex.h"
#include "CmyDraw.h"
#include "WriteLog.h"
#include "include_cpp\\libxl.h"
enum ELE
{
    METAL_LOWVO_VOLTAGE=1,//缺陷1-金属微粒
    METAL_MIDDLE_VOLTAGE,
    METAL_HIGH_VOLTAGE,

    ELECTRICAL_LOWVO_VOLTAGE,//缺陷2-电老化
    ELECTRICAL_MIDDLE_VOLTAGE,
    ELECTRICAL_HIGH_VOLTAGE,

    LONGITUDINALCUT_LOWVO_VOLTAGE,//缺陷3-纵向刀痕
    LONGITUDINALCUT_MIDDLE_VOLTAGE,
    LONGITUDINALCUT_HIGH_VOLTAGE,

    CREOFOUTCONTLAYER_LOWVO_VOLTAGE,//缺陷4-外导电层爬电
    CREOFOUTCONTLAYER_MIDDLE_VOLTAGE,
    CREOFOUTCONTLAYER_HIGH_VOLTAGE,

    JOINTDISPLACEMENT_LOWVO_VOLTAGE,//缺陷5-接头位移
    JOINTDISPLACEMENT_MIDDLE_VOLTAGE,
    JOINTDISPLACEMENT_HIGH_VOLTAGE,

    SPLICE_LOWVO_VOLTAGE,//缺陷6-接头尖刺
    SPLICE_MIDDLE_VOLTAGE,
    SPLICE_HIGH_VOLTAGE,

    AIRGAP_LOWVO_VOLTAGE,//缺陷7-气隙
    AIRGAP_MIDDLE_VOLTAGE,
    AIRGAP_HIGH_VOLTAGE,

    TERMINALDISPLACEMENT_LOWVO_VOLTAGE,//缺陷8-终端位移
    TERMINALDISPLACEMENT_MIDDLE_VOLTAGE,
    TERMINALDISPLACEMENT_HIGH_VOLTAGE,

    TTERMINALCUT_LOWVO_VOLTAGE,//缺陷9-终端刀痕
    TTERMINALCUT_MIDDLE_VOLTAGE,
    TTERMINALCUT_HIGH_VOLTAGE,
    
    AIRGAP_LOWVO_VOLTAGE_INTERFERENCE1,//缺陷7-气隙干扰
    AIRGAP_LOWVO_VOLTAGE_INTERFERENCE2,
    AIRGAP_LOWVO_VOLTAGE_INTERFERENCE3,
    AIRGAP_LOWVO_VOLTAGE_INTERFERENCE4,
    TERMINALDISPLACEMENT_LOWVO_VOLTAGE_INTERFERENCE1,//缺陷8-终端位移干扰
    TERMINALDISPLACEMENT_LOWVO_VOLTAGE_INTERFERENCE2,
    TERMINALDISPLACEMENT_LOWVO_VOLTAGE_INTERFERENCE3,
    TERMINALDISPLACEMENT_LOWVO_VOLTAGE_INTERFERENCE4,

    TTERMINALCUT_LOWVO_VOLTAGE_INTERFERENCE1,//缺陷9-终端刀痕干扰
    TTERMINALCUT_LOWVO_VOLTAGE_INTERFERENCE2,
    TTERMINALCUT_LOWVO_VOLTAGE_INTERFERENCE3,
    TTERMINALCUT_LOWVO_VOLTAGE_INTERFERENCE4,
};
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
#define  SZCHAR unsigned char *
CList<SZCHAR,SZCHAR> list_cmd;
unsigned char szReadLBarCode[20] =                {0x01 ,0x00 ,0x00 ,0x09 ,0x00 ,0x01 ,0x00 ,0x01 ,0x45};//读ID长卡
unsigned char szPreTestData[20] =                     {0x01 ,0x00 ,0x00 ,0x09 ,0x00 ,0x01 ,0x00 ,0x02 ,0xA7};//准备测试
unsigned char szStartTestData[20] =                   {0x01 ,0x00 ,0x00 ,0x09 ,0x00 ,0x01 ,0x00 ,0x03 ,0xF9};//开始传送数据
unsigned char szDarkCurrent[20] =                    {0x01 ,0x00 ,0x00 ,0x09 ,0x00 ,0x01 ,0x00 ,0x04 ,0x7A};//质检命令一部分
unsigned char szCardIn[20] =                            {0x01 ,0x00 ,0x00 ,0x09 ,0x00 ,0x02 ,0x00 ,0x00 ,0xFF};//卡进
unsigned char szCardOut[20] =                          {0x01 ,0x00 ,0x00 ,0x09 ,0x00 ,0x02 ,0x00 ,0x01 ,0xA1};//卡出
unsigned char szTemp[20] =                              {0x01 ,0x00 ,0x00 ,0x09 ,0x00 ,0x02 ,0x00 ,0x02 ,0x43};//读温度
unsigned char szIsCardExit[20] =                       {0x01 ,0x00 ,0x00 ,0x09 ,0x00 ,0x03 ,0x00 ,0x04 ,0x35};//读ID卡芯片插入状态
unsigned char szAddPunchingData[20] =            {0x01 ,0x00 ,0x00 ,0x09 ,0x00 ,0x03 ,0x00 ,0x0A ,0x2A};//加样冲顶数据
unsigned char szReadSBarCode[20] =                {0x01 ,0x00 ,0x00 ,0x09 ,0x00 ,0x03 ,0x00 ,0x0F ,0x15};//读ID卡条码号
unsigned char szReadSBarType[20] =                 {0x01 ,0x00 ,0x00 ,0x09 ,0x00 ,0x03 ,0x00 ,0x10 ,0xC9};//读ID卡类型
unsigned char szReadStandardPointData[20] =   {0x01 ,0x00 ,0x00 ,0x09 ,0x01 ,0x00 ,0x00 ,0xF1 ,0x15};//读ID卡标准点数据
unsigned char szReadIDExtendData1[20] =         {0x01 ,0x00 ,0x00 ,0x09 ,0x01 ,0x00 ,0x00 ,0xF2 ,0xF7};//读ID芯片扩展数据一
unsigned char szReadIDExtendData2[20] =         {0x01 ,0x00 ,0x00 ,0x09 ,0x01 ,0x00 ,0x00 ,0xF3 ,0xA9};//读ID芯片扩展数据二
unsigned char szReadTCRange[20] =                  {0x01 ,0x00 ,0x00 ,0x09 ,0x01 ,0x00 ,0x00 ,0xF6 ,0x96};//TC线范围
unsigned char szStartTest[20] =                          {0x01 ,0x00 ,0x00 ,0x0D ,0x01 ,0x00 ,0x00 ,0x05 ,0x00 ,0x00 ,0x00 ,0x00 ,0xA2};//开始测试第一步
DWORD timeOut=5;
DWORD Current=0;
bool isStartTiming=false;
bool isComBusy=false;
char *StrBuffForSCode=NULL;
char StrBuff[580*4]="\0";
DWORD total=0;
int DischargeNum=78;

int widget[10]={IDC_STATICELEPIC,IDC_PICTURE,IDC_STATICFUHAO,IDC_STATICTEZZ,IDC_STATICfdl1,\
                IDC_Average,IDC_STATICfdl,IDC_max,IDC_STATICfdpl,IDC_frequence};
CMutex g_clsMutex(FALSE, NULL);
char szBlemishData[9][500]={\
"主绝缘表面金属污秽\r\n\
在工业实际情况下，电缆制作的过程中，因工程与施工失误，会造成某些金属碎屑或金属微粒附着在电缆主绝缘上，可能\
造成局部放电，长时间未处理的话甚至造成击穿等后果。在实验过程中，我们采用在电缆一端剥离外导电层，并在主绝缘\
表面附着金属碎屑进行模拟",\
\
"主绝缘外表面划伤\r\n\
在制作电缆接头时需要剥离绝缘层外半导电层，由于外半导电层与交联聚乙烯结合紧密，在剥离时容易造成绝缘表面划伤\
，缺陷尺寸通常在几毫米到几厘米范围内，试验中在试样的绝缘层表面加工一长3cm，深1mm的划痕",\
\
"外半导电层爬电\r\n\
在电缆接头制作过程中，可能因为施工人员的疏忽大意或经验不足，导致外半导层断口处有残留，则在此断口因电场分布\
不均匀容易发生爬电现象。实验中的试样电缆在剥除外半导电层过程中，一端留有宽2cm、长10cm的外半导电层未剥除干净",\
\
"绝缘内部气隙\r\n\
该类型缺陷大多是由于XLPE材料在挤出过程中发泡反应不均匀而出现的内部气隙，此类缺陷的直径大多集中于几微米到几百\
微米，试验过程中采用多片交联聚乙烯叠加、内层片打孔的方式模拟",\
\
"电树枝缺陷\r\n\
该类型缺陷大多是由于电缆内部在长期加压的条件下产生电老化，形成电树枝，造成绝缘缺陷。试验通过在电缆样品铜带中\
插针来模拟电场应力的集中，同时，利用电热联合老化箱加入电应力和热应力，经过长期老化，得到电树枝缺陷",\
\
"中间接头应力锥位移\r\n\
中间接头应力锥位移缺陷多指因接头应力锥与外半导电层断口间错位脱离，缺陷易引起局部电场集中而造成界面爬电。在接\
头预制件安装时有意使一端外半导电层断口伸出应力锥一定距离形成错位，来模拟该缺陷",\
\
"中间接头尖刺\r\n\
该缺陷大多是由于施工过程中的随机性和作业工艺水平，有时会出现电缆接头外半导电层存在尖端的现象，进而引起电场集\
中，导致接头处PD长时间存在，还可能引起沿面击穿。在中间接头的轴向中心位置，将一根铜针径向插入接头外半导电层，铜\
针直径约2mm，曲率半径约0.2mm，插入深度约10mm",\
\
"终端环状刀痕\r\n\
终端的环状刀痕缺陷是终端在安装过程中由于施工不当，在剥离本体外半导电层时用力过大，造成电缆绝缘层产生环状划痕，\
本试验选择在电缆绝缘层沿表面加工深1mm的环状划痕",\
\
"终端应力锥位移\r\n\
终端应力锥位移缺陷模型可用于模拟施工中因应力锥偏移或位移等情况造成的应力锥失效的情况。该缺陷是在终端预制件安装时\
有意使一端应力锥形成5~10cm位移，构成缺陷"\
};
 char szDischargeData[39*2][100]={\
"放电数据\\缺陷1-金属微粒\\缺陷1-金属微粒低电压.jpg","放电数据\\缺陷1-金属微粒\\缺陷1-金属微粒低电压.xlsx",\
"放电数据\\缺陷1-金属微粒\\缺陷1-金属微粒中电压.jpg","放电数据\\缺陷1-金属微粒\\缺陷1-金属微粒中电压.xlsx",\
"放电数据\\缺陷1-金属微粒\\缺陷1-金属微粒高电压.jpg","放电数据\\缺陷1-金属微粒\\缺陷1-金属微粒高电压.xlsx",\
\
"放电数据\\缺陷2-电老化\\缺陷2-电老化-低电压.jpg","放电数据\\缺陷2-电老化\\缺陷2-电老化-低电压.xlsx",\
"放电数据\\缺陷2-电老化\\缺陷2-电老化-中电压.jpg","放电数据\\缺陷2-电老化\\缺陷2-电老化-中电压.xlsx",\
"放电数据\\缺陷2-电老化\\缺陷2-电老化-高电压.jpg","放电数据\\缺陷2-电老化\\缺陷2-电老化-高电压.xlsx",\
\
"放电数据\\缺陷3-纵向刀痕\\缺陷3-纵向刀痕-低电压.jpg","放电数据\\缺陷3-纵向刀痕\\缺陷3-纵向刀痕-低电压.xlsx",\
"放电数据\\缺陷3-纵向刀痕\\缺陷3-纵向刀痕-中电压.jpg","放电数据\\缺陷3-纵向刀痕\\缺陷3-纵向刀痕-中电压.xlsx",\
"放电数据\\缺陷3-纵向刀痕\\缺陷3-纵向刀痕-高电压.jpg","放电数据\\缺陷3-纵向刀痕\\缺陷3-纵向刀痕-高电压.xlsx",\
\
"放电数据\\缺陷4-外导电层爬电\\缺陷4-外导电层爬电-低电压.jpg","放电数据\\缺陷4-外导电层爬电\\缺陷4-外导电层爬电-低电压.xlsx",\
"放电数据\\缺陷4-外导电层爬电\\缺陷4-外导电层爬电-中电压.jpg","放电数据\\缺陷4-外导电层爬电\\缺陷4-外导电层爬电-中电压.xlsx",\
"放电数据\\缺陷4-外导电层爬电\\缺陷4-外导电层爬电-高电压.jpg","放电数据\\缺陷4-外导电层爬电\\缺陷4-外导电层爬电-高电压.xlsx",\
\
"放电数据\\缺陷5-接头位移\\缺陷5-接头位移-低电压.jpg","放电数据\\缺陷5-接头位移\\缺陷5-接头位移-低电压.xlsx",\
"放电数据\\缺陷5-接头位移\\缺陷5-接头位移-中电压.jpg","放电数据\\缺陷5-接头位移\\缺陷5-接头位移-中电压.xlsx",\
"放电数据\\缺陷5-接头位移\\缺陷5-接头位移-高电压.jpg","放电数据\\缺陷5-接头位移\\缺陷5-接头位移-高电压.xlsx",\
\
"放电数据\\缺陷6-接头尖刺\\缺陷6-接头尖刺-低电压.jpg","放电数据\\缺陷6-接头尖刺\\缺陷6-接头尖刺-低电压.xlsx",\
"放电数据\\缺陷6-接头尖刺\\缺陷6-接头尖刺-中电压.jpg","放电数据\\缺陷6-接头尖刺\\缺陷6-接头尖刺-中电压.xlsx",\
"放电数据\\缺陷6-接头尖刺\\缺陷6-接头尖刺-高电压.jpg","放电数据\\缺陷6-接头尖刺\\缺陷6-接头尖刺-高电压.xlsx",\
\
"放电数据\\缺陷7-气隙\\缺陷7-气隙-低电压.jpg","放电数据\\缺陷7-气隙\\缺陷7-气隙-低电压.xlsx",\
"放电数据\\缺陷7-气隙\\缺陷7-气隙-中电压.jpg","放电数据\\缺陷7-气隙\\缺陷7-气隙-中电压.xlsx",\
"放电数据\\缺陷7-气隙\\缺陷7-气隙-高电压.jpg","放电数据\\缺陷7-气隙\\缺陷7-气隙-高电压.xlsx",\
\
"放电数据\\缺陷8-终端位移\\缺陷8-终端位移-低电压.jpg","放电数据\\缺陷8-终端位移\\缺陷8-终端位移-低电压.xlsx",\
"放电数据\\缺陷8-终端位移\\缺陷8-终端位移-中电压.jpg","放电数据\\缺陷8-终端位移\\缺陷8-终端位移-中电压.xlsx",\
"放电数据\\缺陷8-终端位移\\缺陷8-终端位移-高电压.jpg","放电数据\\缺陷8-终端位移\\缺陷8-终端位移-高电压.xlsx",\
\
"放电数据\\缺陷9-终端刀痕\\缺陷9-终端刀痕-低电压.jpg","放电数据\\缺陷9-终端刀痕\\缺陷9-终端刀痕-低电压.xlsx",\
"放电数据\\缺陷9-终端刀痕\\缺陷9-终端刀痕-中电压.jpg","放电数据\\缺陷9-终端刀痕\\缺陷9-终端刀痕-中电压.xlsx",\
"放电数据\\缺陷9-终端刀痕\\缺陷9-终端刀痕-高电压.jpg","放电数据\\缺陷9-终端刀痕\\缺陷9-终端刀痕-高电压.xlsx",\
\
"放电数据\\缺陷7-气隙-干扰\\缺陷7-气隙-低电压-干扰1.jpg","放电数据\\缺陷7-气隙-干扰\\缺陷7-气隙-低电压-干扰1.xlsx",\
"放电数据\\缺陷7-气隙-干扰\\缺陷7-气隙-低电压-干扰2.jpg","放电数据\\缺陷7-气隙-干扰\\缺陷7-气隙-低电压-干扰2.xlsx",\
"放电数据\\缺陷7-气隙-干扰\\缺陷7-气隙-低电压-干扰3.jpg","放电数据\\缺陷7-气隙-干扰\\缺陷7-气隙-低电压-干扰3.xlsx",\
"放电数据\\缺陷7-气隙-干扰\\缺陷7-气隙-低电压-干扰4.jpg","放电数据\\缺陷7-气隙-干扰\\缺陷7-气隙-低电压-干扰4.xlsx",\
\
"放电数据\\缺陷8-终端位移-干扰\\缺陷8-终端位移-低电压-干扰1.jpg","放电数据\\缺陷8-终端位移-干扰\\缺陷8-终端位移-低电压-干扰1.xlsx",\
"放电数据\\缺陷8-终端位移-干扰\\缺陷8-终端位移-低电压-干扰2.jpg","放电数据\\缺陷8-终端位移-干扰\\缺陷8-终端位移-低电压-干扰2.xlsx",\
"放电数据\\缺陷8-终端位移-干扰\\缺陷8-终端位移-低电压-干扰3.jpg","放电数据\\缺陷8-终端位移-干扰\\缺陷8-终端位移-低电压-干扰3.xlsx",\
"放电数据\\缺陷8-终端位移-干扰\\缺陷8-终端位移-低电压-干扰4.jpg","放电数据\\缺陷8-终端位移-干扰\\缺陷8-终端位移-低电压-干扰4.xlsx",\
\
"放电数据\\缺陷9-终端刀痕-干扰\\缺陷9-终端刀痕-低电压-干扰1.jpg","放电数据\\缺陷9-终端刀痕-干扰\\缺陷9-终端刀痕-低电压-干扰1.xlsx",\
"放电数据\\缺陷9-终端刀痕-干扰\\缺陷9-终端刀痕-低电压-干扰2.jpg","放电数据\\缺陷9-终端刀痕-干扰\\缺陷9-终端刀痕-低电压-干扰2.xlsx",\
"放电数据\\缺陷9-终端刀痕-干扰\\缺陷9-终端刀痕-低电压-干扰3.jpg","放电数据\\缺陷9-终端刀痕-干扰\\缺陷9-终端刀痕-低电压-干扰3.xlsx",\
"放电数据\\缺陷9-终端刀痕-干扰\\缺陷9-终端刀痕-低电压-干扰4.jpg","放电数据\\缺陷9-终端刀痕-干扰\\缺陷9-终端刀痕-低电压-干扰4.xlsx",\
\
}; char szAnalysisEIGENVALUES[39][100]={\
"放电数据\\缺陷1-金属微粒\\缺陷1-低电压 特征量.xlsx",\
"放电数据\\缺陷1-金属微粒\\缺陷1-中电压 特征量.xlsx",\
"放电数据\\缺陷1-金属微粒\\缺陷1-高电压 特征量.xlsx",\
\
"放电数据\\缺陷2-电老化\\缺陷2 低电压 特征量.xlsx",\
"放电数据\\缺陷2-电老化\\缺陷2 中电压 特征量.xlsx",\
"放电数据\\缺陷2-电老化\\缺陷2 高电压 特征量.xlsx",\
\
"放电数据\\缺陷3-纵向刀痕\\缺陷3 低电压 特征量.xlsx",\
"放电数据\\缺陷3-纵向刀痕\\缺陷3 中电压 特征量.xlsx",\
"放电数据\\缺陷3-纵向刀痕\\缺陷3 高电压 特征量.xlsx",\
\
"放电数据\\缺陷4-外导电层爬电\\缺陷4 低电压 特征量.xlsx",\
"放电数据\\缺陷4-外导电层爬电\\缺陷4 中电压 特征量.xlsx",\
"放电数据\\缺陷4-外导电层爬电\\缺陷4 高电压 特征量.xlsx",\
\
"放电数据\\缺陷5-接头位移\\缺陷5 低电压 特征量.xlsx",\
"放电数据\\缺陷5-接头位移\\缺陷5 中电压 特征量.xlsx",\
"放电数据\\缺陷5-接头位移\\缺陷5 高电压 特征量.xlsx",\
\
"放电数据\\缺陷6-接头尖刺\\缺陷6 低电压 特征量.xlsx",\
"放电数据\\缺陷6-接头尖刺\\缺陷6 中电压 特征量.xlsx",\
"放电数据\\缺陷6-接头尖刺\\缺陷6 高电压 特征量.xlsx",\
\
"放电数据\\缺陷7-气隙\\缺陷7 低电压 特征量.xlsx",\
"放电数据\\缺陷7-气隙\\缺陷7 中电压 特征量.xlsx",\
"放电数据\\缺陷7-气隙\\缺陷7 高电压 特征量.xlsx",\
\
"放电数据\\缺陷8-终端位移\\缺陷8 低电压 特征量.xlsx",\
"放电数据\\缺陷8-终端位移\\缺陷8 中电压 特征量.xlsx",\
"放电数据\\缺陷8-终端位移\\缺陷8 高电压 特征量.xlsx",\
\
"放电数据\\缺陷9-终端刀痕\\缺陷9 低电压 特征量.xlsx",\
"放电数据\\缺陷9-终端刀痕\\缺陷9 中电压 特征量.xlsx",\
"放电数据\\缺陷9-终端刀痕\\缺陷9 高电压 特征量.xlsx",\
\
"放电数据\\缺陷7-气隙-干扰\\缺陷7 干扰1 特征量.xlsx",\
"放电数据\\缺陷7-气隙-干扰\\缺陷7 干扰2 特征量.xlsx",\
"放电数据\\缺陷7-气隙-干扰\\缺陷7 干扰3 特征量.xlsx",\
"放电数据\\缺陷7-气隙-干扰\\缺陷7 干扰4 特征量.xlsx",\
\
"放电数据\\缺陷8-终端位移-干扰\\缺陷8 干扰1 特征量.xlsx",\
"放电数据\\缺陷8-终端位移-干扰\\缺陷8 干扰2 特征量.xlsx",\
"放电数据\\缺陷8-终端位移-干扰\\缺陷8 干扰3 特征量.xlsx",\
"放电数据\\缺陷8-终端位移-干扰\\缺陷8 干扰4 特征量.xlsx",\
\
"放电数据\\缺陷9-终端刀痕-干扰\\缺陷9 干扰1 特征量.xlsx",\
"放电数据\\缺陷9-终端刀痕-干扰\\缺陷9 干扰2 特征量.xlsx",\
"放电数据\\缺陷9-终端刀痕-干扰\\缺陷9 干扰3 特征量.xlsx",\
"放电数据\\缺陷9-终端刀痕-干扰\\缺陷9 干扰4 特征量.xlsx",\
\
};
using namespace libxl;
typedef struct DataPos
{
    double x;
    double y;
};
typedef struct EigenValuesDataPos
{
    double Average;
    double max;
    double frequence;
};

DataPos stu_DataPos[2048*50];
EigenValuesDataPos stu_EigenValuesDataPos[6];
char *memcat(char * dest, size_t dest_len, const char *src, size_t src_len);
static const unsigned char CRC8Table[256] =
{
    0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83, 
    0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41, 
    0x9d, 0xc3, 0x21, 0x7f, 0xfc, 0xa2, 0x40, 0x1e, 
    0x5f, 0x01, 0xe3, 0xbd, 0x3e, 0x60, 0x82, 0xdc, 
    0x23, 0x7d, 0x9f, 0xc1, 0x42, 0x1c, 0xfe, 0xa0, 
    0xe1, 0xbf, 0x5d, 0x03, 0x80, 0xde, 0x3c, 0x62, 
    0xbe, 0xe0, 0x02, 0x5c, 0xdf, 0x81, 0x63, 0x3d, 
    0x7c, 0x22, 0xc0, 0x9e, 0x1d, 0x43, 0xa1, 0xff, 
    0x46, 0x18, 0xfa, 0xa4, 0x27, 0x79, 0x9b, 0xc5, 
    0x84, 0xda, 0x38, 0x66, 0xe5, 0xbb, 0x59, 0x07, 
    0xdb, 0x85, 0x67, 0x39, 0xba, 0xe4, 0x06, 0x58, 
    0x19, 0x47, 0xa5, 0xfb, 0x78, 0x26, 0xc4, 0x9a, 
    0x65, 0x3b, 0xd9, 0x87, 0x04, 0x5a, 0xb8, 0xe6, 
    0xa7, 0xf9, 0x1b, 0x45, 0xc6, 0x98, 0x7a, 0x24, 
    0xf8, 0xa6, 0x44, 0x1a, 0x99, 0xc7, 0x25, 0x7b, 
    0x3a, 0x64, 0x86, 0xd8, 0x5b, 0x05, 0xe7, 0xb9, 
    0x8c, 0xd2, 0x30, 0x6e, 0xed, 0xb3, 0x51, 0x0f, 
    0x4e, 0x10, 0xf2, 0xac, 0x2f, 0x71, 0x93, 0xcd, 
    0x11, 0x4f, 0xad, 0xf3, 0x70, 0x2e, 0xcc, 0x92, 
    0xd3, 0x8d, 0x6f, 0x31, 0xb2, 0xec, 0x0e, 0x50, 
    0xaf, 0xf1, 0x13, 0x4d, 0xce, 0x90, 0x72, 0x2c, 
    0x6d, 0x33, 0xd1, 0x8f, 0x0c, 0x52, 0xb0, 0xee, 
    0x32, 0x6c, 0x8e, 0xd0, 0x53, 0x0d, 0xef, 0xb1, 
    0xf0, 0xae, 0x4c, 0x12, 0x91, 0xcf, 0x2d, 0x73, 
    0xca, 0x94, 0x76, 0x28, 0xab, 0xf5, 0x17, 0x49, 
    0x08, 0x56, 0xb4, 0xea, 0x69, 0x37, 0xd5, 0x8b, 
    0x57, 0x09, 0xeb, 0xb5, 0x36, 0x68, 0x8a, 0xd4, 
    0x95, 0xcb, 0x29, 0x77, 0xf4, 0xaa, 0x48, 0x16, 
    0xe9, 0xb7, 0x55, 0x0b, 0x88, 0xd6, 0x34, 0x6a, 
    0x2b, 0x75, 0x97, 0xc9, 0x4a, 0x14, 0xf6, 0xa8, 
    0x74, 0x2a, 0xc8, 0x96, 0x15, 0x4b, 0xa9, 0xf7, 
    0xb6, 0xe8, 0x0a, 0x54, 0xd7, 0x89, 0x6b, 0x35, 
};

unsigned char CRC8(unsigned char *p, char len)
{
    unsigned char crc8 = 0;
    int iLen=len&0xff;
    for( ; iLen > 0; iLen--)
    {
       crc8 = CRC8Table[crc8^*p]; //鏌ヨ〃寰楀埌CRC鐮?
       p++;
    }
    return crc8;
}
int Hex2Str(int InLen, unsigned char *InData, char *OutBuffer)
{
    int i,j;
    char ch1,ch2;
    j=0;
    for(i=0;i<InLen;i++)
    {
        ch1=(InData[i]&0xf0)>>4;
        ch2=(InData[i]&0x0f);
        if(ch1<10)
        {
            OutBuffer[j++]=ch1+0x30;
        }
        else
        {
            OutBuffer[j++]=ch1+0x37;
        }
        
        if(ch2<10)
        {
            OutBuffer[j++]=ch2+0x30;
        }
        else
        {
            OutBuffer[j++]=ch2+0x37;
        }
        OutBuffer[j++]=32;
    }
    OutBuffer[j-1]=0;
    return j;
}
int Str2Hex(int InLen, char *InBuffer, char *OutArray)
{
    int  i = 0,j = 0;
    char tmp;
    for( i=0,j=0;i < InLen;)
    {
        if( InBuffer[i] >= 0x30 && InBuffer[i] <= 0x39 )
        {
            tmp = (InBuffer[i] - 0x30)<<4;
        }
        else if( InBuffer[i] >= 0x41 && InBuffer[i] <= 0x46 )
        {
            tmp=(InBuffer[i] - 0x37)<<4;//tmp=(InBuffer[i] - 'A' + 0xa)<<4 =(InBuffer[i] - 0x41' + 0xa)<<4  ; 
        }
        else if( InBuffer[i] >= 0x61 && InBuffer[i] <= 0x66 )
        {
            tmp=(InBuffer[i] - 0x57)<<4;     
        }
        i++;
        
        if( InBuffer[i] >= 0x30 && InBuffer[i] <= 0x39 )
        {
            tmp = tmp | (InBuffer[i] - 0x30);
        }
        else if( InBuffer[i] >= 0x41 && InBuffer[i] <= 0x46 )
        {
            tmp= tmp | (InBuffer[i] - 0x37);
        }
        else if( InBuffer[i] >= 0x61 && InBuffer[i] <= 0x66 )
        {
            tmp =tmp | (InBuffer[i] - 0x57);
        }
        
        OutArray[j++] = tmp;
        i++;
        i++;
    }
       return(j);
}
static DWORD UserAdcProcessThread(LPVOID pParam);
static DWORD UserTimeoutThread(LPVOID pParam);
class CAboutDlg : public CDialogEx
{
public :
    CAboutDlg();

// 对话框数据
    enum { IDD = IDD_ABOUTBOX };

    protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持

// 实现
protected:
    DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()

// CyiliaodemoDlg 对话框

DWORD dwTimeout=5000;
static DWORD UserTimeoutThread(LPVOID pParam)
{
    Sleep(dwTimeout);
    list_cmd.AddTail(szStartTestData);
    return 1;
}
static DWORD UserAdcProcessThread(LPVOID pParam)
{
    CyiliaodemoDlg *dlg=(CyiliaodemoDlg*) pParam;//new CuserkeyDlg;// 
    unsigned char szCmd[20]="\0";
    char sendbuf[512]="\0";
    int iLen;
    while(1)
    {
        if((!list_cmd.IsEmpty())&&(!isComBusy))
        {
            isComBusy = true;
            memcpy(szCmd,list_cmd.GetHead(),20);
            //list_cmd.RemoveHead();
            iLen = szCmd[2]<<8;
            iLen += szCmd[3];
            
            isStartTiming=true;
            dlg->m_pSerial->WriteSyncPort(szCmd,iLen);
            Hex2Str(iLen,szCmd,sendbuf);
            LogPrint("iLen = %d SendBuf = %s\n",iLen,sendbuf);
        }
        if(list_cmd.IsEmpty())
        {
            //LogPrint("list_cmd.IsEmpty() = true\n");
        }
        if(isComBusy)
        {
            //LogPrint("isComBusy = true\n");
        }
        Sleep(500);
        if(isStartTiming) 
            Current+=1;
        if(Current>5)
        {
            switch(dlg->iIndex)
            {
            case 0x20000:dlg->SetDlgItemText(IDC_LBLCARDIN,"失败");isStartTiming=false;Current=0;isComBusy = false;break;
            case 0x20001:dlg->SetDlgItemText(IDC_LBLCARDOUT,"失败");isStartTiming=false;Current=0;isComBusy = false;break;
            case 0x20002:dlg->SetDlgItemText(IDC_LBLREADTEMP,"失败");isStartTiming=false;Current=0;isComBusy = false;break;
            case 0x10001:dlg->SetDlgItemText(IDC_LBLREAGENTCARDCODE,"失败");isStartTiming=false;Current=0;isComBusy = false;break;
            case 0x3000F:dlg->SetDlgItemText(IDC_LBLREADIDCODE,"失败");isStartTiming=false;Current=0;isComBusy = false;break;
            case 0x10000F2:
                            dlg->SetDlgItemText(IDC_LBLITEM,"失败");
                            dlg->SetDlgItemText(IDC_LBLUINT,"失败");
                            dlg->SetDlgItemText(IDC_LBLITEM2,"失败");
                            dlg->SetDlgItemText(IDC_LBLIDCODE2,"失败");
                            dlg->SetDlgItemText(IDC_LBLBATCHNMB,"失败");isStartTiming=false;Current=0;isComBusy = false;break;
            case 0x10002:
                        if(Current<10)
                                    {
                                        isComBusy = false;isComBusy = false;
                                        break;
                                    }
            case 0x10003:if(Current>40){
                            dlg->SetDlgItemText(IDC_LBLREADDATARESULT,"失败");
                            isStartTiming=false;Current=0;isComBusy = false;
                         }
                         break;
            }
        }
    }
}

CyiliaodemoDlg::CyiliaodemoDlg(CWnd* pParent /*=NULL*/)
    : CDialogEx(CyiliaodemoDlg::IDD, pParent)
{
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CyiliaodemoDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialogEx::DoDataExchange(pDX);
    DDX_Control(pDX, IDC_COM, m_Com);
    DDX_Control(pDX, IDC_BOARD, m_BardRate);
    DDX_Control(pDX, IDC_BTNOPENCOM, m_Open);
}

BEGIN_MESSAGE_MAP(CyiliaodemoDlg, CDialogEx)
    ON_WM_SYSCOMMAND()
    ON_WM_PAINT()
    ON_WM_TIMER()
    ON_WM_QUERYDRAGICON()
    ON_MESSAGE(WM_RECV_SERIAL_DATA,OnRecvSerialData)
    ON_BN_CLICKED(IDC_BTNOPENCOM, &CyiliaodemoDlg::OnBtnOpenCom)

    ON_BN_CLICKED(IDC_BTNCARDIN, &CyiliaodemoDlg::OnBtnCardIn)
    ON_BN_CLICKED(IDC_BTNCARDOUT, &CyiliaodemoDlg::OnBtnCardOut)
    ON_BN_CLICKED(IDC_BTNREADTMP, &CyiliaodemoDlg::OnBtnReadTmp)
    ON_BN_CLICKED(IDC_BTNREADCODE, &CyiliaodemoDlg::OnBtnReadCode)
    ON_BN_CLICKED(IDC_BTNREADIDCODE, &CyiliaodemoDlg::OnBtnReadIDCode)
    ON_BN_CLICKED(IDC_BTNREADDATA, &CyiliaodemoDlg::OnBtnReadData)
    ON_BN_CLICKED(IDC_BTNREADIDDATA, &CyiliaodemoDlg::OnBtnReadIDData)
    ON_BN_CLICKED(IDC_BTNCURVE, &CyiliaodemoDlg::OnBtnOpenCurve)
    ON_WM_LBUTTONDOWN()
    ON_BN_CLICKED(IDC_BUTTON1, &CyiliaodemoDlg::OnBnClickedButton1)
    ON_BN_CLICKED(IDC_BUTTON2, &CyiliaodemoDlg::OnBnClickedButton2)
    ON_BN_CLICKED(IDC_PAUSE, &CyiliaodemoDlg::OnBnClickedPause)
    ON_BN_CLICKED(IDC_STOP, &CyiliaodemoDlg::OnBnClickedStop)
    ON_WM_CTLCOLOR()
    ON_WM_DRAWITEM()
    ON_BN_CLICKED(IDC_AnalysisEIGENVALUES, &CyiliaodemoDlg::OnBnClickedAnalysiseigenvalues)
    ON_WM_SIZE()
END_MESSAGE_MAP()

// CyiliaodemoDlg 消息处理程序

// CyiliaoDlg 消息处理程序
void FindCommPort(CComboBox *pComboBox )
{
    HKEY hKey;
#ifdef _DEBUG
    ASSERT( pComboBox != NULL );
    pComboBox->AssertValid();
#endif
    if( ::RegOpenKeyEx( HKEY_LOCAL_MACHINE,
        "Hardware\\DeviceMap\\SerialComm",
        NULL,
        KEY_READ,
        &hKey) == ERROR_SUCCESS) // 打开串口注册表
    {
        int i=0;
        char portName[256],commName[256];
        DWORD dwLong,dwSize;
        while(1)
        {
            dwLong = dwSize = sizeof(portName);
            if( ::RegEnumValue( hKey,
                i,
                portName,
                &dwLong,
                NULL,
                NULL,
                (PUCHAR)commName,
                &dwSize ) == ERROR_NO_MORE_ITEMS ) // 枚举串口
                break;
            pComboBox->AddString( commName ); // commName就是串口名字
            pComboBox->SetCurSel(i);
            i++;
        }
        if( pComboBox->GetCount() == 0 )
        {
            ::AfxMessageBox("在HKEY_LOCAL_MACHINE:Hardware\\DeviceMap\\SerialComm里找不到串口!!!" );
        }
        RegCloseKey(hKey);
    }
} 
static UINT indicators[] =
{
    ID_STAUTSCOM,           // status line indicator
    ID_STAUTSXY,
    ID_STAUTSINFO
};
BOOL CyiliaodemoDlg::OnInitDialog()
{
    CDialogEx::OnInitDialog();
    DWORD threadID; 
    // 将“关于...”菜单项添加到系统菜单中。

    // IDM_ABOUTBOX 必须在系统命令范围内。
    ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
    ASSERT(IDM_ABOUTBOX < 0xF000);

    CMenu* pSysMenu = GetSystemMenu(FALSE);
    if (pSysMenu != NULL)
    {
        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);        // 设置小图标
    m_Statusbar.Create(this);
    m_Statusbar.SetIndicators(indicators,sizeof(indicators)/sizeof(UINT));
    CRect rect;
    GetWindowRect(&oldRect[10]);ScreenToClient(oldRect[10]);
    m_Statusbar.SetPaneInfo(0,ID_STAUTSCOM,SBPS_STRETCH, oldRect[10].Width()/3);
    m_Statusbar.SetPaneInfo(1,ID_STAUTSXY,SBPS_NORMAL ,oldRect[10].Width()/3);
    m_Statusbar.SetPaneInfo(2,ID_STAUTSINFO,SBPS_NORMAL, oldRect[10].Width()/3);
    
    m_Statusbar.GetWindowRect(&oldRect[12]);
    //m_Statusbar.SetPaneText(0,"就绪");
    //m_Statusbar.SetPaneText(1,"速度：0kb/s");
    //m_Statusbar.SetPaneText(2,"端口：8888");
    //m_Statusbar.SetPaneText(3,"连接：0");
 
    RepositionBars(AFX_IDW_CONTROLBAR_FIRST,
        AFX_IDW_CONTROLBAR_LAST,0);
    // TODO: 在此添加额外的初始化代码
    m_BardRate.AddString(_T("1200"));
    m_BardRate.AddString(_T("57600"));
    m_BardRate.AddString(_T("19200"));
    m_BardRate.AddString(_T("115200"));
    WriteCmdThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)UserAdcProcessThread,  this,  0, &threadID);

    m_BardRate.SetCurSel(3);
    FindCommPort(&m_Com);
    iIndex = 0;
    m_pSerial = NULL;
    //SetWindowPos(NULL,0,0,800,600,SWP_NOZORDER | SWP_NOMOVE);

    m_XlsLength = 0;
    m_add = 0;
    isAdd = false;
    isPause = true;
    SetDlgItemText(IDC_TIME,"10");
    SetDlgItemText(IDC_XWIDTH,"360");
    SetDlgItemText(IDC_YWIDTH,"18000");
//    CRect rect;
    CRect rectL,rectR;
    GetDlgItem(IDC_STATICQ)->GetWindowRect(&rectL);ScreenToClient(rectL);
    GetDlgItem(IDC_STATICELEPIC)->GetWindowRect(&rectR);ScreenToClient(rectR);

    GetDlgItem(IDC_STATICELEPIC)->GetWindowRect(&oldRect[0]);ScreenToClient(oldRect[0]);
    GetDlgItem(IDC_PICTURE)->GetWindowRect(&oldRect[1]);;ScreenToClient(oldRect[1]);
    GetDlgItem(IDC_STATICFUHAO)->GetWindowRect(&oldRect[2]);ScreenToClient(oldRect[2]);
    GetDlgItem(IDC_STATICTEZZ)->GetWindowRect(&oldRect[3]);ScreenToClient(oldRect[3]);
    GetDlgItem(IDC_STATICfdl1)->GetWindowRect(&oldRect[4]);ScreenToClient(oldRect[4]);
    GetDlgItem(IDC_Average)->GetWindowRect(&oldRect[5]);ScreenToClient(oldRect[5]);
    GetDlgItem(IDC_STATICfdl)->GetWindowRect(&oldRect[6]);ScreenToClient(oldRect[6]);
    GetDlgItem(IDC_max)->GetWindowRect(&oldRect[7]);ScreenToClient(oldRect[7]);
    GetDlgItem(IDC_STATICfdpl)->GetWindowRect(&oldRect[8]);ScreenToClient(oldRect[8]);
    GetDlgItem(IDC_frequence)->GetWindowRect(&oldRect[9]);ScreenToClient(oldRect[9]);
    //m_SrcX = rectL.left + rectL.Width()/2;
    //m_SrcY = rectL.bottom  + rectL.Height();//105;
    m_Eigenvalues = 0;

    m_XDivide = 10 ;
    m_YDivide = 20 ;
    m_XWidth = (rectR.Width()-10)/360*360;//360;
    m_YWidth = (rectR.Height()-10)/360*360;//360;
    
    m_SrcX = rectR.left + (rectR.Width()-m_XWidth)/2+5;
    m_SrcY = rectR.top  + (rectR.Height()-m_XWidth)/2;

    m_VirtualXWidth = 360;
    m_VirtualYWidth = 3600;

    m_type = 0; 
    m_brush.CreateSolidBrush(RGB(155, 170, 190));//设置画刷的颜色
    UpdateXYWidth();
    return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
} 
void CyiliaodemoDlg::UpdateXYWidth()
{
    char temp[200]="\0";

    g_clsMutex.Lock();

    GetDlgItemText(IDC_XWIDTH,temp,8);
    m_VirtualXWidth = atoi(temp);

    memset(temp,0,200);

    GetDlgItemText(IDC_YWIDTH,temp,8);
    m_VirtualYWidth = atoi(temp)*2;

    CString cs;
    cs.Format("%d,%d",m_VirtualXWidth,m_VirtualYWidth);
//    MessageBox(cs);
    g_clsMutex.Unlock();
} 

bool CyiliaodemoDlg::Loading(char *strXlsPth,CString strJpgPth)
{    
    Book* book = xlCreateXMLBook();
    CString cs;
    const char * x = "Halil Kural";
    const char * y = "windows-2723210a07c4e90162b26966a8jcdboe";
    book->setKey(x, y);
    if (book)
    {
        if (book->load(strXlsPth))
        {
                for (int i = 0; i < book->sheetCount(); ++i)
                {
                    Sheet* sheet = book->getSheet(i);
                    if (!sheet)
                        break;
                    int rowNum = sheet->lastRow();
                    int colNum = sheet->lastCol();
                    m_XlsLength = rowNum;//*colNum;
                    CString cs1;
                    for (int j = 1; j < rowNum; ++j)
                    {
                        //for (int k = 0; k < colNum; ++k)
                        {
                            //std::cout << sheet->readNum(j, k) << ",";
                            //strXlsData[j*colNum+k] = sheet->readNum(j, k);
                            stu_DataPos[j].y = sheet->readNum(j, 0);
                            stu_DataPos[j].x = sheet->readNum(j, 1);
                            //cs1.Format("%.4f",sheet->readNum(j, k));
                            //MessageBox(cs1);
                        }
                        //std::cout << std::endl;
                    }
            //std::cout << "book->sheetCount()" << rowNum << std::endl;
                }
                
        } else {
                cs.Format("打开表格失败 %s",strXlsPth);
                MessageBox(cs);
                return false;
            //std::cout << "At first run generate !" << std::endl;
        }
    } else {
    
    }

    m_strFilePath = strJpgPth;
    return true;
}
void CyiliaodemoDlg::OnBtnOpenCom()
{
    // TODO: 在此添加控件通知处理程序代码
    int iRet;
    int iPortNo=m_Com.GetCurSel();
    int iBaudRate=9600;
    if (m_BardRate.GetCurSel()==0) iBaudRate=1200;
    if (m_BardRate.GetCurSel()==1) iBaudRate=57600;
    else if (m_BardRate.GetCurSel()==2) iBaudRate=19200;
    else if (m_BardRate.GetCurSel()==3) iBaudRate=115200;
    CString cs;
    m_Open.GetWindowTextA(cs);
    if(cs=="关闭")
    {
        if (m_pSerial != NULL)
        {    
            //关闭串口
            m_pSerial->ClosePort();
            //释放串口对象
            delete m_pSerial;
            m_pSerial = NULL;
            m_Open.SetWindowTextA("打开");
            
            cs.Format("串口已关闭");
            m_Statusbar.SetPaneText(0,cs);
        }
    }
    else
    {
        //判断串口是否已经打开
        if (m_pSerial != NULL)
        {
            m_pSerial->ClosePort();

            delete m_pSerial;
            m_pSerial = NULL;
        }
        CString strTemp;
        CString m_com;
        m_Com.GetWindowText(strTemp);
        LogPrint(strTemp);
        //新建串口通讯对象
        m_pSerial = new CCESeries();
        m_pSerial->m_OnSeriesRead = OnSerialRead; //
        CString a;
        
        
        m_Com.GetWindowText(strTemp);
        m_BardRate.GetWindowText(a);
        //打开串口
        LogPrint(strTemp);
        LogPrint(a);
        if (m_pSerial->OpenPort(this,strTemp,a))
        {
            m_Open.SetWindowTextA("关闭");
            LogPrint("OpenPort SUCCED\n");
            cs.Format("串口打开成功");
            m_Statusbar.SetPaneText(0,cs);
        }
        else
        {
            MessageBox(_T("open device failed!"));
        }
    }
}
int times=0;
DWORD iLen=0;
DWORD HavRead=0;
BYTE savereadBuf[4096]="\0";
//定义串口接收数据函数类型
void CALLBACK CyiliaodemoDlg::OnSerialRead(void * pOwner,BYTE* buf,DWORD bufLen)
{
    CyiliaodemoDlg* pThis = (CyiliaodemoDlg*)pOwner;
    BYTE buff[100]="\0";
    char  pBufOut[200] = "\0";// = NULL;
    unsigned char crc;
    BYTE *pRecvBuf = new BYTE[bufLen];
    int i=0;
    int iWantRead = 0;
    CString cs;
    ZeroMemory(pRecvBuf,bufLen);
    memcpy(pRecvBuf,buf,bufLen);
    Hex2Str(bufLen,(unsigned char *)buf,pBufOut);
    LogPrint("OnSerialRead dwBufLen = %d pBuf = %s\n",bufLen,pBufOut);

    pThis->PostMessage(WM_RECV_SERIAL_DATA,WPARAM(pRecvBuf),bufLen);
    
    Sleep(10);
    delete[] pRecvBuf;
    pRecvBuf = NULL;
}

/*消息列队检测及处理*/
void ProcessMsgLoop2()
{
    MSG Msg;
    if(PeekMessage(&Msg,NULL,0,0,PM_REMOVE))    //消息队列检查线程,无消息时返回FALSE
    {
        //此处可以处理窗口消息
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }
    return;
}
// 串口接收数据处理函数
char *memcat(char * dest, size_t dest_len, const char *src, size_t src_len)
{
    memcpy(dest+dest_len, src, src_len);
    return dest;
}
char gsendbuf[512]="\0";
DWORD dwReadSize=0;
LONG CyiliaodemoDlg::OnRecvSerialData(WPARAM wParam,LPARAM lParam)
{
    CString strOldRecv ;
    CString strRecv ;
    DWORD dwBufLen = lParam;
    CString str;
    DWORD iLen;
    DWORD dwCmd = 0;
    unsigned char *pBuf = (unsigned char *)wParam;
    char  pBufOut[200] = "\0";// = NULL;
    char  sendbuf[512]="\0";
    char  szSavBuff[255]="\0";
    char  szRxBuff[255] = "\0";
    float fTemp;
    int j = 0;
    DWORD iPos = 0;
    long eleticReleaseType = 0;
    if(m_pSerial == NULL)
    {
        return 1;
    }
    eleticReleaseType = pBuf[0]+(pBuf[1])*256;
    //CString cs;cs.Format("0x%x 0x%x 0x%x",eleticReleaseType,pBuf[0],pBuf[1]);
    //MessageBox(cs);
    ProcessMsgLoop2();
    switch(eleticReleaseType&0xffff)
    {
        /*
        ** 低电压9中缺陷
        */
        case 0x9:StartShowEleInfo(METAL_LOWVO_VOLTAGE,METAL_LOWVO_VOLTAGE);break; //01001
        case 0x11:StartShowEleInfo(ELECTRICAL_LOWVO_VOLTAGE,ELECTRICAL_LOWVO_VOLTAGE);break;//10001
        case 0x21:StartShowEleInfo(LONGITUDINALCUT_LOWVO_VOLTAGE,LONGITUDINALCUT_LOWVO_VOLTAGE);break;//100001
        case 0x41:StartShowEleInfo(CREOFOUTCONTLAYER_LOWVO_VOLTAGE,CREOFOUTCONTLAYER_LOWVO_VOLTAGE);break;//100 0001
        case 0x81:StartShowEleInfo(JOINTDISPLACEMENT_LOWVO_VOLTAGE,JOINTDISPLACEMENT_LOWVO_VOLTAGE);break;//1000 0001
        case 0x101:StartShowEleInfo(SPLICE_LOWVO_VOLTAGE,SPLICE_LOWVO_VOLTAGE);break;//10000 0001
        case 0x201:StartShowEleInfo(AIRGAP_LOWVO_VOLTAGE,AIRGAP_LOWVO_VOLTAGE);break;//10000 0001
        case 0x401:StartShowEleInfo(TERMINALDISPLACEMENT_LOWVO_VOLTAGE,TERMINALDISPLACEMENT_LOWVO_VOLTAGE);break;//10000 0001
        case 0x801:StartShowEleInfo(TTERMINALCUT_LOWVO_VOLTAGE,TTERMINALCUT_LOWVO_VOLTAGE);break;//10000 0001
        /*
        ** 中电压9中缺陷
        */
        case 0xA:StartShowEleInfo(METAL_MIDDLE_VOLTAGE,METAL_MIDDLE_VOLTAGE);break; //01001
        case 0x12:StartShowEleInfo(ELECTRICAL_MIDDLE_VOLTAGE,ELECTRICAL_MIDDLE_VOLTAGE);break;//10001
        case 0x22:StartShowEleInfo(LONGITUDINALCUT_MIDDLE_VOLTAGE,LONGITUDINALCUT_MIDDLE_VOLTAGE);break;//100001
        case 0x42:StartShowEleInfo(CREOFOUTCONTLAYER_MIDDLE_VOLTAGE,CREOFOUTCONTLAYER_MIDDLE_VOLTAGE);break;//100 0001
        case 0x82:StartShowEleInfo(JOINTDISPLACEMENT_MIDDLE_VOLTAGE,JOINTDISPLACEMENT_MIDDLE_VOLTAGE);break;//1000 0001
        case 0x102:StartShowEleInfo(SPLICE_MIDDLE_VOLTAGE,SPLICE_MIDDLE_VOLTAGE);break;//10000 0001
        case 0x202:StartShowEleInfo(AIRGAP_MIDDLE_VOLTAGE,AIRGAP_MIDDLE_VOLTAGE);break;//10000 0001
        case 0x402:StartShowEleInfo(TERMINALDISPLACEMENT_MIDDLE_VOLTAGE,TERMINALDISPLACEMENT_MIDDLE_VOLTAGE);break;//10000 0001
        case 0x802:StartShowEleInfo(TTERMINALCUT_MIDDLE_VOLTAGE,TTERMINALCUT_MIDDLE_VOLTAGE);break;//10000 0001    
        /*
        ** 高电压9中缺陷
        */
        case 0xC:StartShowEleInfo(METAL_HIGH_VOLTAGE,METAL_HIGH_VOLTAGE);break; //01001
        case 0x14:StartShowEleInfo(ELECTRICAL_HIGH_VOLTAGE,ELECTRICAL_HIGH_VOLTAGE);break;//10001
        case 0x24:StartShowEleInfo(LONGITUDINALCUT_HIGH_VOLTAGE,LONGITUDINALCUT_HIGH_VOLTAGE);break;//100001
        case 0x44:StartShowEleInfo(CREOFOUTCONTLAYER_HIGH_VOLTAGE,CREOFOUTCONTLAYER_HIGH_VOLTAGE);break;//100 0001
        case 0x84:StartShowEleInfo(JOINTDISPLACEMENT_HIGH_VOLTAGE,JOINTDISPLACEMENT_HIGH_VOLTAGE);break;//1000 0001
        case 0x104:StartShowEleInfo(SPLICE_HIGH_VOLTAGE,SPLICE_HIGH_VOLTAGE);break;//10000 0001
        case 0x204:StartShowEleInfo(AIRGAP_HIGH_VOLTAGE,AIRGAP_HIGH_VOLTAGE);break;//10000 0001
        case 0x404:StartShowEleInfo(TERMINALDISPLACEMENT_HIGH_VOLTAGE,TERMINALDISPLACEMENT_HIGH_VOLTAGE);break;//10000 0001
        case 0x804:StartShowEleInfo(TTERMINALCUT_HIGH_VOLTAGE,TTERMINALCUT_HIGH_VOLTAGE);break;//10000 0001    
        /*
        ** 低电压12中干扰
        */
        case 0x1201:StartShowEleInfo(AIRGAP_LOWVO_VOLTAGE,AIRGAP_LOWVO_VOLTAGE_INTERFERENCE1);break; //01001
        case 0x2201:StartShowEleInfo(AIRGAP_LOWVO_VOLTAGE,AIRGAP_LOWVO_VOLTAGE_INTERFERENCE2);break;//10001
        case 0x4201:StartShowEleInfo(AIRGAP_LOWVO_VOLTAGE,AIRGAP_LOWVO_VOLTAGE_INTERFERENCE3);break;//100001
        case 0x8201:StartShowEleInfo(AIRGAP_LOWVO_VOLTAGE,AIRGAP_LOWVO_VOLTAGE_INTERFERENCE4);break; //01001
            
        case 0x1401:StartShowEleInfo(TERMINALDISPLACEMENT_LOWVO_VOLTAGE,TERMINALDISPLACEMENT_LOWVO_VOLTAGE_INTERFERENCE1);break; //01001
        case 0x2401:StartShowEleInfo(TERMINALDISPLACEMENT_LOWVO_VOLTAGE,TERMINALDISPLACEMENT_LOWVO_VOLTAGE_INTERFERENCE2);break;//10001
        case 0x4401:StartShowEleInfo(TERMINALDISPLACEMENT_LOWVO_VOLTAGE,TERMINALDISPLACEMENT_LOWVO_VOLTAGE_INTERFERENCE3);break;//100001
        case 0x8401:StartShowEleInfo(TERMINALDISPLACEMENT_LOWVO_VOLTAGE,TERMINALDISPLACEMENT_LOWVO_VOLTAGE_INTERFERENCE4);break; //01001
            
        case 0x1801:StartShowEleInfo(TTERMINALCUT_LOWVO_VOLTAGE,TTERMINALCUT_LOWVO_VOLTAGE_INTERFERENCE1);break; //01001
        case 0x2801:StartShowEleInfo(TTERMINALCUT_LOWVO_VOLTAGE,TTERMINALCUT_LOWVO_VOLTAGE_INTERFERENCE2);break;//10001
        case 0x4801:StartShowEleInfo(TTERMINALCUT_LOWVO_VOLTAGE,TTERMINALCUT_LOWVO_VOLTAGE_INTERFERENCE3);break;//100001
        case 0x8801:StartShowEleInfo(TTERMINALCUT_LOWVO_VOLTAGE,TTERMINALCUT_LOWVO_VOLTAGE_INTERFERENCE4);break; //01001

        default :
            CString cs;
            cs.Format("开关没有按要求闭合 0x%x",eleticReleaseType&0xffff);
            MessageBox(cs);break;
    }
    Sleep(1);//LogPrint("123\n");

    //delete[] pBuf;LogPrint("1233\n");
    //pBuf = NULL;//LogPrint("12333\n");
    return 0;
}
void CyiliaodemoDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
    if ((nID & 0xFFF0) == IDM_ABOUTBOX)
    {
        CAboutDlg dlgAbout;
        dlgAbout.DoModal();
    }
    else
    {
        CDialogEx::OnSysCommand(nID, lParam);
    }
}

// 如果向对话框添加最小化按钮，则需要下面的代码
//  来绘制该图标。对于使用文档/视图模型的 MFC 应用程序，
//  这将由框架自动完成。

void CyiliaodemoDlg::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);
        drawPic(&dc);
    }
    else
    {
        CPaintDC dc(this); // 用于绘制的设备上下文
        OnDraw(&dc); //调用了OnDraw
        drawPic(&dc);
        CDialogEx::OnPaint();
    }
}

//当用户拖动最小化窗口时系统调用此函数取得光标
//显示。
HCURSOR CyiliaodemoDlg::OnQueryDragIcon()
{
    return static_cast<HCURSOR>(m_hIcon);
}
void CyiliaodemoDlg::OnBtnCardIn()
{    
    ASSERT(m_pSerial != NULL);
    if(m_pSerial == NULL)
    {
        MessageBox("device not open!");
        return;
    }
    isStartTiming =true;
    isComBusy = false;
    Current=0;
    iIndex = 0x20000;
    SetDlgItemText(IDC_LBLCARDIN,"请等待");
    list_cmd.AddTail(szCardIn);//m_pSerial->WriteSyncPort(szCardIn,9);
}
void CyiliaodemoDlg::OnBtnCardOut()
{
    if(m_pSerial == NULL)
    {
        MessageBox("device not open!");
        return;
    }
    isStartTiming =true;
    isComBusy = false;
    Current=0;
    iIndex = 0x20001;
    SetDlgItemText(IDC_LBLCARDOUT,"请等待");
    list_cmd.AddTail(szCardOut);//m_pSerial->WriteSyncPort(szCardOut,9);
}
void CyiliaodemoDlg::OnBtnReadTmp()
{
    if(m_pSerial == NULL)
    {
        MessageBox("device not open!");
        return;
    }
    isStartTiming =true;
    Current=0;
    iIndex = 0x20002;
    SetDlgItemText(IDC_LBLREADTEMP,"请等待");
    list_cmd.AddTail(szTemp);//m_pSerial->WriteSyncPort(szTemp,9);
}
void CyiliaodemoDlg::OnBtnReadCode()
{
    if(m_pSerial == NULL)
    {
        MessageBox("device not open!");
        return;
    }
    isStartTiming =true;
    Current=0;
    iIndex = 0x10001;
    SetDlgItemText(IDC_LBLREAGENTCARDCODE,"请等待");
    list_cmd.AddTail(szStartTest);
    list_cmd.AddTail(szReadLBarCode);
}
void CyiliaodemoDlg::OnBtnReadIDCode()
{
    if(m_pSerial == NULL)
    {
        MessageBox("device not open!");
        return;
    }
    isStartTiming =true;
    Current=0;
    iIndex = 0x3000F;
    SetDlgItemText(IDC_LBLREADIDCODE,"请等待");
    list_cmd.AddTail(szIsCardExit);
    //Sleep(1000);
    list_cmd.AddTail(szReadSBarCode);
}
void CyiliaodemoDlg::OnBtnReadIDData()
{
    if(m_pSerial == NULL)
    {
        MessageBox("device not open!");
        return;
    }
    isStartTiming =true;
    Current=0;
    iIndex = 0x10000F2;
    SetDlgItemText(IDC_LBLITEM,"请等待");
    SetDlgItemText(IDC_LBLUINT,"请等待");
    SetDlgItemText(IDC_LBLITEM2,"请等待");
    SetDlgItemText(IDC_LBLIDCODE2,"请等待");
    SetDlgItemText(IDC_LBLBATCHNMB,"请等待");
    list_cmd.AddTail(szReadIDExtendData1);
}
void CyiliaodemoDlg::OnBtnPretest()
{
    if(m_pSerial == NULL)
    {
        MessageBox("device not open!");
        return;
    }
    DWORD threadID;
    isStartTiming =true;
    Current=0;
    iIndex = 0x10002;
    //SetDlgItemText(IDC_LBLPRETEST,"请等待");
    list_cmd.AddTail(szPreTestData);
    //WriteCmdTimeout = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)UserTimeoutThread,  this,  0, &threadID);
    //list_cmd.AddTail(szPreTestData);
}
void CyiliaodemoDlg::OnBtnReadData()
{
    if(m_pSerial == NULL)
    {
        MessageBox("device not open!");
        return;
    }
    DWORD threadID;
    isStartTiming =true;
    Current=0;
    iIndex = 0x10003;
    SetDlgItemText(IDC_LBLREADDATARESULT,"请等待");
    list_cmd.AddTail(szStartTestData);
    //WriteCmdTimeout = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)UserTimeoutThread,  this,  0, &threadID);
    //list_cmd.AddTail(szPreTestData);
}
void CyiliaodemoDlg::OnBtnOpenCurve()
{//list_cmd.AddTail(szStartTestData);
    CmyDraw myDraw;
    myDraw.DoModal();
}
int iStatus=0;
int iAddTemp=0;
void CyiliaodemoDlg::OnTimer(UINT_PTR nIDEvent)
{
    CString cs;

    cs.Format("已加载 百分之%d",m_add*100/m_XlsLength);
    iStatus++;
    if (m_add<m_XlsLength&&(!isPause))
    {
        m_Oldadd = m_add;
        m_add+=1;

        //if(m_sleep>=100)m_add+=1;
        //if(m_XlsLength>=(m_add+1000/m_sleep))m_add+=1000/m_sleep;
        //else m_add =m_XlsLength;
        m_Statusbar.SetPaneText(2,cs);
    }
    else if (m_add==m_XlsLength&&!isAdd) {
        isAdd = true;
        SetDlgItemText(IDC_BUTTON1,"开始");
        cs.Format("加载完成");
        m_Statusbar.SetPaneText(2,cs);KillTimer(1);
    }
    //OnPaint();
    CClientDC dc(this); 
    OnDraw(&dc); //调用了OnDraw
    //drawPic(&dc);
    CDialog::OnTimer(nIDEvent);
}

void CyiliaodemoDlg::drawPic(CPaintDC *pDc)
{
    if(!m_strFilePath.IsEmpty()) 
        {
            int height, width;
            CRect rect;//定义矩形类
            CRect rect1;
            CImage image; //创建图片类
            image.Load(m_strFilePath);
            height = image.GetHeight();
            width = image.GetWidth();

            CWnd *pWnd=GetDlgItem(IDC_PICTURE);//获得pictrue控件窗口的句柄

            pWnd->GetClientRect(&rect);//获得pictrue控件所在的矩形区域

            //m_PictureControl.GetClientRect(&rect); //获得pictrue控件所在的矩形区域
            CDC *pDc=pWnd->GetDC();//获得pictrue控件的DC
            //CDC *pDc = m_PictureControl.GetDC();//获得pictrue控件的Dc
            SetStretchBltMode(pDc->m_hDC,STRETCH_HALFTONE);

            float xScale=(float)rect.Width()/(float)width;
            float yScale=(float)rect.Height()/(float)height;
            float ScaleIndex=((xScale>=yScale)?xScale:yScale);
            rect1 = CRect(rect.TopLeft(), CSize((int)width*xScale,(int)height*yScale));
            image.StretchBlt(pDc->m_hDC,rect1,SRCCOPY); //将图片画到Picture控件表示的矩形区域

            //image.StretchBlt(pDC->m_hDC,0,0,rect.Width(),rect.Height(),0,0,bmpInfo.biWidth,bmpInfo.biHeight,pBmpData,pBmpInfo,DIB_RGB_COLORS,SRCCOPY);
        
            ReleaseDC(pDc);//释放picture控件的Dc
        }
}
/*
void CyiliaodemoDlg::OnPaint()
{
    CPaintDC dc(this); // device context for painting
    // TODO: 在此处添加消息处理程序代码
    // 不为绘图消息调用 CDialogEx::OnPaint()    
    //CDC* pDc = GetDC();
    //MoveWindow(100,100,800,600);
    //dc.DrawText("时间时",CRect(0,0,160,200),DT_WORDBREAK);
    OnDraw(&dc); //调用了OnDraw
    drawPic(&dc);
}*/

//绘制弧线
void CyiliaodemoDlg::DrawArc(CDC *pDC)
{
    CRect rect(150,400,220,460);
    CPoint ptStart(170,440);
    CPoint ptEnd(210,400);
    CPen m_pen[2];
    m_pen[0].CreatePen(PS_SOLID, 1, RGB(255, 0, 0)); 
    CPen *oldPen=pDC->SelectObject(&m_pen[0]);

    rect.OffsetRect(80,0);
    ptStart+=CPoint(100,300);
    ptEnd+=CPoint(280,300);
    pDC->SelectObject(&m_pen[0]);
    pDC->Arc(&rect,ptStart,ptEnd);
    pDC->SelectObject(oldPen);
}

void CyiliaodemoDlg::updateRect()
{
    RECT rect;
    rect.bottom = m_SrcY+m_YWidth+40;//740;
    rect.left = m_SrcX-60;
    rect.right = m_SrcX+m_XWidth+60;
    rect.top = m_SrcY-20;
    InvalidateRect(&rect);
    UpdateWindow();
}
void CyiliaodemoDlg::OnDraw(CDC* pDC)
{
    int nYScale = 20;
    int iYScaleInit = 10000;
    int iYPerScaleValue = 2000;
    
    int nXScale = 8;
    int iXScaleInit = 360;
    int iXPerScaleValue = 90;

    int x=m_SrcX;
    int y=m_SrcY;
    int x1=100;
    int y1=100;
    char buff[5]="\0";
    DWORD i=0;
    CString cs;
    LPRECT rect;
    CPen cpen,pen,pen2;
    char  pBufOut[20000] = "\0";// = NULL;
    SetBkMode(*pDC, TRANSPARENT);

    g_clsMutex.Lock();
    pen2.CreatePen(PS_SOLID,2,RGB(0,0,0));
    cpen.CreatePen(PS_SOLID,1,RGB(0,0,0));
    
    pDC->SelectObject(&pen2);
    Hex2Str(580*4,(unsigned char *)StrBuff,pBufOut);
     
    double radian1=10;
    double radian = 60;
    int x2,y2;
    /*
        int x2;  
        radian = m_SrcX / ((double)60 * 2)*3.14;
        y2 = m_SrcY+m_YWidth/4+sin(radian) * 2 * 60;
        pDC->MoveTo(m_SrcX, m_SrcY+m_YWidth/4);
        pDC->LineTo((int)m_SrcX, (int)y2);
        //pDC->Ellipse(m_SrcX,m_SrcY+m_YWidth/2,m_SrcX+5,y2+5);
        */
    /*y2 = m_SrcY+m_YWidth/2;
    pDC->MoveTo(m_SrcX, y2);double y3=90;
    for (int x = m_SrcX; x < m_SrcX+10; x++)
    {
        //弧度=x坐标/曲线宽度*角系数*∏
        //y坐标=振幅*曲线宽度*sin(弧度）
         //radian = x / ((double)60 * 2)*3.14;
        //y2 = m_SrcY+m_YWidth/2-sin(radian) * 2 * 60;
        
        y2 += sin(y3) * m_SrcX;
        //y2 = m_SrcY+m_YWidth/2-radian;
        
        pDC->LineTo((int)x, (int)y2);y3--;
    }
    // pDC->MoveTo(m_SrcX,m_SrcY+m_YWidth/4);
    for(int x=m_SrcX;x<m_SrcX+360;x++)
    {
       //弧度=X坐标/曲线宽度*角系数*π
       //Y坐标=振幅*曲线宽度*sin(弧度)
       radian =x/((double)60*2)*3.14;
       y2=m_SrcY+m_YWidth/4+sin(radian)*2*60;
       pDC->MoveTo((int)x,(int)y2);
       pDC->LineTo((int)x,(int)y2);
    }*/
    for(int x=0;x<m_XWidth;x++)
    {
        radian=m_SrcX+x*m_XWidth/m_XWidth;
        y2=m_SrcY+m_YWidth/2-m_YWidth/4*sin(2*3.14*x/m_XWidth);
        pDC->MoveTo((int)radian,(int)y2);
       pDC->LineTo((int)radian,(int)y2);
    }
    //LPCRECT lpRect;POINT ptStart; POINT ptEnd;

    //lpRect->bottom=m_SrcX;
    //lpRect->left=m_SrcX;
    //lpRect->right=m_SrcX;
    //lpRect->top=m_SrcX;
    //pDC->Arc(100,100,200,200,300,300,400,400);
    // pDC->Arc(m_SrcX,m_YWidth+m_YWidth/2,m_SrcX,m_YWidth+m_YWidth/2+m_YWidth/2,m_SrcX+180,m_YWidth+m_YWidth/2+m_YWidth/2,m_SrcX,m_YWidth+m_YWidth/2);
    pDC->SelectObject(&cpen);
    pDC->MoveTo(m_SrcX,m_SrcY);//y轴终点
    pDC->LineTo(m_SrcX,m_SrcY+m_YWidth);//中心点
    pDC->LineTo(m_SrcX+m_XWidth,m_SrcY+m_YWidth);//x轴终点
    pDC->LineTo(m_SrcX+m_XWidth,m_SrcY);//中心点
    pDC->LineTo(m_SrcX,y);//x轴终点
    for(i=0;i<=m_XWidth;)//画x轴刻度数值
    {
        pDC->MoveTo(i+x,y+m_YWidth);
        if(i%(m_XWidth/m_XDivide)==0) pDC->LineTo(i+x,y+m_YWidth+10);
        else pDC->LineTo(i+x,y+m_YWidth+5);
        cs.Format("%d",i*m_VirtualXWidth/m_XWidth);
        if(i%(m_XWidth/m_XDivide)==0)pDC->TextOut(i+x-10, y+m_YWidth+20,  cs);
        i+=m_XWidth/m_XDivide;
    }
    for(i=0;i<=m_XWidth;)//画x轴刻度数值
    {
        pDC->MoveTo(i+m_SrcX,y);
        if(i%(m_XWidth/m_XDivide)==0) pDC->LineTo(i+x,y+10);
        else pDC->LineTo(i+x,y+5);
        i+=(m_XWidth/m_XDivide);
    }
    ///pDC->TextOut(i+x, y+350+10,  "");
    for(i=0;i<=m_VirtualYWidth;)//画y轴刻度数值
    { 
        pDC->MoveTo(x, y+m_YWidth-i/(m_VirtualYWidth/m_YWidth));
        if(i%(m_VirtualYWidth/m_YDivide*2)==0) pDC->LineTo(x-10, y+m_YWidth-i/(m_VirtualYWidth/m_YWidth));
        else pDC->LineTo(x-5, y+m_YWidth-i/(m_VirtualYWidth/m_YWidth));
        cs.Format("%d",i-m_VirtualYWidth/2);
        if(i%(m_VirtualYWidth/m_YDivide*2)==0)pDC->TextOut(x-60, y+m_YWidth-i/(m_VirtualYWidth/m_YWidth)-10,  cs);
        i+=m_VirtualYWidth/m_YDivide;
    }
    for(i=0;i<=m_VirtualYWidth;)//画y轴刻度数值
    {
        pDC->MoveTo(x+m_XWidth, y+m_YWidth-i/(m_VirtualYWidth/m_YWidth));
        if(i%(m_VirtualYWidth/m_YDivide*2)==0) pDC->LineTo(x+m_XWidth-10, y+m_YWidth-i/(m_VirtualYWidth/m_YWidth));
        else pDC->LineTo(x+m_XWidth-5, y+m_YWidth-i/(m_VirtualYWidth/m_YWidth));
        i+=m_VirtualYWidth/m_YDivide;
    }
    /*0 坐标是100，450*/ // 画数据轨迹
    pen.CreatePen(PS_SOLID,3,RGB(31,22,107)); 
    pDC->SelectObject(&pen);
    for(i=m_Oldadd;i<m_add;)
    {    
        x1 = stu_DataPos[i].x*m_XWidth/m_VirtualXWidth+m_SrcX;//转换成实际坐标
        y1 = (m_SrcY+m_YWidth/2)-stu_DataPos[i].y*m_YWidth/m_VirtualYWidth;//转换成实际坐标
        if((x1<=(m_XWidth+m_SrcX))&&(y1<=(m_YWidth+m_SrcY)\
            )&&(x1>=m_SrcX)&&(y1>=m_SrcY)) pDC->Ellipse(x1,y1,x1+1,y1+1);
        i+=1;
    }

    //MessageBox(cs);
    //DrawArc(pDC);
    cpen.DeleteObject();
    pen.DeleteObject();
    
    g_clsMutex.Unlock();
}

void CyiliaodemoDlg::OnLButtonDown(UINT nFlags, CPoint point)
{
    // TODO: 在此添加消息处理程序代码和/或调用默认值
    g_clsMutex.Lock();

    CString cs;//转换成虚拟坐标
    cs.Format("%d,%d",(point.x-m_SrcX)*m_VirtualXWidth/m_XWidth,-(point.y-(m_YWidth/2+m_SrcY))*m_VirtualYWidth/m_YWidth);
    m_Statusbar.SetPaneText(1,cs);
    CDialogEx::OnLButtonDown(nFlags, point);

    g_clsMutex.Unlock();
}

void CyiliaodemoDlg::OnBnClickedButton1()
{
    // TODO: 在此添加控件通知处理程序代码
    char temp[200]="\0";
    bool bLoadXlsFile = false;
    //BYTE  sendbuf[10]={0x55,0x12,0x12,0x12,0x12,0x12,0x12,0x13};
    BYTE  sendbuf[10]={0x55,0xd,0xa};

    GetDlgItemText(IDC_BUTTON1,temp,10);

    isPause=false;

    if(m_pSerial==NULL)
    {
        MessageBox("串口未打开");
        return;
    }
    UpdateXYWidth();
    if ((m_VirtualXWidth % 180 != 0) || (m_VirtualYWidth % 180 != 0))
    {
        MessageBox("输入X、Y参数不合法");
        return;
    }

    if(strcmp(temp,"开始")==0){
    SetDlgItemText(IDC_BUTTON1,"停止");ClearScreen();m_pSerial->WriteSyncPort(sendbuf,3);iAddTemp = 0;}
    if(strcmp(temp,"停止")==0){
        SetDlgItemText(IDC_BUTTON1,"开始");
        SetDlgItemText(IDC_PAUSE,"暂停");KillTimer(1);
        CString cs;
        cs.Format("停止");
        m_Statusbar.SetPaneText(2,cs);
        return;
    }
    
}
void CyiliaodemoDlg::StartShowEleInfo(int iBlemishType,int iBlemishDisturbType)
{
    char temp[200]="\0";
    int i;
    bool bLoadXlsFile = false;
    
    m_add = 1;
    CString cs;
    memset(temp,0,200);

    UpdateXYWidth();
    
    bLoadXlsFile = Loading(szDischargeData[(iBlemishDisturbType-1)*2+1],szDischargeData[(iBlemishDisturbType-1)*2]);
    if(!bLoadXlsFile) return;

    //获取文件名称
    for(i=(strlen(szDischargeData[(iBlemishDisturbType-1)*2])-1);i>0;i--)
    {
        if(szDischargeData[(iBlemishDisturbType-1)*2][i] =='\\')  break;    
    }
    if(i!=0) 
        memcpy(temp,szDischargeData[(iBlemishDisturbType-1)*2]+i+1,strlen(szDischargeData[(iBlemishDisturbType-1)*2])-i-1-4);
        
    cs.Format("%s",temp);
    SetDlgItemText(IDC_SHOWTYPE,cs);
    
    isAdd = false;

    updateRect(); 

    showBlemishData((iBlemishType-1)/3);

    m_Eigenvalues = iBlemishDisturbType-1;

    memset(temp,0,200);

    GetDlgItemText(IDC_TIME,temp,10);
    int iTime = atoi(temp);
    m_sleep = iTime;
    
    SetTimer(1,iTime,NULL); 
}
void CyiliaodemoDlg::OnBnClickedButton2()
{
    // TODO: 在此添加控件通知处理程序代码
}

void CyiliaodemoDlg::OnBnClickedPause()
{
    // TODO: 在此添加控件通知处理程序代码
    char temp[200]="\0";
    GetDlgItemText(IDC_PAUSE,temp,10);
    if (strcmp(temp,"暂停")==0){
        SetDlgItemText(IDC_PAUSE,"继续");
        isPause = true;
        CString cs;
        cs.Format("暂停");
        m_Statusbar.SetPaneText(2,cs);
    }
    if(strcmp(temp,"继续")==0){
    SetDlgItemText(IDC_PAUSE,"暂停");isPause=false;}
}

void CyiliaodemoDlg::OnBnClickedStop()
{
    // TODO: 在此添加控件通知处理程序代码
}
void CyiliaodemoDlg::showBlemishData(int type)
{
    SetDlgItemText(IDC_SHOWBlemish,szBlemishData[type]);
}

HBRUSH CyiliaodemoDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{HBRUSH hbr = CDialogEx::OnCtlColor(pDC, pWnd, nCtlColor);
 
    if (nCtlColor == CTLCOLOR_DLG)
    {
        return m_brush;
    }
 
    if (nCtlColor == CTLCOLOR_STATIC)
    {
        pDC->SetTextColor(RGB(0, 0, 0));
        pDC->SetBkColor(RGB(155, 170, 190));
        hbr = (HBRUSH)m_brush;
    }
 
    // TODO:  在此更改 DC 的任何特性
    if (nCtlColor == CTLCOLOR_EDIT &&
        pWnd->GetDlgCtrlID() == IDD_YILIAODEMO_DIALOG)//注意此处的（pWnd->），否则没效果
    {
        pDC->SetTextColor(RGB(255, 0, 0));
        //pDC->SetBkColor(RGB(155, 170, 190));//设置文本背景色
        pDC->SetBkMode(TRANSPARENT);//设置背景透明
        hbr = (HBRUSH)m_brush;
    }
    // TODO:  如果默认的不是所需画笔，则返回另一个画笔

    // TODO:  如果默认的不是所需画笔，则返回另一个画笔
    return hbr;
}

void CyiliaodemoDlg::OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct)
{
    // TODO: 在此添加消息处理程序代码和/或调用默认值
    CDC dc;
    dc.Attach(lpDrawItemStruct->hDC);
    ASSERT(lpDrawItemStruct->CtlType == ODT_BUTTON);

    CString strText;
    ((CButton *)GetDlgItem(nIDCtl))->GetWindowText(strText);

    SetBkMode(lpDrawItemStruct->hDC, TRANSPARENT);

    CBrush brush(RGB(255, 0, 0));
    dc.FillRect(&(lpDrawItemStruct->rcItem), &brush);
    DrawText(lpDrawItemStruct->hDC, strText, strText.GetLength(),
    &lpDrawItemStruct->rcItem, DT_SINGLELINE | DT_VCENTER | DT_CENTER);
    SetBkMode(lpDrawItemStruct->hDC, TRANSPARENT);
    
    dc.Detach();
}
bool CyiliaodemoDlg::GetAnalysiseigenvaluesXLSX(char *strXlsPth)
{
    Book* book = xlCreateXMLBook();
    CString cs;
    const char * x = "Halil Kural";
    const char * y = "windows-2723210a07c4e90162b26966a8jcdboe";
    book->setKey(x, y);
    if (book)
    {
        if (book->load(strXlsPth))
        {
                for (int i = 0; i < book->sheetCount(); ++i)
                {
                    Sheet* sheet = book->getSheet(i);
                    if (!sheet)
                        break;
                    int rowNum = sheet->lastRow();
                    int colNum = sheet->lastCol();
                    m_XlsLength = rowNum;//*colNum;
                    CString cs1;
                    for (int j = 1; j < rowNum; ++j)
                    {
                        //for (int k = 0; k < colNum; ++k)
                        {
                            //std::cout << sheet->readNum(j, k) << ",";
                            //strXlsData[j*colNum+k] = sheet->readNum(j, k);
                            stu_EigenValuesDataPos[j].Average = sheet->readNum(j, 0);
                            stu_EigenValuesDataPos[j].max = sheet->readNum(j, 1);
                            stu_EigenValuesDataPos[j].frequence = sheet->readNum(j, 2);
                            //cs1.Format("%d %d",j*colNum,stu_EigenValuesDataPos[j*colNum].frequence);
                            //MessageBox(cs1);
                        }
                        //std::cout << std::endl;
                    }
            //std::cout << "book->sheetCount()" << rowNum << std::endl;
                }
                
        } else {
                cs.Format("打开特征值表格失败 %s",strXlsPth);
                MessageBox(cs);
                return false;
            //std::cout << "At first run generate !" << std::endl;
        }
    } else {
        return false;
    }
    return true;
}
//分析特征值
void CyiliaodemoDlg::OnBnClickedAnalysiseigenvalues()
{    
    bool bReturn = GetAnalysiseigenvaluesXLSX(szAnalysisEIGENVALUES[m_Eigenvalues]);
    CString cs;
    // TODO: 在此添加控件通知处理程序代码
    if(bReturn) {
        cs.Format("%.7f",stu_EigenValuesDataPos[1].Average);
        SetDlgItemText(IDC_Average,cs);

        cs.Format("%.7f",stu_EigenValuesDataPos[1].max);
        SetDlgItemText(IDC_max,cs);
        
        cs.Format("%.0f",stu_EigenValuesDataPos[1].frequence);
        SetDlgItemText(IDC_frequence,cs);
    }
}
void CyiliaodemoDlg::ClearScreen()
{
    SetDlgItemText(IDC_Average,"");
    SetDlgItemText(IDC_max,"");
    SetDlgItemText(IDC_frequence,"");
    SetDlgItemText(IDC_SHOWTYPE,"");
    SetDlgItemText(IDC_SHOWBlemish,"");
    SetDlgItemText(IDC_PICTURE,"");
    updateRect();
}

void CyiliaodemoDlg::OnSize(UINT nType, int cx, int cy)
{
    CDialogEx::OnSize(nType, cx, cy);
    int differ[2];
    int i;
    //MessageBox("1");
    CRect rect,rect1;
    GetWindowRect(rect);ScreenToClient(rect);
    differ[0]=rect.Width()-oldRect[10].Width();;
    differ[1]=rect.Height()-oldRect[10].Height();

    if (differ[0]<=0||differ[1]<=0)
    {
        GetDlgItem(IDC_STATICELEPIC)->MoveWindow(oldRect[0]);
        for(i=0;i<10;i++)
        {
            newRect[i].left=oldRect[i].left;
            newRect[i].top=oldRect[i].top;
            newRect[i].right=oldRect[i].right+differ[0];
            newRect[i].bottom=oldRect[i].bottom+differ[1];
            GetDlgItem(widget[i])->MoveWindow(newRect[i]);
        }
        
        m_Statusbar.SetPaneInfo(0,ID_STAUTSCOM,SBPS_STRETCH, rect.Width()/3);
        m_Statusbar.SetPaneInfo(1,ID_STAUTSXY,SBPS_NORMAL ,rect.Width()/3);
        m_Statusbar.SetPaneInfo(2,ID_STAUTSINFO,SBPS_NORMAL, rect.Width()/3);
            
        RepositionBars(AFX_IDW_CONTROLBAR_FIRST,
        AFX_IDW_CONTROLBAR_LAST,0);
        
        m_XWidth = (oldRect[0].Width()-10)/360*360;//360;
        m_YWidth = (oldRect[0].Height()-20)/360*360;//360;

        m_SrcX = oldRect[0].left + (oldRect[0].Width()-m_XWidth)/2+5;
        m_SrcY = oldRect[0].top  + (oldRect[0].Height()-m_YWidth)/2;

        UpdateXYWidth();
        RedrawWindow(oldRect[1]);
        return;
    }
    CString cs;
//    m_Statusbar.GetWindowRect(rect1);
    m_Statusbar.SetPaneInfo(0,ID_STAUTSCOM,SBPS_STRETCH, rect.Width()/3);
    m_Statusbar.SetPaneInfo(1,ID_STAUTSXY,SBPS_NORMAL ,rect.Width()/3);
    m_Statusbar.SetPaneInfo(2,ID_STAUTSINFO,SBPS_NORMAL, rect.Width()/3);
            
    RepositionBars(AFX_IDW_CONTROLBAR_FIRST,
        AFX_IDW_CONTROLBAR_LAST,0);

    //m_Statusbar.MoveWindow(rect1.left,rect1.top+differ[1],rect1.Width()+differ[0],rect1.Height());
        // TODO: 在此处添加消息处理程序代码
    //显示点组合框
    for(i=0;i<1;i++)
    {
        newRect[i].left=oldRect[i].left;
        newRect[i].top=oldRect[i].top;
        newRect[i].right=oldRect[i].right+differ[0];
        newRect[i].bottom=oldRect[i].bottom+differ[1];
        GetDlgItem(widget[i])->MoveWindow(newRect[i]);
    }
    //cs.Format("%d %d",newRect[0].Width(),newRect[0].Height());
    //MessageBox(cs);
    //显示图片
    newRect[1].left=oldRect[1].left;
    newRect[1].top=oldRect[1].top;
    newRect[1].right=oldRect[1].right;
    newRect[1].bottom=oldRect[1].bottom+differ[1];
    GetDlgItem(widget[1])->MoveWindow(newRect[1]);

    newRect[2].left=oldRect[2].left+differ[0];
    newRect[2].top=oldRect[2].top+differ[1];
    newRect[2].right=oldRect[2].right+differ[0];
    newRect[2].bottom=oldRect[2].bottom+differ[1];
    GetDlgItem(widget[2])->MoveWindow(newRect[2]);

    newRect[3].left=oldRect[3].left;
    newRect[3].top=oldRect[3].top+differ[1];
    newRect[3].right=oldRect[3].right+differ[0];
    newRect[3].bottom=oldRect[3].bottom+differ[1];
    GetDlgItem(widget[3])->MoveWindow(newRect[3]);

    newRect[4].left=oldRect[4].left;
    newRect[4].top=oldRect[4].top+differ[1];
    newRect[4].right=oldRect[4].right;
    newRect[4].bottom=oldRect[4].bottom+differ[1];
    GetDlgItem(widget[4])->MoveWindow(newRect[4]);

    for(i=1;i<6;i++)
    {
        newRect[i+4].left=oldRect[i+4].left;//+differ[0]/5*i;
        newRect[i+4].top=oldRect[i+4].top+differ[1];
        newRect[i+4].right=oldRect[i+4].right;//+differ[0]/5*i;
        newRect[i+4].bottom=oldRect[i+4].bottom+differ[1];
        GetDlgItem(widget[i+4])->MoveWindow(newRect[i+4]);
    }    

    m_XWidth = (newRect[0].Width()-10)/360*360;//360;
    m_YWidth = (newRect[0].Height()-100)/360*360;//360;

    m_SrcX = newRect[0].left + (newRect[0].Width()-m_XWidth)/2+5;
    m_SrcY = newRect[0].top  + (newRect[0].Height()-m_YWidth)/2;

    UpdateXYWidth();
    /*GetDlgItem(IDC_PICTURE)->GetWindowRect(&oldRect[1]);;
    GetDlgItem(IDC_STATICFUHAO)->GetWindowRect(&oldRect[2]);
    GetDlgItem(IDC_STATICTEZZ)->GetWindowRect(&oldRect[3]);
    GetDlgItem(IDC_STATICfdl1)->GetWindowRect(&oldRect[4]);
    GetDlgItem(IDC_Average)->GetWindowRect(&oldRect[5]);
    GetDlgItem(IDC_STATICfdl)->GetWindowRect(&oldRect[6]);
    GetDlgItem(IDC_max)->GetWindowRect(&oldRect[7]);
    GetDlgItem(IDC_STATICfdpl)->GetWindowRect(&oldRect[8]);
    GetDlgItem(IDC_frequence)->GetWindowRect(&oldRect[9]);*/
    RedrawWindow(newRect[1]);
}