// 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]);

}

 

     WAV文件格式
波形音频文件（*.WAV）是Microsoft为Windows设计的多媒体文件格式RIFF(The Resource Interchange File Format,资源交换文件格式)中的一种（另一种常用的为AVI）。RIFF由文件头、数据类型标识及若干块(chunk)组成。
 
WAV文件的基本格式


类型


内容


变量名


大小


取值

RIFF头
文件标识符串
fileId
4B
“RIFF”
头后文件长度
fileLen
4B
非负整数(=文件长度－8)
数据类型标识符
波形文件标识符
waveId
4B
“WAVE”
格式块
块头
格式块标识符串
chkId
4B

“fmt ”

头后块长度
chkLen
4B
非负整数(= 16或18)
块数据
格式标记
wFormatTag
2B
非负短整数(PCM=1)
声道数
wChannels
2B
非负短整数(= 1或2)
采样率
dwSampleRate
4B
非负整数(单声道采样数/秒)
平均字节率
dwAvgBytesRate
4B
非负整数(字节数/秒)
数据块对齐
wBlockAlign
2B
非负短整数(不足补零)
采样位数
wBitsPerSample
2B
非负短整数(PCM时才有)
扩展域大小
wExtSize
2B
非负短整数
可选(根据chkLen=16or 18判断)
扩展域
extraInfo

extSize B

扩展信息
数据块
块头
数据块标识符串
chkId
4B

“data”

头后块长度
chkLen
4B
非负整数
块数据
波形采样数据
x或xl、xr

chkLen B


左右声道样本交叉排列
样本值为整数(整字节存储，不足位补零)，
整个数据块按blockAlign对齐


 
注意：
       wFormatTag = 1时为无压缩的PCM（Pulse Code Modulation, 脉冲编码调制）标准格式（即等间隔采样、线性量化）。
      单字节样本值v为无符号整数(0~255)，实际样本值应为v-128；多字节样本值本身就是有符号的，可直接使用。
有些wav文件在data块之前,fmt块之后还有一个fact块..
|  ID    |  4 Bytes |   'fact'          |

        ----------------------------------

      | Size  |  4 Bytes |   数值为4    |

       ----------------------------------

      | data  |  4 Bytes |  ?? ?? ?? ??  | 
因此要根据读到的ID进行判断
参考: http://www.snowcn.net/?action/viewspace/itemid/260.html  wav文件格式分析详解


Wav文件 所有数值表示均为低字节表示低位，高字节表示高位。
通过CArchive的>>读入, 会自动转化(把高字节的作为高位)
如读入地址为0000000的双字(DWORD)到变量dw中 :
0000000: 52 49 46 46 
则dw会等于0x46464952
 

为了简化RIFF文件中的4字符标识的读写与比较，Windows SDK在多媒体头文件mmsystem.h中定义了类型

FOURCC（Four-Character Code四字符代码）：
typedef DWORD FOURCC;
及其构造宏（用于将4个字符转换成一个FOURCC数据）
FOURCC mmioFOURCC(CHAR ch0, CHAR ch1, CHAR ch2, CHAR ch3);
其定义为MAKEFOURCC宏：
#define  mmioFOURCC(ch0, ch1, ch2, ch3)  MAKEFOURCC(ch0, ch1, ch2, ch3);
而MAKEFOURCC宏定义为：
#define MAKEFOURCC(ch0, ch1, ch2, ch3)  /
    ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |  /
    ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ));
例如：
#include <mmsystem.h>
#define ID_RIFF    mmioFOURCC('R', 'I', 'F', 'F')
#define ID_WAVE   mmioFOURCC('W', 'A', 'V', 'E')
……
FOURCC id;
……
              ar >> id;
              if (id != ID_RIFF) {
       ……
}
……
l         播放波形声音文件
函数PlaySound可以播放系统声音、声音资源和声音文件，其函数原型为：
BOOL PlaySound(
  LPCSTR pszSound, 
  HMODULE hmod,    
  DWORD fdwSound
);
例如：
PlaySound(“c://sounds//sample.wav”, NULL, SND_ASYNC);
              PlaySound(ar.GetFile()->GetFilePath(), NULL, SND_ASYNC);

 
下面是完整步骤:
新建MFC应用程序, 单文挡(SDI)项目WavePlayer.
为了使包含PlaySound的程序能够编译通过，必须包含多媒体头文件： #include <mmsystem.h>, 而且需要注意头文件包含的次序.. 否则会提示找不到标识符..
并在项目中添加多媒体库：在项目区中任何页中选中顶部的项目名，选“项目/属性”菜单项或按Alt+F7组合键，弹出“[项目名]属性页”对话框，在该其左上角的“配置”栏的下拉式列表中，选择“所有配置”项，在其左边的“配置”目录栏中，选中“配置属性/链接器/输入”项，在右边顶行的“附加依赖项”栏中键入winmm.lib，按“确定”钮关闭对话框。
 
文件过滤
可通过修改资源视图页的“项目名/项目名.rc/String Table/String Table”串表资源中的ID：IDR_MAINFRAME(SDI)所对应的串，为应用程序的文件I/O对话框增加文件过滤器。为WavePlayer程序增加*.wav的过滤器：
将原来的串
IDR_MAINFRAME  “WavePlayer/n/nWavePlayer/n/n/nWavePlayer.Document/nWavePlayer.Document”
修改成
“WavePlayer/n/nWavePlayer/nWave Files (*.wav)/n.wav/nWavePlayer.Document/nWavePlayer.Document”
 
 
文档类cpp 添加如下宏
#define ID_RIFF mmioFOURCC('R', 'I', 'F', 'F')
#define ID_WAVE mmioFOURCC('W', 'A', 'V', 'E')
#define ID_data mmioFOURCC('d', 'a', 't', 'a')
#define ID_fmt  mmioFOURCC('f', 'm', 't',  '/x20')
#define ID_fact mmioFOURCC('f', 'a', 'c',  't')
 
 
文档类添加如下变量
public:
    int num;         // 样本数
    LONG* data;      // 样本数据
    LONG *Ldata, *Rdata;     // 双声道数据
    WORD BytesPerSample, wChannel;     // 一个样本的字节数,  声道数
 
Serialize函数添加如下代码:
if (ar.IsStoring())

    {

        // TODO: 在此添加存储代码

    }

    else

    {

        // TODO: 在此添加加载代码

        FOURCC id, chkLen,  dw;    // 无符号双字

        BYTE b;               // 无符号字节

        WORD w;              // unsined short  无符号单字长

        WORD fmtTag;           //格式标记

        WORD wBitsPerSample;   //样本位数

        FOURCC dwAvgBytesRate;  

        FOURCC Len;          // 数据块大小,  BYTE

        ar>>id;

        if(id!=ID_RIFF)  return;

        ar>>dw>>id;

        if(id!=ID_WAVE) return;

        ar>>id; if(id!=ID_fmt)  return;

        ar>>chkLen;            // 16或

        ar>>fmtTag;            // 只处理PCM(Pulse Code Modulation, 脉冲编码调制)情况

        if(fmtTag!=1)

            return;

        ar>>wChannel;           //声道数

        ar>>dw;                 //采样率

        ar>>dwAvgBytesRate;     //平均字节率

        ar>>w;                  //数据块对齐

        ar>>wBitsPerSample;     //样本位数

        if(chkLen==18)

        {

            ar>>w;               // 扩展域大小

            for(int i=0; i<w; i++)  // 读走扩展域的内容

                ar>>b;

        }

        ar>>id;            // data or fact

        if(id==ID_fact)

        {

            ar>>dw>>dw;        // 读走fact块内容

            ar>>id;    //      data  ID

        }

        if(id!=ID_data)

            return;

        ar>>Len;          

        BytesPerSample=wBitsPerSample/8;         // 一个样本的字节数

        num=Len/BytesPerSample;              // 样本数

        if(wChannel==1)                 // 单音道

        {

            data=new LONG[num];

            if(BytesPerSample==1)

                for(int i=0; i<num; i++)

                {

                    ar>>b;

                    data[i]=b-128;

                }

            else if(BytesPerSample==2)

                for(int i=0; i<num; i++)

                {

                    ar>>w;

                    data[i]= (SHORT)w;         // 无符号数转成有符号数

                }

            else if(BytesPerSample==4)

                for(int i=0; i<num; i++)

                {

                    ar>>dw;

                    data[i]=(LONG)w;          // 无符号数转成有符号数

                }

            else if(BytesPerSample==3)

                for(int i=0; i<num; i++)

                {

                    ar>>b>>w;

                    data[i]=w+b;

                }

        }

        else if(wChannel==2)             // 双音道

        {

            Ldata=new LONG[num/2];     // 左声道

            Rdata=new LONG[num/2];      // 右声道

            if(BytesPerSample==1)

            {

                for(int i=0; i<num/2; i++)  // 一个声道的样本数为num/2, 左右声道交替

                {

                    ar>>b;            

                    Ldata[i]=b-128;        

                    ar>>b;

                    Rdata[i]=b-128;

                }

            }

            else if(BytesPerSample==2)

                for(int i=0; i<num/2; i++)

                {

                    ar>>w;

                    Ldata[i]=(SHORT)w;         // 无符号数转成有符号数

                    ar>>w;

                    Rdata[i]=(SHORT)w;

                }

            else if(BytesPerSample==4)

                for(int i=0; i<num/2; i++)

                {

                    ar>>dw;

                    Ldata[i]=(LONG)dw;

                    ar>>dw;

                    Rdata[i]=(LONG)dw;

                }

            else if(BytesPerSample==3)

                for(int i=0; i<num/2; i++)

                {

                    ar>>b>>w;

                    Ldata[i]=w+b;

                    ar>>b>>w;

                    Rdata[i]=w+b;

                }

        }

        PlaySound(ar.GetFile()->GetFilePath(), NULL, SND_ASYNC);  // 播放声音

    }

 


 
视图类OnDraw函数添加如下代码:
CRect rect;                // 客户区大小

    GetClientRect(&rect);        

    CPen gpen(PS_SOLID, 1, RGB(0, 250, 0));          // 绿色笔

    pDC->SelectObject(&gpen);

    if(pDoc->data!=NULL || pDoc->Ldata!=NULL)        // 数据非空时才画

    {

        float A=pow(2.0, 8.0*pDoc->BytesPerSample-1);  // 将样本的高度映射到所需高度,

                                                       // 先算出样本的最大值

        if(pDoc->wChannel==1)                         // 单声道

        {  

            int x=0, y=rect.Height()/2;               

            while(x < rect.Width())         

            {

                int min=INT_MAX, max=INT_MAX+1;      // 让min初始为最大的int, 让max初始化最小的int

                // 一个象素x映射(样本数/客户区宽度)个样本点, 用其中最大最小值, 画一竖直的线段

                for(int j=x*pDoc->num/rect.Width(); j<(x+1)*pDoc->num/rect.Width(); j++)

                {

                    if(pDoc->data[j]<min)

                        min=pDoc->data[j];

                    if(pDoc->data[j]>max)

                        max=pDoc->data[j];

                }

                pDC->MoveTo(x, y+(max*rect.Height()/2.0/A));

                pDC->LineTo(x, y+(min*rect.Height()/2.0/A));

                x++;

            }

            CPen pen(PS_SOLID, 1, RGB(200, 0, 0));          // 客户区中间画一横线

            pDC->SelectObject(&pen);

            pDC->MoveTo(0, rect.Height()/2);

            pDC->LineTo(rect.Width(), rect.Height()/2);    

        }

        else if(pDoc->wChannel==2)

        {

            // 在客户区上半部分画左声道, 原理同单声道,

            int x=0, y=rect.Height()/4;

            while(x<rect.Width())

            {

                int min=INT_MAX, max=INT_MAX+1;

                for(int j=x*pDoc->num/2/rect.Width(); j<(x+1)*pDoc->num/2/rect.Width(); j++)

                {

                    if(pDoc->Ldata[j]<min)

                        min=pDoc->Ldata[j];

                    if(pDoc->Ldata[j]>max)

                        max=pDoc->Ldata[j];

                }

                pDC->MoveTo(x, y+(max*rect.Height()/4.0/A));

                pDC->LineTo(x, y+(min*rect.Height()/4.0/A));

                x++;

            }

            // 在客户区下半部分画右声道

            x=0, y=3*rect.Height()/4;

            while(x<rect.Width())

            {

                int min=INT_MAX, max=INT_MAX+1;

                for(int j=x*pDoc->num/2/rect.Width(); j<(x+1)*pDoc->num/2/rect.Width(); j++)

                {

                    if(pDoc->Rdata[j]<min)

                        min=pDoc->Rdata[j];

                    if(pDoc->Rdata[j]>max)

                        max=pDoc->Rdata[j];

                }

                gpen.DeleteObject();

                gpen.CreatePen(PS_SOLID, 1, RGB(255, 0, 0));

                pDC->SelectObject(&gpen);

                pDC->MoveTo(x, y+(max*rect.Height()/4.0/A));

                pDC->LineTo(x, y+(min*rect.Height()/4.0/A));

                x++;

            }

            // 画客户区中央横线

            CPen pen(PS_SOLID, 1, RGB(0, 0, 0));

            pDC->SelectObject(&pen);

            pDC->MoveTo(0, rect.Height()/2);

            pDC->LineTo(rect.Width(), rect.Height()/2);

 

           

            pen.DeleteObject();

            pen.CreatePen(PS_SOLID, 1, RGB(0, 0, 255));

            pDC->SelectObject(&pen);

            // 画左声道横线

            pDC->MoveTo(0, rect.Height()/4);

            pDC->LineTo(rect.Width(), rect.Height()/4);

            // 右声道横线

            pDC->MoveTo(0, 3*rect.Height()/4);

            pDC->LineTo(rect.Width(), 3*rect.Height()/4);

        }

    }

OnDraw用到了pow函数, 添加头文件包含指令
#include<cmath>      // double pow(double, double);

上半年写的一篇论文早在两个月前就已经收到录用通知，可前天上午突然收到编辑的邮件说文中的波形图坐标、标签、刻度太小，不符合要求，要我重画。当时想死的心都有了，那么多图，重新调参数仿真太耗时间了，最后只得PS、画图工具齐上阵，花了整整一个下午加晚上才把八幅大图，共48幅小图。这些耗时费力的重复工作本该在一开始就能杜绝，只因经验不足。今天花了一上午时间把matplotlib库中关于axes的用法仔细看了一遍，收获颇丰。我只能说当初还是太年轻了！
Axes是matplotlib中最常用到的API，像Subplot这样的类都是Axes的子类。

ax = plt.subplot(111)
# 获取x轴刻度线
ticklines = ax.xaxis.get_ticklines()
# 获取x轴刻度标签
ticklabels = ax.xaxis.get_ticklabels()



tickline有多种方法，如下所示：


set_markersize
设置刻度线大小
set_markeredgewidth
设置刻度线宽度
ticklabel常见方法如下所示：

set_rotation
设置旋转角度
set_fontsize
设置字体大小
set_visible
设置可见性
图片的边框通过 ax.spines 获取，得到一个dict，包含'bottom', 'top', 'left', 'right'，可通过 set_linewidth 方法设置边框线宽。
总结：
在两栏排列的期刊论文中，如果图片中subplot有两列，则字体设置为24，刻度线大小设置为8，刻度线宽度设置为3，图片边框线宽设置为3，这种设置方式能使得插入word中的图片能清晰可见。对比如下所示。上图采用的是matplotlib默认的设置，在100%视图下刻度、标签都太小，下图是采用上述设置得到的波形图，可以看到，刻度、标签都依然很清晰，能符合论文要求。以前看到评论说matplotlib能绘制出版级的图片，当时还不以为然，现在经历一番波折后算是领略到它的强大威力了。强大的工具只有在善于使用的人手里才能展现它的强大之处！


连接地址：http://blog.sina.com.cn/s/blog_ae174eaa0102vwkc.html
看到网上有的同行问怎么改示波器的背景，把示波器波形复制到Word中，我有两种方法，第一种是我一个同学告诉我的，通过命令对示波器进行操作。
具体如下
shh = get(0,'ShowHiddenHandles');
set(0,'ShowHiddenHandles','On')
set(gcf,'menubar','figure')
set(gcf,'CloseRequestFcn','closereq')
set(gcf,'DefaultLineClipping','Off')
set(0,'ShowHiddenHandles',shh)
输入以上命令可以直接对示波器进行修改，包括背景和曲线颜色
第二种方法我以前总结过，现在详细说明一下
用MATLAB命令将simulink示波器的图形画出
第一步，将你的示波器的输出曲线以矩阵形式映射到MATLAB的工作空间内。
如图1所示，双击示波器后选择parameters目录下的Data history,将Save data to workspace勾上，Format选择Array,Variable name即你输入至工作空间的矩阵名称，这里我取名aa。在这之后运行一次仿真，那么你就可以在MATLAB的工作空间里看到你示波器输出曲线的矩阵aa。如图2所示。​


第二步，用plot函数画出曲线
双击曲线矩阵aa，将可以看到详细情况，我这里的aa矩阵是一个1034行，3列的矩阵，观察这个矩阵即可以发现，这个矩阵的第一列是仿真时间，而由于我仿真时示波器内输出的是两条曲线，所以第二列和第三列即分别代表了这2条曲线。同时大家要注意，在simulink中我们有时往往在示波器中混合输出曲线，那么就要在示波器前加一个MUX混合模块，因此示波器内曲线映射到的工作空间的矩阵是和你的MUX的输入端数有关，如果你设置了3个MUX输入端，而实际上你只使用了2个，那么曲线矩阵仍然会有4列，并且其中一列是零，而不是3列。
理解曲线矩阵的原理之后，我们就可以用plot函数画出示波器中显示的图形了。
curve=plot(aa(:,1),aa(:,2),aa(:,1),aa(:,3),'--r')
�(:,1)表示取aa的第一列，仿真时间
�(:,2)表示取aa的第二列，示波器的输入一
�(:,3)表示取aa的第三列，示波器的输入二
%--r表示曲线2显示的形式和颜色，这里是（red)
set(curve(1),'linewidth',3)
%设置曲线1的粗细
set(curve(2),'linewidth',3)
%设置曲线2的粗细
legend('Fuzzy','PID')
%曲线名称标注
xlabel('仿真时间（s）')
%X坐标轴名称标注
ylabel('幅值')
%Y轴坐标轴标注
title('Fuzzy Control VS PID')
%所画图的名称
grid on
%添加网格
运行上述命令后即可以看到用MATLAB命令画出的图形了，你可以在图形出来之后继续进行编辑。​

将不同示波器中的曲线画在一张图上
如何将不同示波器中的曲线画在一张图上，很简单，如下命令解释
curve=plot(f1(:,1),f1(:,2),FP(:,1),FP(:,2),'r',FP(:,1),FP(:,3),'k')
�为即示波器1输出的曲线矩阵f1，FP为示波器2输出的曲线矩阵FP
同一示波器内的仿真时间和曲线要相一致，所以f1(:,1),f1(:,2)放一起，FP(:,1),FP(:,2)放一起，不能出现f1(:,1),FP(:,2)的情况