/// <summary>
/// 数据接收 事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void serialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
try
{
string str = serialPort.ReadExisting();
if (str != "!")
{
//MessageBox.Show("光源控制失败！","系统提示",MessageBoxButton.OKCancel,MessageBoxImage.Question );
}
//int len = serialPort.BytesToRead; //获取输入缓冲区数组长度
//byte[] RxData = new byte[len];
//serialPort.Read(RxData, 0, len); //将数据读入缓存
//if (RxData[0] == 38)
//{
// // 控制器接收命令失败，则返回&
// ReceivedSuccess = false;
//}
//else
//{
// //当命令字为1，2，3时，如控制器接收命令成功，则返回特征字$
// //当命令字为4时，如控制器接收命令成功，则返回对应通道的亮度设置参数（返回格式跟发送格式相同）
// ReceivedSuccess = true;
//}
}
catch (Exception ex)
{
SoftwareInfo.getInstance().WriteLog("serialPort_DataReceived:\n" + ex.ToString());
}
}
/// <summary>
///
/// </summary>
/// <param name="str"></param>
/// <returns>[-1异常，0成功，1无串口]</returns>
private int Write2Device(string str)
{
if (openSuceess)
{
try
{
//ReceivedSuccess = false;
//数据 +异或和
//string sendStr = str + XOR_XLen(str, 2);
byte[] sendData = System.Text.ASCIIEncoding.ASCII.GetBytes(str);
int len = sendData.Length;
serialPort.Write(sendData, 0, len);
//string str1= serialPort.ReadExisting();
System.Threading.Thread.Sleep(30);
return(0);
}
catch (Exception ex)
{
SoftwareInfo.getInstance().WriteLog("Write2Device:\n" + ex.ToString());
return(-1);
}
}
else
{
return(1);
}
}
public GenerateModelParas()
{
//m_CreateChannel = SoftwareInfo.getInstance().DefaultCreateChannel;
//m_DetectChannel = SoftwareInfo.getInstance().DefaultDetectChannel;
m_LightOrDark = SoftwareInfo.getInstance().HasBacklit;
m_RangeProduct = SoftwareInfo.getInstance().ProductGrayDefault;
m_RangeLocation = SoftwareInfo.getInstance().HoleGrayDefault;
m_MinScore = SoftwareInfo.getInstance().MinScoreDefault;
}
/// <summary>
/// 获取单例对象
/// </summary>
/// <returns></returns>
public static SoftwareInfo getInstance()
{
if (instance == null)
{
lock (typeof(SoftwareInfo))
{
if (instance == null)
{
instance = new SoftwareInfo();
}
}
}
return(instance);
}
//序列化用
public Station()
{
ModelUnMatchAlarmNum = SoftwareInfo.getInstance().ModelUnMatchAlarmNum;
CameraPhotoInterval = SoftwareInfo.getInstance().CameraPhotoInterval;
PhotoNumForOneSize = SoftwareInfo.getInstance().PhotoNumForOneSize;
CameraPhotoCount = SoftwareInfo.getInstance().CameraPhotoCount;
CameraStartPhotoPosition = SoftwareInfo.getInstance().CameraStartPhotoPosition;
CameraIntervalPhotoPosition = SoftwareInfo.getInstance().CameraIntervalPhotoPosition;
//todo
ExposureTimeRaw = 80;
GainRaw = 390;
//PriorityStationModel = SoftwareInfo.getInstance().PriorityStationModel;
isEnablePCRevise = false;
hv_CorrectGray = 0;
}
/// <summary>
/// 关闭所有 光源控制器串口
/// </summary>
public void ClosAllSerialPort()
{
if (dicLightControl == null)
{
return;
}
try
{
for (int i = 0; i < dicLightControl.Count; i++)
{
dicLightControl.ElementAt(i).Value.CloseSerialPort();
}
}
catch (Exception ex)
{
SoftwareInfo.getInstance().WriteLog("ClosAllSerialPort:\n" + ex.ToString());
}
}
//读取相机参数信息
public string ReadAndSetCameraParas(string xmlPath)
{
string xmlFileName = xmlPath + "\\CameraParas.xml";
if (System.IO.File.Exists(xmlFileName))
{
System.Xml.Linq.XDocument xDoc = System.Xml.Linq.XDocument.Load(xmlFileName);
try
{
foreach (var camera in xDoc.Root.Descendants("CameraPara"))
{
int channelNo = Convert.ToInt32(camera.Attribute("ChannelNo").Value);
int stationNo = Convert.ToInt32(camera.Attribute("StationNo").Value);
Dictionary <string, Para4HTuple> dicParas = (from para in camera.Descendants("Para4HTuple")
select new Para4HTuple
{
ParaNo = para.Attribute("ParaNo").Value,
ParaName = para.Attribute("ParaName").Value,
ParaValue = para.Attribute("ParaValue").Value,
ParaType = para.Attribute("ParaType").Value
}).ToDictionary(v => v.ParaNo);
Camera nowCamera = dicCamera[channelNo, stationNo];
if (nowCamera != null)
{
//设置参数信息
foreach (var vPara in dicParas.Values)
{
nowCamera.SetCameraPara(vPara);
}
}
}
}
catch (Exception ex)
{
SoftwareInfo.getInstance().WriteLog("ReadAndSetCameraParas:\n" + ex.ToString());
}
}
return("OK");
}
/// <summary>
/// 关闭串口
/// </summary>
/// <returns>[-1异常，0成功，1已关闭]</returns>
public int Close()
{
if (serialPort.IsOpen)
{
try
{
serialPort.Close();
return(0);
}
catch (Exception ex)
{
SoftwareInfo.getInstance().WriteLog("Close:\n" + ex.ToString());
return(-1);
}
}
else
{
return(1);
}
}
public int load(string path, ref string exMessage)
{
int result = 0;
try
{
using (Stream fStream = File.OpenRead(path))
{
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(ProductSet));
instance = serializer.Deserialize(fStream) as ProductSet;
}
}
catch (System.Exception ex)
{
SoftwareInfo.getInstance().WriteLog("load:\n" + ex.ToString());
exMessage = ex.Message;
result = 1;
}
return(result);
}
/// <summary>
/// 保存通道亮度
/// </summary>
/// <param name="xmlPath"></param>
/// <param name="exMessage"></param>
/// <returns></returns>
public List <int> SaveChannelBrightnessParas(string xmlPath, ref string exMessage)
{
//int resultFLag = 0;
List <int> brightList = new List <int>()
{
};
try
{
XElement rootNode = new XElement("Channels");
foreach (var para in dicChannelBrightness.Keys)
{
//定义一个新节点 Channel
XElement newNode = new XElement("Channel",
new XAttribute("ControlNo", para.ControlNo),
new XAttribute("ChannelNo", para.ChannelNo),
new XAttribute("Brightness", para.Brightness)
);
rootNode.Add(newNode);
brightList.Add(para.Brightness);
}
XDocument parasXDoc = new XDocument();
parasXDoc.Add(rootNode);
parasXDoc.Save(xmlPath);
exMessage = "保存成功！";
}
catch (Exception ex)
{
SoftwareInfo.getInstance().WriteLog("SaveChannelBrightnessParas:\n" + ex.ToString());
//resultFLag = -1;
exMessage = ex.Message;
}
return(brightList);
}
/// <summary>
/// 打开串口
/// </summary>
/// <returns>[-1异常，0成功，1已打开]</returns>
public int Open()
{
if (!serialPort.IsOpen)
{
try
{
serialPort.Open();
openSuceess = true;
return(0);
}
catch (Exception ex)
{
SoftwareInfo.getInstance().WriteLog("Open:\n" + ex.ToString());
openSuceess = false;
return(-1);
}
}
else
{
return(1);
}
}
public Station(int ChannelNo, int StationNo, bool isEnable)
{
IsEnable = isEnable;
ModeList = new ObservableCollection <Model>();
this.ChannelNo = ChannelNo;
this.StationNo = StationNo;
for (int i = 0; i < 4; i++)
{
ModeList.Add(new Model(i + 1));
}
ModelUnMatchAlarmNum = SoftwareInfo.getInstance().ModelUnMatchAlarmNum;
CameraPhotoInterval = SoftwareInfo.getInstance().CameraPhotoInterval;
PhotoNumForOneSize = SoftwareInfo.getInstance().PhotoNumForOneSize;
SetCameraPhotoCount(SoftwareInfo.getInstance().CameraPhotoCount);
CameraStartPhotoPosition = SoftwareInfo.getInstance().CameraStartPhotoPosition;
CameraIntervalPhotoPosition = SoftwareInfo.getInstance().CameraIntervalPhotoPosition;
//todo
ExposureTimeRaw = 80;
GainRaw = 390;
//PriorityStationModel =SoftwareInfo.getInstance().PriorityStationModel;
}
/// <summary>
/// 从配置文件中获取相机参数信息
/// </summary>
/// <param name="xmlPath"></param>
/// <param name="exMessage"></param>
/// <returns></returns>
public int GetCameraS(string xmlPath, ref string exMessage)
{
if (!System.IO.File.Exists(xmlPath))
{
exMessage = "不存在文件=" + xmlPath;
return(-1);
}
int resultFLag = 0;
try
{
XDocument xDoc = XDocument.Load(xmlPath);
foreach (var camera in xDoc.Descendants("Camera"))
{
Camera cam = new Camera();
if (camera.Attributes("StationNo").Count() > 0)
{
cam.StationNo = Convert.ToInt32(camera.Attribute("StationNo").Value);
}
else
{
resultFLag = -1;
exMessage += "相机缺少StationNo属性\r\n";
}
if (camera.Attributes("ChannelNo").Count() > 0)
{
cam.ChannelNo = Convert.ToInt32(camera.Attribute("ChannelNo").Value);
}
else
{
resultFLag = -1;
exMessage += "相机缺少ChannelNo属性\r\n";
}
if (camera.Attributes("Name").Count() > 0)
{
cam.Name = camera.Attribute("Name").Value;
}
else
{
resultFLag = -1;
exMessage += "相机缺少Name属性\r\n";
}
if (camera.Attributes("IsEnabled").Count() > 0)
{
cam.IsEnabled = camera.Attribute("IsEnabled").Value == "1" ? true : false;
}
else
{
resultFLag = -1;
exMessage += "相机缺少IsEnabled属性\r\n";
}
if (camera.Attributes("AOIHeight").Count() > 0)
{
cam.AOIHeight = Convert.ToInt32(camera.Attribute("AOIHeight").Value);
}
else
{
resultFLag = -1;
exMessage += "相机缺少AOIHeight属性\r\n";
}
if (camera.Attributes("AOIWidth").Count() > 0)
{
cam.AOIWidth = Convert.ToInt32(camera.Attribute("AOIWidth").Value);
}
else
{
resultFLag = -1;
exMessage += "相机缺少AOIWidth属性\r\n";
}
if (camera.Attributes("AlarmDelayTime").Count() > 0)
{
cam.AlarmDelayTime = Convert.ToInt32(camera.Attribute("AlarmDelayTime").Value);
}
else
{
resultFLag = -1;
exMessage += "相机缺少AlarmDelayTime属性\r\n";
}
if (camera.Attributes("AlarmDelayCode").Count() > 0)
{
cam.AlarmDelayCode = Convert.ToInt32(camera.Attribute("AlarmDelayCode").Value);
}
else
{
resultFLag = -1;
exMessage += "相机缺少AlarmDelayCode属性\r\n";
}
if (camera.Attributes("IsImageRotate").Count() > 0)
{
cam.IsImageRotate = Convert.ToInt32(camera.Attribute("IsImageRotate").Value);
}
else
{
resultFLag = -1;
exMessage += "相机缺少IsImageRotate属性\r\n";
}
//打开相机参数
cam.dicOpenFramegrabber_00_15 = (from para4 in camera.Element("OpenFramegrabber").Descendants("Para4HTuple")
select new Para4HTuple
{
ParaNo = para4.Attribute("ParaNo").Value,
ParaName = para4.Attribute("ParaName").Value,
ParaType = para4.Attribute("ParaType").Value,
ParaValue = para4.Value
}).ToDictionary(v4 => v4.ParaNo);
//设置参数
cam.dicSetFramegrabberParam = (from para7 in camera.Element("SetFramegrabberParam").Descendants("Para7HTuple")
select new Para7HTuple
{
ParaNo = para7.Attribute("ParaNo").Value,
ParaName = para7.Attribute("ParaName").Value,
ParaType = para7.Attribute("ParaType").Value,
ParaValue = para7.Value,
ShowName = para7.Attribute("ShowName").Value,
Des = para7.Attribute("Des").Value,
DefaultValue = para7.Attribute("DefaultValue").Value,
Level = Convert.ToInt32(para7.Attribute("Level").Value)
}).ToDictionary(v7 => v7.ParaNo);
cam.CameraParameters = (from paraString in camera.Element("CameraCalibration").Element("CameraParameters").Value.Split(',')
select Convert.ToDouble(paraString)).ToList();
cam.CameraPose = (from PoseString in camera.Element("CameraCalibration").Element("CameraPose").Value.Split(',')
select Convert.ToDouble(PoseString)).ToList();
cam.PixelToSizeRatio = Convert.ToDouble(camera.Element("CameraCalibration").Element("PixelToSizeRatio").Value);
int channelNo = Convert.ToInt32(camera.Attribute("ChannelNo").Value);
int stationNo = Convert.ToInt32(camera.Attribute("StationNo").Value);
dicCamera[channelNo, stationNo] = cam;
}
}
catch (Exception ex)
{
SoftwareInfo.getInstance().WriteLog("GetCameraS:\n" + ex.ToString());
resultFLag = -1;
exMessage += ex.Message;
}
return(resultFLag);
}
public int GenerateHalconParas(int AlgorithmNormalParasNum, int AlgorithmSeniorParasNum, Station station)
{
int ret = 0;
try
{
//用户框选的检测单元ROI
List <double> Region_Array_UnitList = new List <double>();
Region_Array_UnitList.Add(detectionArea.HRectList[0].Row);
Region_Array_UnitList.Add(detectionArea.HRectList[0].Column);
Region_Array_UnitList.Add(detectionArea.HRectList[0].Phi);
Region_Array_UnitList.Add(detectionArea.HRectList[0].Length1);
Region_Array_UnitList.Add(detectionArea.HRectList[0].Length2);
//用户框选的定位区域ROI
List <double> Region_Array_LHolesList = new List <double>();
foreach (var item in locationArea.HRectList)
{
Region_Array_LHolesList.Add(item.Row);
Region_Array_LHolesList.Add(item.Column);
Region_Array_LHolesList.Add(item.Phi);
Region_Array_LHolesList.Add(item.Length1);
Region_Array_LHolesList.Add(item.Length2);
}
Region_Array_Unit = Region_Array_UnitList.ToArray();
Region_Array_LHoles = Region_Array_LHolesList.ToArray();
//定位区域的坐标位置
List <double> Array_location_holes_List = new List <double>();
foreach (var v in Array_location_holes_String.Split(';'))
{
Array_location_holes_List.Add(Convert.ToDouble(v));
}
Array_location_holes = Array_location_holes_List.ToArray();
//定位区域的坐标位置与模板的坐标位置的位置仿射变换关系
List <double> HomMat2D_LocationHoles2SampleXLD_List = new List <double>();
foreach (var v in HomMat2D_LocationHoles2SampleXLD_String.Split(';'))
{
HomMat2D_LocationHoles2SampleXLD_List.Add(Convert.ToDouble(v));
}
HomMat2D_LocationHoles2SampleXLD = HomMat2D_LocationHoles2SampleXLD_List.ToArray();
//普通参数列表
List <double> parasTypeList = new List <double>();
List <double> DefectList = new List <double>();
//高级参数列表
List <double> AssistList = new List <double>();
//框个数列表
List <double> defectRectNumList = new List <double>();
//框数据列表
List <double> defectRectList = new List <double>();
//框转换图像数据列表
//List<HObject > defectxldList = new List<HObject>();
//HObject Defect_xldArray_Temp = null;
HObject ContOut = null;
////框数据列表
//List<double> defectRectList = new List<double>();
//框图形数据
HObject defect_xldArray = null;
HObject defect_xldArray_Temp = null;
HObject ContourTemp = null;
parasTypeList.Add(MeasureDefectList.Count);
defectRectNumList.Add(MeasureDefectList.Count);
foreach (var defect in MeasureDefectList)
{
parasTypeList.Add(defect.DefectAlgorithm.m_AlgId);
defectRectNumList.Add(defect.HRectList.Count + defect.HCircleList.Count + defect.HPolygonList.Count);
//普通参数个数
int NormalParasNum = 0;
//1、连续出现几次报警
DefectList.Add(defect.DefectAlgorithm.TimesToAlarm);
NormalParasNum++;
//2、精度等级
DefectList.Add(defect.DefectAlgorithm.PrecisionLevel);
NormalParasNum++;
//3、是否连续报警
DefectList.Add(Convert.ToInt32(defect.DefectAlgorithm.IsContinuousAlarm));
NormalParasNum++;
//4、单元总数量
DefectList.Add(Convert.ToInt32(defect.DefectAlgorithm.GroupNumAlarm));
NormalParasNum++;
//高级参数个数
int SeniorParasNum = 0;
//第一个参数作为报警计数不计入计算参数
for (int i = 0; i < defect.DefectAlgorithm.GenericAlgorithmParasList.Count; i++)
{
AlgorithmParas paras = defect.DefectAlgorithm.GenericAlgorithmParasList[i];
if (paras.IsSenior)
{
AssistList.Add(Convert.ToDouble(paras.Value));
SeniorParasNum++;
}
}
//foreach (var paras in defect.DefectAlgorithm.GenericAlgorithmParasList)
//{
// if (!paras.IsSenior)
// {
// DefectList.Add(Convert.ToDouble(paras.Value));
// NormalParasNum++;
// }
// else
// {
// AssistList.Add(Convert.ToDouble(paras.Value));
// SeniorParasNum++;
// }
//}
for (int i = NormalParasNum; i < AlgorithmNormalParasNum; i++)
{
DefectList.Add(0);
}
for (int i = SeniorParasNum; i < AlgorithmSeniorParasNum; i++)
{
AssistList.Add(0);
}
foreach (var rect in defect.HRectList)
{
HOperatorSet.GenRectangle2ContourXld(out ContOut, rect.Row, rect.Column, rect.Phi, rect.Length1, rect.Length2);
rect.Rect_xld = ContOut;
defectRectList.Add(1);
if (defect_xldArray == null)
{
defect_xldArray = rect.Rect_xld;
}
else
{
//defect_xldArray.ConcatObj(rect.Rect_xld);
defect_xldArray_Temp = defect_xldArray;
HOperatorSet.ConcatObj(defect_xldArray_Temp, rect.Rect_xld, out defect_xldArray);
}
}
foreach (var circle in defect.HCircleList)
{
HOperatorSet.GenCircleContourXld(out ContOut, circle.Row, circle.Column, circle.Radius, 0, 6.28318, "positive", 1);
circle.Circle_xld = ContOut;
defectRectList.Add(0);
if (defect_xldArray == null)
{
defect_xldArray = circle.Circle_xld;
}
else
{
defect_xldArray_Temp = defect_xldArray;
HOperatorSet.ConcatObj(defect_xldArray_Temp, circle.Circle_xld, out defect_xldArray);
}
}
foreach (var polygon in defect.HPolygonList)
{
HOperatorSet.GenContourPolygonXld(out ContOut, polygon.Row.ToArray(), polygon.Column.ToArray());
polygon.Polygon_xld = ContOut;
defectRectList.Add(2);
if (defect_xldArray == null)
{
defect_xldArray = polygon.Polygon_xld;
}
else
{
defect_xldArray_Temp = defect_xldArray;
HOperatorSet.ConcatObj(defect_xldArray_Temp, polygon.Polygon_xld, out defect_xldArray);
}
}
ContourTemp = defect.Hcontour;
}
//缺陷参数数组
List <double> Defect_SetArray_List = new List <double>();
Defect_SetArray_List.AddRange(parasTypeList);
Defect_SetArray_List.AddRange(DefectList);
Defect_SetArray = Defect_SetArray_List.ToArray();
//高级参数
List <double> Assistant_Array_List = new List <double>();
Assistant_Array_List.AddRange(parasTypeList);
Assistant_Array_List.AddRange(AssistList);
Defect_Assistant_Array = Assistant_Array_List.ToArray();
//缺陷框列表
List <double> Defect_RectArray_List = new List <double>();
Defect_RectArray_List.AddRange(defectRectNumList);
Defect_RectArray_List.AddRange(defectRectList);
Defect_RectArray = Defect_RectArray_List.ToArray();
Defect_xldArray = defect_xldArray;
Contour = ContourTemp;
//Defect_xldArray = defectxldList.ToArray();
////特殊区域类型列表
//List<double> specialParasTypeList = new List<double>();
////特殊区域参数列表
//List<double> specialParasList = new List<double>();
////特殊区域框个数列表
//List<double> specialRectNumList = new List<double>();
////特殊区域框数据列表
//List<double> specialRectList = new List<double>();
//specialParasTypeList.Add(MeasureSpecialRegionList.Count);
//specialRectNumList.Add(MeasureSpecialRegionList.Count);
//foreach (var special in MeasureSpecialRegionList)
//{
// specialParasList.Add(special.SpecialRegionAlgorithm.m_AlgId);
// specialRectNumList.Add(special.HRectList.Count);
// //普通参数个数
// int NormalParasNum = 0;
// foreach (var paras in special.SpecialRegionAlgorithm.GenericAlgorithmParasList)
// {
// if (!paras.IsSenior)
// {
// specialParasList.Add(Convert.ToDouble(paras.Value));
// NormalParasNum++;
// }
// else
// {
// }
// }
// for (int i = NormalParasNum; i < AlgorithmNormalParasNum; i++)
// {
// specialParasList.Add(0);
// }
// foreach (var rect in special.HRectList)
// {
// specialRectList.Add(rect.Row);
// specialRectList.Add(rect.Column);
// specialRectList.Add(rect.Phi);
// specialRectList.Add(rect.Length1);
// specialRectList.Add(rect.Length2);
// }
//}
////特殊区域参数数组
//List<double> SpecialRegion_SetArray_List = new List<double>();
//SpecialRegion_SetArray_List.AddRange(specialParasTypeList);
//SpecialRegion_SetArray_List.AddRange(specialParasList);
//SpecialRegion_SetArray = SpecialRegion_SetArray_List.ToArray();
////特殊区域框列表
//List<double> SpecialRegion_RectArray_List = new List<double>();
//SpecialRegion_RectArray_List.AddRange(specialRectNumList);
//SpecialRegion_RectArray_List.AddRange(specialRectList);
//SpecialRegion_RectArray = SpecialRegion_RectArray_List.ToArray();
List <double> CreateParaList = new List <double>();
CreateParaList.Add(generateModeParas.LightOrDark);
CreateParaList.Add(station.ImageChannel);
CreateParaList.Add(generateModeParas.RangeProduct);
CreateParaList.Add(generateModeParas.Angle_Modle);
CreateParaList.Add(generateModeParas.Select_MD);
CreateParaList.Add(generateModeParas.IsClosedZone);
CreateParaList.Add(generateModeParas.MinScore);
CreateParaList.Add(generateModeParas.RangeLocation);
CreateParaList.Add(generateModeParas.ModelPriority);
CreateParaList.Add(generateModeParas.DetectionOver);
CreateParaList.Add(generateModeParas.LocationType);
CreateParaList.Add(generateModeParas.DirectionY);
CreateParaList.Add(generateModeParas.DirectionX);
CreateParaList.Add(generateModeParas.StretchY);
CreateParaList.Add(generateModeParas.StretchX);
hv_Create_Range_Tuple = CreateParaList.ToArray();
List <double> ROIParaList = new List <double>();
ROIParaList.Add(detectionArea.OffCenters_X / PixelToSizeRatio);
ROIParaList.Add(detectionArea.OffCenters_Y / PixelToSizeRatio);
ROIParaList.Add(detectionArea.Height / PixelToSizeRatio);
ROIParaList.Add(detectionArea.Width / PixelToSizeRatio);
hv_Rect_ROI = ROIParaList.ToArray();
//灰度值
List <double> Gray_Set_List = new List <double>();
foreach (var v in hv_Gray_Set_String.Split(';'))
{
Gray_Set_List.Add(Convert.ToDouble(v));
}
Gray_Set = Gray_Set_List.ToArray();
//标定值
List <double> CalibList = new List <double>();
CalibList.AddRange(CameraParameters);
CalibList.AddRange(CameraPose);
CalibList.Add(PixelToSizeRatio);
Calib_Tuple = CalibList.ToArray();
//尺寸类型列表
List <int> Size_Type_List = new List <int>();
//公称值列表
List <double> Size_NominalValue_List = new List <double>();
//上下公差列表
List <double> Size_UpDownTolerance_List = new List <double>();
//补偿值列表
List <double> Size_Compensation_List = new List <double>();
//测量个数列表
List <int> Size_MeasureNums_List = new List <int>();
//尺寸是否显示列表
List <int> Size_IsShow_List = new List <int>();
//框个数列表
List <double> SizeRectNumList = new List <double>();
//框数据列表
List <double> SizeRectList = new List <double>();
//尺寸参数列表
List <double> SizeParaList = new List <double>();
foreach (var size in MeasureSizeList)
{
Size_Type_List.Add(size.SizeAlgorithm.m_AlgId);
Size_NominalValue_List.Add(size.SizeAlgorithm.Std);
Size_UpDownTolerance_List.Add(size.SizeAlgorithm.Up);
Size_UpDownTolerance_List.Add(size.SizeAlgorithm.Down);
Size_Compensation_List.Add(size.SizeAlgorithm.Compensate);
Size_MeasureNums_List.Add(size.SizeAlgorithm.SizeNum);
Size_IsShow_List.Add(size.SizeAlgorithm.IsShow);
SizeRectNumList.Add(size.HRectList.Count);
foreach (var rect in size.HRectList)
{
SizeRectList.Add(rect.Row);
SizeRectList.Add(rect.Column);
SizeRectList.Add(rect.Phi);
SizeRectList.Add(rect.Length1);
SizeRectList.Add(rect.Length2);
}
int SizeParaNum = 0;
foreach (var paras in size.SizeAlgorithm.GenericAlgorithmParasList)
{
SizeParaList.Add(Convert.ToDouble(paras.Value));
SizeParaNum++;
}
for (int i = SizeParaNum; i < SoftwareInfo.getInstance().AlgorithmSizeParasNum; i++)
{
SizeParaList.Add(0);
}
}
Size_Type_Array = Size_Type_List.ToArray();
Size_NominalValue_Array = Size_NominalValue_List.ToArray();
Size_UpDownTolerance_Array = Size_UpDownTolerance_List.ToArray();
Size_Compensation_Array = Size_Compensation_List.ToArray();
Size_MeasureNums_Array = Size_MeasureNums_List.ToArray();
Size_IsShow_Array = Size_IsShow_List.ToArray();
List <double> Size_Rects_Array_List = new List <double>();
Size_Rects_Array_List.AddRange(SizeRectNumList);
Size_Rects_Array_List.AddRange(SizeRectList);
Size_Rects_Array = Size_Rects_Array_List.ToArray();
Size_Algorithm_SetArray = SizeParaList.ToArray();
}
catch (Exception ex)
{
SoftwareInfo.getInstance().WriteLog("GenerateHalconParas:\n" + ex.ToString());
ret = 1;
}
return(ret);
}
/// <summary>
/// 从文件中 获取 光源通道参数
/// </summary>
/// <param name="xmlPath"></param>
/// <param name="exMessage"></param>
/// <returns></returns>
public List <int> ReadAndSetLightParas(string xmlPath)
{
List <int> brightList = new List <int>()
{
};
//InfoPath .getInstance ().ChannelBrightness
string xmlFileName = xmlPath;
//if (!System.IO.File.Exists(xmlFileName))
//{
// return "不存在文件=" + xmlFileName;
//}
string resultOK = "OK";
try
{
XDocument xDoc = XDocument.Load(xmlFileName);
var listChannelBrightness = from para in xDoc.Descendants("Channel")
select new ChannelBrightness
{
ControlNo = para.Attribute("ControlNo").Value,
ChannelNo = para.Attribute("ChannelNo").Value,
Brightness = Convert.ToInt32(para.Attribute("Brightness").Value)
};
KeyValuePair <ChannelBrightness, Channel> keyvalue;
ChannelBrightness cb = null;
foreach (var para in listChannelBrightness)
{
//try
//{
//修改 光源亮度值
keyvalue = dicChannelBrightness.First(v => { return((v.Key.ChannelNo == para.ChannelNo) && (v.Key.ControlNo == para.ControlNo)); });
keyvalue.Key.Brightness = para.Brightness;
if (!instance.dicChannelBrightness.ContainsKey(keyvalue.Key))
{
Channel channel = keyvalue.Value;
channel.NewDefaultValue = keyvalue.Key.Brightness;
instance.dicChannelBrightness.Add(keyvalue.Key, channel);
}
//else
//{
// resultFlag = ERR_EXT_ChannelNo;
// exMessage = "光源通道已存在" + controlChannelNo.ControlNo + "->" + controlChannelNo.ChannelNo;
// break;
//}
brightList.Add(keyvalue.Key.Brightness);
cb = keyvalue.Key;
//设置光源亮度
//}
//catch
//{
//}
}
SendBrightness(brightList, cb);
}
catch (Exception ex)
{
SoftwareInfo.getInstance().WriteLog("ReadAndSetLightParas:\n" + ex.ToString());
SaveChannelBrightness(xmlPath);
//MessageBox.Show("请检查当前程序ChannelBrightness文件配置是否正确！","系统提示",MessageBoxButtons.YesNo);
resultOK = ex.Message;
}
return(brightList);
}
/// <summary>
/// 加载XML 文档并 注册串口
/// </summary>
/// <param name="filePath"></param>
public int GetControlsByLoadXML(string filePath, ref string exMessage)
{
if (haveLoadXml)
{
return(ERR_HaveLoadedXML);
}
int resultFlag = 0;
//if(File.Ex
if (System.IO.File.Exists(filePath))
{
//读取XML 文件并解析
List <LightControl> listLC = new List <LightControl>();
try
{
XDocument doc = XDocument.Load(filePath);
instance.dicLightControl =
(
from LC in doc.Descendants("LightControl")
select new LightControl
{
//控制器编号
ControlNo = LC.Element("ControlNo").Value.Trim(),
IsEnabled = LC.Element("IsEnabled").Value == "0" ? false : true,
//窗口参数
SerialPortPara = new SerialPortPara
{
PortName = LC.Element("SerialPortPara").Element("PortName").Value.Trim(),
BaudRate = Convert.ToInt32(LC.Element("SerialPortPara").Element("BaudRate").Value),
DataBits = Convert.ToInt32(LC.Element("SerialPortPara").Element("DataBits").Value),
StopBits = (StopBits)Enum.Parse(typeof(StopBits), LC.Element("SerialPortPara").Element("StopBits").Value, true),
Parity = (Parity)Enum.Parse(typeof(StopBits), LC.Element("SerialPortPara").Element("Parity").Value, true),
},
//通道列表
DicChannel = (
from channel in LC.Element("Channels").Descendants("Channel")
select new Channel
{
ChannelNo = channel.Element("ChannelNo").Value,
Name = channel.Element("Name").Value,
DefaultValue = Convert.ToInt32(channel.Element("DefaultValue").Value),
NewDefaultValue = Convert.ToInt32(channel.Element("NewDefaultValue").Value),
Des = channel.Element("Des").Value
}
).ToDictionary(v => v.ChannelNo)
}
).ToDictionary(v => v.ControlNo);
}
catch (Exception ex)
{
SoftwareInfo.getInstance().WriteLog("GetControlsByLoadXML:\n" + ex.ToString());
resultFlag = ERR_ReadXML;
exMessage = "光源配置文件错误:" + ex.Message;
}
if (resultFlag == 0 && instance.dicLightControl.Count > 0)
{
foreach (var lc in instance.dicLightControl.Values)
{
//打开串口
if (0 != lc.OpenSerialPort())
{
resultFlag = ERR_OpenSerialPort;
exMessage = "打开串口异常:" + lc.SerialPortPara.PortName;
break;
}
foreach (var ch in lc.DicChannel.Values)
{
ChannelBrightness controlChannelNo = new ChannelBrightness {
ControlNo = lc.ControlNo, ChannelNo = ch.ChannelNo, Brightness = -1
};
if (!instance.dicChannelBrightness.ContainsKey(controlChannelNo))
{
instance.dicChannelBrightness.Add(controlChannelNo, ch);
}
else
{
resultFlag = ERR_EXT_ChannelNo;
exMessage = "光源通道已存在" + controlChannelNo.ControlNo + "->" + controlChannelNo.ChannelNo;
break;
}
}
//if (System.IO.File.Exists(brightPath))
//{
// ReadAndSetLightParas(brightPath);
//}
if (resultFlag != 0)
{
break;
}
}
}
}
else
{
exMessage = "无XML文件:" + filePath;
//无XML 文件
resultFlag = ERR_NoXML;
}
return(resultFlag);
}
public void WriteLog(string str)
{
try
{
List <string> ListErrLogFileName = new List <string>()
{
};
List <string> timeList = new List <string>()
{
};
string[] strArray = new string[] { };
if (File.Exists(SoftwareInfo.getInstance().ErrorLogPath))
{
ListErrLogFileName = Directory.GetFiles(SoftwareInfo.getInstance().ErrorLogPath).ToList();
}
int count = 0;
foreach (string ErrLogFileName in ListErrLogFileName)
{
strArray = ErrLogFileName.Split(' ');
timeList.Add(strArray[strArray.Length - 1].Split('.')[0].Split('_')[0]);
}
foreach (string time in timeList)
{
//相等：0 小于today：1 大于today：-1
DateTime fileTime = Convert.ToDateTime(time);
DateTime fileTimeNew = fileTime.AddDays(SoftwareInfo.getInstance().SaveErrorLogTime);
if (DateTime.Today.CompareTo(fileTimeNew) == 1)
{
File.Delete(ListErrLogFileName[count]);
}
//dates t = DateTime.Today-fileTime;
count++;
}
rowCnt++;
string path = SoftwareInfo.getInstance().ErrorLogPath;
string pathtxt = path + "\\ErrLog " + DateTime.Now.ToString("yyyy-MM-dd") + ".txt";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
if (rowCnt > 20)
{
rowCnt = 0;
rowCntTimes++;
}
int cntTemp = 0;
while (File.Exists(pathtxt) && cntTemp < 10 && rowCntTimes != 0)
{
cntTemp++;
pathtxt = path + "\\" + rowCntTimes + "_" + "ErrLog " + DateTime.Now.ToString("yyyy-MM-dd") + ".txt";
}
using (StreamWriter sw = new StreamWriter(pathtxt, true))
{
sw.WriteLine(DateTime.Now.ToString());
sw.WriteLine(str);
sw.WriteLine("---------------------------------------------------------");
sw.Close();
}
}
catch
{ }
}
