using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.IO;
using System.Xml.Serialization;
using System.Threading;
using Misc;
using FlyADBase;
using FLY.Thick.BulkDataModule;
using FLY.Thick.Base.Common;
using FLY.Thick.Base.IService;
using FLY.Thick.Base.Server;
using FLY.Thick.Blowing.IService;
using MathNet.Numerics.LinearAlgebra.Double;
using FObjBase;
using Newtonsoft.Json;
using FLY.Thick.Blowing.Common;
using FLY.Thick.Blowing.Server.Model;
namespace FLY.Thick.Blowing.Server
{
/// <summary>
///
/// </summary>
public class GM_BlowingFix : GM_Base, IBlowingFixService, ISaveToXml
{
NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
const int MARKNO_PROFILE_ADD = 87;
const int MARKNO_PROFILE_CHANGED = 88;
HistoryDb mHistoryDb;
BulkDb mBulkDb;
#region 延时操作，markno
const int MARKNO_SAVE = 1;
const int MARKNO_CALFRAME = 2;
#endregion
/// <summary>
/// 人字架角度 & 膜走带位置检测
/// </summary>
public BlowingDetect mPDetect;
#region ISaveToXml
public string[] GetSavePropertyNames()
{
return new string[]{
"ChannelCnt",
"BPC",
"OrgBoltNo",
"EPCType",
"SampleConsume",
"SampleInterval",
"BackEdgeWait",
"IsBtnSelfHold",
"IsUsedMap",
"Map"
};
}
#endregion
#region IRenZiJiaService
#region 分区设定
/// <summary>
/// 加热通道数
/// </summary>
public int ChannelCnt { get; set; } = 88;
/// <summary>
/// 分区数/加热通道数
/// </summary>
public int BPC { get; set; } = 1;
/// <summary>
/// 风环螺丝数
/// </summary>
public int NBolts => ChannelCnt * BPC;
/// <summary>
/// 复位时，探头测量的位置对应分区号
/// </summary>
public int OrgBoltNo { get; set; } = 1;
/// <summary>
/// 第1个螺丝号
/// </summary>
public int BoltNo1st=1;
/// <summary>
/// 使用分区表
/// </summary>
public bool IsUsedMap { get; set; }
bool IsNeedMap()
{
if (IsUsedMap && Map.Count() > 0)
return true;
else
return false;
}
private List<BoltMapCell> map = new List<BoltMapCell>();
/// <summary>
/// 分区表,必须保证不能为null
/// </summary>
public List<BoltMapCell> Map
{
get { return map; }
set {
//检测是否不一样
if (value == null)
return;
if (checkNoSame_map(map,value))
{
if (!checkParamErr_map(value))
{
IsUsedMap = false;
map = new List<BoltMapCell>();
}
else
{
map = value;
}
}
}
}
#endregion
#region IRenZiJiaFixService
/// <summary>
/// 追边开始按钮自锁
/// </summary>
public bool IsBtnSelfHold
{
get {
return mEPCA10.IsBtnSelfHold;
}
set {
mEPCA10.IsBtnSelfHold = value;
}
}
/// <summary>
/// 温修对位硬件类型
/// </summary>
public RenZiJiaFixEPCType EPCType { get; set; } = RenZiJiaFixEPCType.Null;
/// <summary>
/// 采样时间， 默认2s
/// </summary>
public TimeSpan SampleConsume
{
get { return mEPCA10.SampleConsume; }
set
{
mEPCA10.SampleConsume = value;
}
}
/// <summary>
/// 温修间隔，默认45分钟
/// </summary>
public TimeSpan SampleInterval
{
get { return mEPCA10.SampleInterval; }
set
{
mEPCA10.SampleInterval = value;
}
}
/// <summary>
/// 当前温修计时，大于温修间隔就会去温修
/// </summary>
public TimeSpan SampleTimer
{
get {
return mEPCA10.SampleTimer;
}
}
/// <summary>
/// 回到边界后，再等待一段时间，那就肯定找到边界了。 默认5s
/// </summary>
public TimeSpan BackEdgeWait
{
get {
return mEPCA10.BackEdgeWait;
}
set {
mEPCA10.BackEdgeWait = value;
}
}
/// <summary>
/// 采样得到的样品AD
/// </summary>
public int SampleAD
{
get
{
return mEPCA10.SampleAD;
}
}
/// <summary>
/// 追边运行中！
/// </summary>
public bool EPCIsRunning
{
get {
return mEPCA10.IsRunning;
}
}
#endregion
/// <summary>
/// 应用
/// </summary>
public void Apply()
{
Save();
}
public event RenZiJiaDataEventHandler DataEvent;
#endregion
#region EPC
public delegate void EPCSampledEventHandler(int ad);
class EPCA10:INotifyPropertyChanged
{
/// <summary>
/// EPC-A10 警报 对应输入位
/// </summary>
const int in_epc_alarm_bit = 12;
/// <summary>
/// EPC启动 对应输入位
/// </summary>
const int in_epc_enable_bit = 6;
/// <summary>
/// EPC启动状态 对应输出位
/// </summary>
const int out_epc_isrunning_bit = 1;
/// <summary>
/// 控制EPC-A10 到温修点 对应输出位
/// </summary>
const int out_epc_sample_bit = 2;
#region public成员
public bool Enable { get; set; } = false;
/// <summary>
/// 温修时间，默认2秒
/// </summary>
public TimeSpan SampleConsume { get; set; } = TimeSpan.FromSeconds(2);
/// <summary>
/// 温修间隔，默认45分钟
/// </summary>
public TimeSpan SampleInterval { get; set; } = TimeSpan.FromMinutes(45);
/// <summary>
/// 当前温修计时，大于温修间隔就会去温修
/// </summary>
public TimeSpan SampleTimer { get; set; }= TimeSpan.Zero;
/// <summary>
/// 回到边界，再等待1段时间
/// </summary>
public TimeSpan BackEdgeWait { get; set; } = TimeSpan.FromSeconds(5);
/// <summary>
/// 追边开始按钮自锁
/// </summary>
public bool IsBtnSelfHold { get; set; } = true;
/// <summary>
/// 采样得到的样品AD
/// </summary>
public int SampleAD { get; set; } = -1;
/// <summary>
/// 追边运行中！
/// </summary>
public bool IsRunning { get; set; } = false;
public event EPCSampledEventHandler Sampled;
#endregion
/// <summary>
/// 采样开始时间
/// </summary>
/// <returns></returns>
DateTime SampleBegin;
/// <summary>
/// 回去膜边开始时间
/// </summary>
DateTime GoBackBegin;
/// <summary>
/// 去采样开始时间
/// </summary>
DateTime GoSampleBegin;
/// <summary>
/// 去采样消耗的时间
/// </summary>
TimeSpan GoSampleConsume;
IFlyAD mFlyAD;
List<int> sampledata = new List<int>();
TimeSpan sampleConsumeTimer = TimeSpan.Zero;
public EPCA10(IFlyAD flyad)
{
mFlyAD = flyad;
mFlyAD.IStatusChangedEvent += new IStatusChangedEventHandler(mFlyAD_IStatusChangedEvent);
mFlyAD.TimeGridEvent += new FlyADBase.TimeGridEventHandler(mFlyAD_TimeGridEvent);
this.PropertyChanged += EPCA10_PropertyChanged;
}
private void EPCA10_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "Enable")
{
//TODO, 错的！！！！
if(!Enable)
Stop();
}
}
void mFlyAD_TimeGridEvent(object sender, FlyADBase.TimeGridEventArgs e)
{
if (!Enable)
return;
if (State != STATE.SAMPLE)
return;
TimeSpan ts = e.Ts;//准确
DateTime dt = e.Time;//准确
int[] data = e.Data;
if (dt < SampleBegin)
return;
sampledata.AddRange(data);
sampleConsumeTimer += TimeSpan.FromTicks(ts.Ticks * data.Length);
if (sampleConsumeTimer >= SampleConsume)
{
int ad = Misc.MyMath.Avg(sampledata.ToArray());
if (Misc.MyBase.ISVALIDATA(ad))
{
SampleAD = ad;
if (Sampled != null)
Sampled(SampleAD);
}
else
{
SampleAD = -1;
}
FinishSample();
}
}
void mFlyAD_IStatusChangedEvent(object sender, IStatusChangedEventArgs e)
{
if (!Enable)
return;
if (Misc.MyBase.CHECKBIT(e.IChanged, in_epc_enable_bit - 1))
{
if (IsBtnSelfHold)
{
if (!Misc.MyBase.CHECKBIT(e.IStatus, in_epc_enable_bit - 1))
{
if (!IsRunning)
{
Start();
}
}
else
{
if (IsRunning)
{
Stop();
}
}
}
else
{
if (!Misc.MyBase.CHECKBIT(e.IStatus, in_epc_enable_bit - 1))
{
if (!IsRunning)
{
Start();
}
else
{
Stop();
}
}
}
}
}
enum STATE
{
/// <summary>
/// 没动作
/// </summary>
STOP,
/// <summary>
/// 准备去温修
/// </summary>
START,
/// <summary>
/// 去温修过程中，记录耗费的时间
/// </summary>
WAITFOR_SAMPLE,
/// <summary>
/// 已经到达温修点，温修中,采样 N秒
/// </summary>
SAMPLE,
/// <summary>
/// 等待 耗费的时间+N秒
/// </summary>
WAITFOR_EDGE,
/// <summary>
/// 测量中，等待N分钟，下次会进入START
/// </summary>
WAITFOR_NEXT,
}
/// <summary>
/// 追边状态
/// </summary>
STATE State = STATE.STOP;
public void Start()
{
if (!Enable)
return;
State = STATE.START;
SetRunning();
}
public void Stop()
{
if (!Enable)
return;
State = STATE.STOP;
ClearRunning();
GoBack();
}
void SetRunning()
{
IsRunning = true;
mFlyAD.SetOutput(
(UInt16)Misc.MyBase.BIT(out_epc_isrunning_bit - 1),
(UInt16)~Misc.MyBase.BIT(out_epc_isrunning_bit - 1));
}
void ClearRunning()
{
IsRunning = false;
mFlyAD.SetOutput(
(UInt16)Misc.MyBase.BIT(out_epc_isrunning_bit - 1),
(UInt16)Misc.MyBase.BIT(out_epc_isrunning_bit - 1));
}
bool CheckIsRunning()
{
if (!Misc.MyBase.CHECKBIT(mFlyAD.OStatus, out_epc_isrunning_bit - 1))
return true;
else
return false;
}
void GoSample()
{
mFlyAD.SetOutput(
(UInt16)Misc.MyBase.BIT(out_epc_sample_bit - 1),
(UInt16)~Misc.MyBase.BIT(out_epc_sample_bit - 1));
}
void GoBack()
{
mFlyAD.SetOutput(
(UInt16)Misc.MyBase.BIT(out_epc_sample_bit - 1),
(UInt16)Misc.MyBase.BIT(out_epc_sample_bit - 1));
}
bool IsAlarm()
{
if (!Misc.MyBase.CHECKBIT(mFlyAD.IStatus, in_epc_alarm_bit - 1))
return true;
else
return false;
}
public bool IsSampling()
{
switch (State)
{
case STATE.WAITFOR_SAMPLE:
case STATE.SAMPLE:
case STATE.WAITFOR_EDGE:
return true;
default:
return false;
}
}
void FinishSample()
{
State = STATE.WAITFOR_EDGE;
GoBack();
GoBackBegin = DateTime.Now;
}
/// <summary>
/// 应该放在完成一幅图时触发
/// </summary>
public void CheckToSample()
{
if (!Enable)
return;
if (!IsRunning)
return;
if(SampleTimer >= SampleInterval)
{
Start();
}
}
/// <summary>
/// 0.1秒触发一次
/// </summary>
public void OnPoll()
{
if (!Enable)
return;
switch (State)
{
case STATE.STOP:
if (CheckIsRunning())
ClearRunning();//这是不正常的，灭了它
break;
case STATE.START:
{
sampledata.Clear();
SampleTimer = TimeSpan.Zero;
GoSample();
GoSampleBegin = DateTime.Now;
State = STATE.WAITFOR_SAMPLE;
} break;
case STATE.WAITFOR_SAMPLE:
{
if (IsAlarm())
{
GoSampleConsume = DateTime.Now - GoSampleBegin;
//已经到达
State = STATE.SAMPLE;
SampleBegin = DateTime.Now;
sampleConsumeTimer = TimeSpan.Zero;
}
} break;
case STATE.SAMPLE:
{
} break;
case STATE.WAITFOR_EDGE:
{
TimeSpan ts = DateTime.Now - GoBackBegin;
if (ts >= GoSampleConsume + BackEdgeWait)
{
//完成
State = STATE.WAITFOR_NEXT;
}
} break;
case STATE.WAITFOR_NEXT:
{
if (SampleTimer < SampleInterval)
{
SampleTimer += TimeSpan.FromSeconds(1);
}
}break;
}
}
public event PropertyChangedEventHandler PropertyChanged;
}
EPCA10 mEPCA10;
#endregion
#region 吹膜定点解方程用
/// <summary>
/// 测量模式， 决定是否解方程
/// </summary>
public MeasureMode MMode { get; set; } = MeasureMode.Edge;
/// <summary>
/// 膜宽 单位 mm
/// </summary>
public int FilmWidth { get; set; } = 1500;
/// <summary>
/// 探头所在膜的横向位置 单位 mm
/// </summary>
public int FilmPosH { get; set; } = 70;
/// <summary>
/// 探头测量位置，袋折叠的宽度 单位 mm
/// </summary>
public int BagFold0 { get; set; } = 405;
/// <summary>
/// 另一端 袋折叠的宽度 单位 mm
/// </summary>
public int BagFold1 { get; set; } = 415;
#endregion
IBulkDataServiceAdd mBulkData;
DynArea mDynArea;
BlowingFixProfileParam mProfileParam;
/// <summary>
/// 当前正在处理的 ADList 里面的数据.No
/// </summary>
int mADListToDoNo;
/// <summary>
/// 处理放入filminfo 的数据.No
/// </summary>
int mADListToDoNo_ToFilmInfo;
/// <summary>
/// 1s一个数据，
/// </summary>
RList<ADCell> mADList;
/// <summary>
/// 1条方程
/// </summary>
class Formula
{
/// <summary>
/// n元方程
/// </summary>
public int n;
/// <summary>
/// 方程 xi前面的 ai
/// </summary>
public double[] ai;
/// <summary>
/// 方程 y 值
/// </summary>
public double y;
public Formula(int no_x)
{
int i;
n = no_x;
ai = new double[no_x];
for (i = 0; i < n; i++) ai[i] = 0;
y = 0;
}
public bool AddData(IEnumerable<int> idxs, int thick)
{
foreach(int idx in idxs)
if ((idx < 0) || (idx >= n)) return false;
foreach(int idx in idxs)
ai[idx]++;
y += thick;
return true;
}
}
class FRAME_INFO//一幅数据信息
{
public DateTime StartTime;//开始时间
public DateTime EndTime;//结束时间
public int NoStartAD;//在AD列表 处理的数据开始点
public int NoEndAD;//在AD列表 处理的数据结束点
public DIRECTION direction;//当前幅数据，方向
public double velocity;//线速度 m/min
public int rotationCnt;//人字架旋转次数
/// <summary>
/// 对应bulkdata 的数据, -1, 没有对应的bookmark，因为从来都没数据
/// </summary>
public int bookmark = -1;
/// <summary>
/// 对应数据库的 id
/// </summary>
public Int64? scandata_id = null;
/// <summary>
/// 分区数据 N*long
/// </summary>
public int[] frame;
/// <summary>
/// 经过分区表后的结果
/// </summary>
public int[] frame_map;
/// <summary>
/// 推送出去的数据，也是数据库中的数据
/// </summary>
public RenZiJiaDataEventArgs renZiJiaDataEventArgs;
/// <summary>
/// 推送出去的数据 被修改了
/// </summary>
public bool renZiJiaDataEventArgsHasChanged = false;
int frame_sum = 0;
int frame_cnt = 0;
static int virtual_nbolts = 88;
static List<Formula> virtual_formulas = new List<Formula>();
static void UpdateVirtualFormulas()
{
virtual_formulas.Clear();
for (int i = 0; i < virtual_nbolts; i++)
{
int boltindex1 = i;
int boltindex2 = i + 1;
if (boltindex2 >= virtual_nbolts)
boltindex2 = 0;
Formula fm = new Formula(virtual_nbolts);
fm.ai[boltindex1] = 1;
fm.ai[boltindex2] = -1;
virtual_formulas.Add(fm);
}
}
static FRAME_INFO()
{
UpdateVirtualFormulas();
}
public void SetNBolt(int nbolts)
{
frame = new int[nbolts];
appeared = new bool[nbolts];
for (int i = 0; i < nbolts; i++)
{
ClearFrameValue(i);
}
}
void ClearFrameValue(int index)
{
frame[index] = Misc.MyBase.NULL_VALUE;
appeared[index] = false;
}
public void Clear()
{
for (int i = 0; i < frame.Count(); i++)
{
ClearFrameValue(i);
}
IsValid = true;
HasChanged = true;
index_last = -1;
frame_cnt = 0;
frame_sum = 0;
mFormulas.Clear();
last_solvedt = DateTime.MinValue;
isTimeToSolve = false;
canSolve = false;
}
public bool HasChanged = false;//数据被改变了！！！，是时候更新bulkdata
public bool IsValid = true;//是合法数据
/// <summary>
/// 提交，完成一次操作。清除状态
/// </summary>
public void Submit()
{
HasChanged = false;
}
public void CheckForValid()
{
if (rotationCnt == 0)//旋转次数=0，肯定是不完整的数据
{
HasChanged = true;
IsValid = false;
return;
}
//所有的数据都应该大于10
for (int i = 0; i < frame.Count(); i++)
{
if (Misc.MyBase.ISVALIDATA(frame[i]))
{
if (frame[i] < 1000)
{
HasChanged = true;
IsValid = false;
return;
}
}
}
}
/// <summary>
/// 上一次解方程的时间
/// </summary>
DateTime last_solvedt = DateTime.MinValue;
/// <summary>
/// 是时候解方程
/// </summary>
bool isTimeToSolve = false;
/// <summary>
/// 方程多了，能解方程
/// </summary>
bool canSolve = false;
/// <summary>
/// 每个区号，是否有出现
/// </summary>
bool[] appeared;
/// <summary>
/// 方程组
/// </summary>
List<Formula> mFormulas = new List<Formula>();
public void SolveFormula()
{
if (!canSolve)//没有新方程，没法解
return;
int nbolts = frame.Count();
if (virtual_nbolts!= nbolts)
{
virtual_nbolts = nbolts;
UpdateVirtualFormulas();
}
//TODO 能否解得方程检查
int nrow = mFormulas.Count() + virtual_formulas.Count();
//if (nrow < NBolts) return;
//Console.WriteLine("Total get {0} formular", nrow);
//转换为 DenseMatrix 与 DenseVector
DenseMatrix matrixA = new DenseMatrix(nrow, nbolts);
DenseMatrix matrixAT = new DenseMatrix(nbolts, nrow);
DenseVector vectorB = new DenseVector(nrow);
DenseVector vectorATB = new DenseVector(nbolts);
int rowindex = 0;
foreach (Formula fm in mFormulas)
{
matrixA.SetRow(rowindex, fm.ai);
matrixAT.SetColumn(rowindex, fm.ai);
vectorB[rowindex] = fm.y;
rowindex++;
}
foreach (Formula fm in virtual_formulas)
{
matrixA.SetRow(rowindex, fm.ai);
matrixAT.SetColumn(rowindex, fm.ai);
vectorB[rowindex] = fm.y;
rowindex++;
}
DenseMatrix ATA = (DenseMatrix)matrixA.TransposeThisAndMultiply(matrixA);
DenseVector ATB = (DenseVector)matrixA.TransposeThisAndMultiply(vectorB);
DenseVector X = (DenseVector)ATA.Solve(ATB);
for (int i = 0; i < nbolts; i++)
{
int d = (appeared[i]) ? (int)X[i] : Misc.MyBase.NULL_VALUE;
frame[i] = d;// (int)X[i];
}
HasChanged = true;
isTimeToSolve = false;
canSolve = false;
}
/// <summary>
/// 检查是否需要更新
/// </summary>
public void CheckToSolveFormula()
{
if(isTimeToSolve)
{
SolveFormula();
}
}
int index_last = -1;
public void SetFrameValue(int index, int value, DateTime dt)
{
int nbolts = frame.Count();
if (index >= nbolts)
return;//异常
else if (index < 0)
return;//异常
else if (!Misc.MyBase.ISVALIDATA(value))
return;//异常
if (index_last != index)
{
index_last = index;
HasChanged = true;
frame_cnt = 0;
frame_sum = 0;
}
frame_sum += value;
frame_cnt++;
frame[index] = frame_sum / frame_cnt;
}
/// <summary>
/// 解方程方式更新 frame
/// </summary>
/// <param name="indexs"></param>
/// <param name="value"></param>
/// <param name="dt"></param>
public void SetFrameValue(IEnumerable<int> indexs, int value, DateTime dt)
{
int nbolts = frame.Count();
foreach (int index in indexs)
{
if (index >= nbolts)
return;//异常
else if (index < 0)
return;//异常
}
if (!Misc.MyBase.ISVALIDATA(value))
return;//异常
Formula fm = new Formula(nbolts);
fm.AddData(indexs, value);
mFormulas.Add(fm);
foreach (int index in indexs)
appeared[index] = true;
canSolve = true;
//5秒解一次方程
if ((index_last != indexs.First()) && ((dt - last_solvedt) >= TimeSpan.FromSeconds(5)))
{
index_last = indexs.First();
last_solvedt = dt;
isTimeToSolve = true;
}
}
}
RList<FRAME_INFO> mFrameInfoList;
AD2ThickHandler AD2Thick;
public event EPCSampledEventHandler EPCSampled
{
add {
mEPCA10.Sampled += value;
}
remove {
mEPCA10.Sampled -= value;
}
}
void checkParamErr()
{
if (ChannelCnt < 20 || ChannelCnt > 160)
{
ChannelCnt = 44;
}
if (BPC < 1 || BPC > 4)
{
BPC = 2;
}
if (OrgBoltNo < 1 || OrgBoltNo > NBolts)
{
OrgBoltNo = 1;
}
if (!checkParamErr_map(Map))
{
IsUsedMap = false;
Map = new List<BoltMapCell>();
}
}
/// <summary>
/// 检测通过，返回true
/// </summary>
/// <returns></returns>
bool checkParamErr_map(List<BoltMapCell> mapCells)
{
bool map_err = false;
bool g_o = false;
bool g_n = false;
//Map 检测
//OldNo,NewNo不能 <1 >NBolts
//Map OldNo 必须从小到大环形排列
//Map NewNo 必须从小到大环形排列
for (int i = 0; i < mapCells.Count(); i++)
{
var mapCell = mapCells[i];
if (mapCell.NewNo < 1 || mapCell.NewNo > NBolts)
{
map_err = true;
break;
}
if (mapCell.OldNo < 1 || mapCell.OldNo > NBolts)
{
map_err = true;
break;
}
int i_next = i + 1;
if (i_next >= mapCells.Count())
i_next = 0;
var mapCell_next = mapCells[i_next];
if (mapCell.OldNo >= mapCell_next.OldNo)
{
if (!g_o)
g_o = true;
else
{
map_err = true;
break;
}
}
if (mapCell.NewNo >= mapCell_next.NewNo)
{
if (!g_n)
g_n = true;
else
{
map_err = true;
break;
}
}
}
if (map_err)
{
return false;
}
else
{
return true;
}
}
bool checkNoSame_map(List<BoltMapCell> mapCells1, List<BoltMapCell> mapCells2)
{
if (mapCells1.Count() != mapCells2.Count())
return true;
for (int i = 0; i < mapCells1.Count(); i++)
{
var mapCell1 = mapCells1[i];
var mapCell2 = mapCells2[i];
if (mapCell1.NewNo != mapCell2.NewNo)
return true;
if (mapCell1.OldNo != mapCell2.OldNo)
return true;
}
return false;
}
static GM_BlowingFix()
{
Misc.SaveToXmlHepler.Regist(typeof(BoltMapCell));
}
/// <summary>
///
/// </summary>
/// <param name="flyad"></param>
public GM_BlowingFix(FlyAD7 flyad)
:base(flyad)
{
GMState = CTRL_STATE.FIX;
mPDetect = new BlowingDetect();
mEPCA10 = new EPCA10(flyad);
mPDetect.Load();
Load();
//检测参数
mPDetect.CheckParamErr();
checkParamErr();
mEPCA10.Enable = (EPCType == RenZiJiaFixEPCType.EPCA10);
mEPCA10.PropertyChanged += new PropertyChangedEventHandler(mEPCA10_PropertyChanged);
InitList();
PropertyChanged += new PropertyChangedEventHandler(RenZiJiaFix_PropertyChanged);
mPDetect.FilmInfoChangedEvent += new BlowingDetect.FilmInfoChangedEventHandler(mPDetect_FilmInfoChangedEvent);
mPDetect.ClearEvent += new BlowingDetect.ClearEventHandler(mPDetect_ClearEvent);
mFlyAD.TimeGridEvent += new FlyADBase.TimeGridEventHandler(flyad_TimeGridEvent);
mPDetect.Init(flyad);
}
void mEPCA10_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
if ((e.PropertyName == "SampleConsume") ||
(e.PropertyName == "SampleInterval") ||
(e.PropertyName == "SampleTimer") ||
(e.PropertyName == "BackEdgeWait") ||
(e.PropertyName == "IsBtnSelfHold"))
{
NotifyPropertyChanged(e.PropertyName);
}
else if (e.PropertyName == "IsRunning")
{
NotifyPropertyChanged("EPCIsRunning");
}
}
/// <summary>
/// 作废的功能
/// </summary>
public void EPCStart()
{
if(EPCType == RenZiJiaFixEPCType.EPCA10)
mEPCA10.Start();
}
/// <summary>
/// 作废的功能
/// </summary>
public void EPCStop()
{
if (EPCType == RenZiJiaFixEPCType.EPCA10)
mEPCA10.Stop();
}
void mPDetect_ClearEvent(object sender)
{
//没信号，清空所有数据！！！
}
/// <summary>
/// 从1幅数据，获取头部，尾部，为于 ADList 的位置
/// </summary>
/// <param name="frameinfo"></param>
/// <param name="index_start"></param>
/// <param name="index_end"></param>
/// <returns>false 数据不存在</returns>
bool GetFilmInfoADIndex(FRAME_INFO frameinfo, out int index_start, out int index_end)
{
index_start = mADList.No2Index(frameinfo.NoStartAD);
index_end = mADList.No2Index(frameinfo.NoEndAD);
if ((index_start < 0)||(index_end <0)||
(index_start >= mADList.Count)||(index_end >= mADList.Count))
{
//数据已经不存在，删除
return false;
}
return true;
}
void mPDetect_FilmInfoChangedEvent(object sender, BlowingDetect.FilmInfoChangedEventArgs e)
{
var ret = ADListFastSearchIndex(e.Time, out int idx);
switch (ret)
{
case ADListFastSearchIndexResult.Before://发送在过去
{
mADListToDoNo = mADList.Index2No(0);
mADListToDoNo_ToFilmInfo = mADListToDoNo;
}
break;
case ADListFastSearchIndexResult.Now://发生在列表时间内
{
mADListToDoNo = mADList.Index2No(idx);
mADListToDoNo_ToFilmInfo = mADListToDoNo;
}
break;
case ADListFastSearchIndexResult.Future:
{
//未来的，不处理
}
break;
}
}
void RenZiJiaFix_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "NBolts")
{
//所有数据删除
mFrameInfoList.Clear();
}
else if (e.PropertyName == "EPCType")
{
mEPCA10.Enable = (EPCType == RenZiJiaFixEPCType.EPCA10);
}
else if (e.PropertyName == "OrgBoltNo")
{
//TODO 只处理3幅图
int idx = mFrameInfoList.Count - 3;
if (idx < 0)
idx = 0;
if (idx >= mFrameInfoList.Count)
return;
mADListToDoNo_ToFilmInfo = mFrameInfoList[idx].NoStartAD;
}
else if ((e.PropertyName == "FilmWidth") || (e.PropertyName == "FilmPosH") ||
(e.PropertyName == "SolveEnable"))
{
//重新计算当前幅数据
UpdateCurrFrame();
}
}
/// <summary>
///
/// </summary>
/// <param name="bulkdata"></param>
/// <param name="func_ad2thick"></param>
/// <param name="dynarea"></param>
/// <param name="profileParam"></param>
/// <param name="historyDB"></param>
/// <param name="bulkDB"></param>
public void Init(
IBulkDataServiceAdd bulkdata, AD2ThickHandler func_ad2thick, DynArea dynarea,
BlowingFixProfileParam profileParam,
HistoryDb historyDB, BulkDb bulkDB
)
{
AD2Thick = func_ad2thick;
mBulkData = bulkdata;
mDynArea = dynarea;
mProfileParam = profileParam;
mHistoryDb = historyDB;
mBulkDb = bulkDB;
Misc.BindingOperations.SetBinding(profileParam, "MMode", this, "MMode");
Misc.BindingOperations.SetBinding(profileParam, "FilmWidth", this, "FilmWidth");
Misc.BindingOperations.SetBinding(profileParam, "FilmPosH", this, "FilmPosH");
Misc.BindingOperations.SetBinding(profileParam, "BagFold0", this, "BagFold0");
Misc.BindingOperations.SetBinding(profileParam, "BagFold1", this, "BagFold1");
Misc.BindingOperations.SetBinding(mPDetect, "FilmVelocity", mDynArea, "FilmVelocity");
Misc.BindingOperations.SetBinding(this, "NBolts", () =>
{
mBulkData.NBolts = NBolts;
mDynArea.NBolts = NBolts;
mDynArea.FirstBoltNo = 1;
mDynArea.DataBoltNoBegin = 1;
mDynArea.DataBoltNoEnd = NBolts;
mDynArea.ScanBoltNoBegin = 1;
mDynArea.ScanBoltNoEnd = NBolts;
});
profileParam.PropertyChanged += (s, e) =>
{
if (e.PropertyName == "K")
{
//重新计算当前幅数据
UpdateCurrFrame();
}
};
mDynArea.PropertyChanged += (s, e) =>
{
if (e.PropertyName == "SampleAD")
{
//重新计算当前幅数据
UpdateCurrFrame();
}
};
//记录调试数据
MarkDebugInit();
}
#region 记录测试数据
DateTime markdebug_dt = DateTime.MinValue;
void MarkDebugInit()
{
if (markdebug_dt == DateTime.MinValue)
markdebug_dt = DateTime.Now;
//启动1分钟定时器
FObjBase.PollModule.Current.Poll_Config(
FObjBase.PollModule.POLL_CONFIG.ADD,
()=>
{
mPDetect.GetSignList(markdebug_dt, (asyncState, retData) =>
{
var reponse = retData as GetSignListReponse;
var cells = reponse.datas;
if (cells.Count > 0)
{
mHistoryDb.AddSignData(
new Lc_Sign()
{
Time = cells.First().Time,
Signs = cells.ToArray()
});
}
}, null);
mPDetect.GetRollList(markdebug_dt, (asyncState, retData) =>
{
var reponse = retData as GetRollListReponse;
var cells = reponse.datas;
if (cells.Count > 0)
{
mHistoryDb.AddRollData(
new Lc_Roll()
{
Time = cells.First().dt,
Signs = cells.ToArray()
});
}
}, null);
this.GetADList(markdebug_dt, (asyncState, retData) =>
{
var reponse = retData as GetADListReponse;
var cells = reponse.datas;
if (cells.Count > 0)
{
var thicks = ToRealThicks(cells.Select(c => AD2Thick(c.thick)));
mHistoryDb.AddTrendData(
new Lc_TrendData(){
Time = cells.First().dt,
K = mProfileParam.K,
Thicks = thicks
});
}
}, null);
markdebug_dt = DateTime.Now;
},
TimeSpan.FromMinutes(1));
}
#endregion
void UpdateCurrFrame()
{
FObjBase.PollModule.Current.Poll_JustOnce(
new FObjBase.PollModule.PollHandler(delegate()
{
if (mFrameInfoList.Count > 0)
{
mADListToDoNo_ToFilmInfo = mFrameInfoList.Last().NoStartAD;
}
}), this, MARKNO_CALFRAME);
}
TimeSpan datOf1s_ts = TimeSpan.Zero;
TimeSpan datOf1s_interval = TimeSpan.FromSeconds(1);
List<int> datOf1s = new List<int>();
void flyad_TimeGridEvent(object sender, FlyADBase.TimeGridEventArgs e)
{
bool issample = false;
if (EPCType == RenZiJiaFixEPCType.EPCA10)
{
if (mEPCA10.IsSampling())
{
issample = true;
}
}
TimeSpan ts = e.Ts;//准确
DateTime dt = e.Time;//准确
int[] data = e.Data;
DateTime datOf100ms_dt = DateTime.MinValue;
for(int i=0;i<data.Length;i++)
{
if (issample)//采样中，数据都是无效的
{
datOf1s.Add(Misc.MyBase.NULL_VALUE);
}
else if (data[i] > UInt16.MaxValue)
{
datOf1s.Add(Misc.MyBase.NULL_VALUE);
}
else if (data[i] < 0)
{
datOf1s.Add(Misc.MyBase.NULL_VALUE);
}
else
{
datOf1s.Add(data[i]);
}
datOf1s_ts = datOf1s_ts + ts;
if (datOf100ms_dt == DateTime.MinValue)
datOf100ms_dt = dt;
else
datOf100ms_dt = datOf100ms_dt + ts;
if (datOf1s_ts>= datOf1s_interval)//1s 一个数据
{
datOf1s_ts = datOf1s_ts - datOf1s_interval;
int avgad = Misc.MyBase.NULL_VALUE;
if (datOf1s.Count() > 0)
{
avgad = Misc.MyMath.Avg(datOf1s.ToArray());
datOf1s.Clear();
}
else if (mADList.Count() > 0)
{
avgad = mADList.Last().Ad;
}
mADList.RAdd(
new ADCell()
{
Time = datOf100ms_dt,
Ad = avgad
});
}
}
}
private void InitList()//初始化列表
{
if (mADList == null)
{
mADList = new RList<ADCell>(4000);
mADListToDoNo = mADList.GetLastNo();
mADListToDoNo_ToFilmInfo = mADListToDoNo;
}
if(mFrameInfoList==null)
mFrameInfoList=new RList<FRAME_INFO>(6);
}
//复位
void Clear()
{
if(mADList!=null)
mADList.Clear();
if (mFrameInfoList != null)
{
mFrameInfoList.Clear();
}
}
int Angle2BoltIndex(double angle)
{
if(angle<0)
{
angle+=360;
}
int boltindex = (int)(OrgBoltNo - BoltNo1st +angle*NBolts/360);
if (boltindex >= NBolts)
{
boltindex -= NBolts;
}
else if (boltindex < 0)//不应该发生，可能是 OrgBoltNo 出错了。
{
boltindex += NBolts;
}
return boltindex;
}
enum ADListFastSearchIndexResult
{
/// <summary>
/// 时间点在列表以前;
/// </summary>
Before = -1,
/// <summary>
/// 时间点在列表中;
/// </summary>
Now = 0,
/// <summary>
/// 时间点在列表的未来;
/// </summary>
Future = 1
}
/// <summary>
/// 找到在 dt 前最近的 ADList 序号；
/// 当ADList 没有数据，返回 Future；
/// 已知AD列表每个数据之间的时间差，快速推断结果；
/// </summary>
/// <param name="dt"></param>
/// <param name="index"></param>
/// <returns></returns>
ADListFastSearchIndexResult ADListFastSearchIndex(DateTime dt, out int index)
{
index = 0;
if (mADList.Count <= 0)//列表没有数据， 只能当它在未来
return ADListFastSearchIndexResult.Future;
if (dt > mADList.Last().Time)
return ADListFastSearchIndexResult.Future;
else if (dt < mADList.First().Time)
return ADListFastSearchIndexResult.Before;
else
{
int offset = (int)((mADList.Last().Time - dt).TotalSeconds / datOf1s_interval.TotalSeconds);
index = mADList.Count - offset - 1;//大约在这个位置附近
//安全限制
if (index >= mADList.Count)
index = mADList.Count() - 1;
else if (index < 0)
index = 0;
if (mADList[index].Time == dt)
{
//已经找到就是它！！！！
}
else if (mADList[index].Time > dt)
{
while (true)
{
index--;
if (index <= 0)
{
index = 0;//最前面一个了
break;
}
if (mADList[index].Time <= dt)
{
//找到了
break;
}
}
}
else
{
while(true)
{
index++;//测试一下
if (index >= mADList.Count)
{
//到顶了，不找了
index--;
break;
}
else if (mADList[index].Time == dt)
{
//找到了，就是它
break;
}
else if (mADList[index].Time > dt)
{
//上一个小于，现在大于，上一个就对了
index--;
break;
}
}
}
return ADListFastSearchIndexResult.Now;
}
}
void OnPoll_UpdateADList()
{
int adlist_index = mADList.No2Index(mADListToDoNo);
if (adlist_index >= mADList.Count)
return;//没有数据需要处理
if (adlist_index < 0)
adlist_index = 0;
for (int i = adlist_index; i < mADList.Count; i++)
{
mADListToDoNo = mADList.Index2No(i);
//被测膜模式选择
switch (MMode)
{
case MeasureMode.Edge:
{
if (!OnPoll_UpdateADList_Edge(i))
return;
}
break;
case MeasureMode.Normal:
{
if (!OnPoll_UpdateADList_Normal(i))
return;
}
break;
default:
//case MeasureMode.Bag:
{
if (!OnPoll_UpdateADList_Bag(i))
return;
}
break;
}
}
mADListToDoNo = mADList.Index2No(mADList.Count);
}
#region 不同测量模式的ADList数据更新
bool OnPoll_UpdateADList_Edge(int idx)
{
BlowingDetect.FilmInfo filminfo;
int ret = mPDetect.GetFilmInfo(out filminfo, mADList[idx].Time, 2.3, 0);
if (ret == 1)//发生在未来
{
return false;
}
if (filminfo == null)//异常，FilmPosH 错误
{
return false;
}
if (mADListToDoNo != mADList.Index2No(idx))//触发了事件
{
return false;
}
ADCell adcell = mADList[idx];
adcell.Angles.Clear();
adcell.Angles.Add(filminfo.angle1);
adcell.Direction = filminfo.direction;
adcell.Velocity = filminfo.filmVelocity;
adcell.RotationCnt = filminfo.rotationCnt;
adcell.InCV = filminfo.inCV;
return true;
}
bool OnPoll_UpdateADList_Normal(int idx)
{
BlowingDetect.FilmInfo filminfo;
int ret = mPDetect.GetFilmInfo(out filminfo, mADList[idx].Time, FilmWidth, FilmPosH);
if (ret == 1)//发生在未来
{
return false;
}
if (filminfo == null)//异常，FilmPosH 错误
{
return false;
}
if (mADListToDoNo != mADList.Index2No(idx))//触发了事件
{
return false;
}
ADCell adcell = mADList[idx];
adcell.Angles.Clear();
adcell.Angles.Add(filminfo.angle1);
adcell.Angles.Add(filminfo.angle2);
adcell.Direction = filminfo.direction;
adcell.Velocity = filminfo.filmVelocity;
adcell.RotationCnt = filminfo.rotationCnt;
adcell.InCV = filminfo.inCV;
return true;
}
bool OnPoll_UpdateADList_Bag(int idx)
{
double filmWidth = FilmWidth + BagFold0 + BagFold1;
//最内2层
BlowingDetect.FilmInfo filminfo0;
double filmPosH0 = BagFold0 - FilmPosH;
int ret = mPDetect.GetFilmInfo(out filminfo0, mADList[idx].Time, filmWidth, filmPosH0);
if (ret == 1)//发生在未来
{
return false;
}
if (filminfo0 == null)//异常，FilmPosH 错误
{
return false;
}
if (mADListToDoNo != mADList.Index2No(idx))//触发了事件
{
return false;
}
//最外2层
BlowingDetect.FilmInfo filminfo1;
double filmPosH1 = BagFold0 + FilmPosH;
mPDetect.GetFilmInfo(out filminfo1, mADList[idx].Time, filmWidth, filmPosH1);
ADCell adcell = mADList[idx];
adcell.Angles.Clear();
adcell.Angles.Add(filminfo1.angle1);
adcell.Angles.Add(filminfo0.angle1);
adcell.Angles.Add(filminfo0.angle2);
adcell.Angles.Add(filminfo1.angle2);
//下面的参数 filminfo0 与 filminfo1 一样
adcell.Direction = filminfo0.direction;
adcell.Velocity = filminfo0.filmVelocity;
adcell.RotationCnt = filminfo0.rotationCnt;
adcell.InCV = filminfo0.inCV;
return true;
}
#endregion
/// <summary>
/// 状态不一样，人字架已经转了新一圈，需要增加新一幅数据
/// </summary>
/// <param name="adcell"></param>
/// <param name="frameinfo"></param>
/// <returns></returns>
bool FrameInfoCheckToNew(ADCell adcell, FRAME_INFO frameinfo)
{
if ((adcell.Direction != frameinfo.direction) ||
(adcell.RotationCnt != frameinfo.rotationCnt) )
//(Math.Abs(adcell.velocity - frameinfo.velocity) > 2))
{
return true;
}
else
{
return false;
}
}
FR_DATA_TYPE Direction2FR_DATA_TYPE(Misc.DIRECTION direction)
{
if (direction == DIRECTION.FORWARD)
return FR_DATA_TYPE.INVALID;
else
return FR_DATA_TYPE.VALID;
}
/// <summary>
/// 输出的数据都必须是稳定，可靠的。 生成一幅幅测厚仪数据！！！！！！！！！！！！
/// </summary>
void OnPoll_UpdateFrameInfo()
{
RenZiJiaDataEventArgs renZiJiaDataEventArgs=null;//当数据被修改，推送事件！！！，当只有最后一幅图被推送
int adlist_index = mADList.No2Index(mADListToDoNo_ToFilmInfo);//当前在处理的 数据点
if (adlist_index >= mADList.Count)
return;//没有数据需要处理
if (adlist_index < 0)//全部都要处理
adlist_index = 0;
//当没有任何一幅数据时， frameinfo_index = mFrameInfoList.Count = 0
int frameinfo_index = Math.Max(mFrameInfoList.Count - 1, 0);
//查找adlist_index 属于哪个frameinfo;
//当找到，清空里面的.frame,一切重新开始！！！
//当不能找到，说明只是接着上次的处理而已，不需要重新开始
for (int i = 0; i < mFrameInfoList.Count; i++)
{
int index_start;
int index_end;
FRAME_INFO frameinfo = mFrameInfoList[i];
if (!GetFilmInfoADIndex(frameinfo, out index_start, out index_end))
{
//数据已经不存在，删除
mFrameInfoList.RemoveAt(i);
i--;
continue;
}
if (adlist_index <= index_end)
{
//要处理的数据点，位于 这幅数据 (frameinfo)； 重新计算整幅数据
frameinfo_index = i;
//adlist_index = mADList.No2Index(frameinfo.NoStartAD);
break;
}
}
int adlist_todo_index = mADList.No2Index(mADListToDoNo);//已经成功获取完位置信息的数据尽头
for (int i = adlist_index; (i < mADList.Count && i<adlist_todo_index); i++)
{
ADCell adcell = mADList[i];
//mADListToDoNo_ToFilmInfo = mADList.Index2No(i);
FRAME_INFO frameinfo;
//--------------------------------------------------------------------------------------------------------
//条件检测
if (frameinfo_index >= mFrameInfoList.Count)//根本没数据，新建
{
frameinfo = new FRAME_INFO();
frameinfo.StartTime = adcell.Time;
frameinfo.EndTime = adcell.Time;
frameinfo.direction = adcell.Direction;
frameinfo.velocity = adcell.Velocity;
frameinfo.rotationCnt = adcell.RotationCnt;
frameinfo.NoStartAD = mADList.Index2No(i);
frameinfo.NoEndAD = mADList.Index2No(i);
frameinfo.SetNBolt(NBolts);
mFrameInfoList.RAdd(frameinfo);
frameinfo_index = mFrameInfoList.Count - 1;
}
else
{
frameinfo = mFrameInfoList[frameinfo_index];
if (i <= mADList.No2Index(frameinfo.NoEndAD))
{
//当为新数据， i应该>mADList.No2Index(frameinfo.NoEndAD)
//能进这里，证明是要重新计算
//清空数据，重新来过
frameinfo.StartTime = adcell.Time;
frameinfo.EndTime = adcell.Time;
frameinfo.direction = adcell.Direction;
frameinfo.velocity = adcell.Velocity;
frameinfo.rotationCnt = adcell.RotationCnt;
frameinfo.NoStartAD = mADList.Index2No(i);
frameinfo.NoEndAD = mADList.Index2No(i);
frameinfo.Clear();
}
}
//--------------------------------------------------------------------------------------------------------
if (FrameInfoCheckToNew(adcell, frameinfo))
{
//一幅数据已经完成
switch (MMode)
{
case MeasureMode.Normal:
case MeasureMode.Bag:
{
//最后检查一下是否需要解方程
frameinfo.SolveFormula();
}
break;
}
//重新分区
if (IsNeedMap())
{
Dictionary<int, int> m = new Dictionary<int, int>();
for (int j = 0; j < Map.Count(); j++)
m.Add(Map[j].OldNo - 1, Map[j].NewNo - 1);
frameinfo.frame_map = Misc.MyMath.Map(frameinfo.frame, m);
}
//更新数据库内容
{
int[] frame;
List<BoltMapCell> map;
if (IsNeedMap())
{
frame = frameinfo.frame_map;
map = new List<BoltMapCell>();
foreach (var m in Map)
map.Add(m.Clone());
}
else
{
frame = frameinfo.frame;
map = null;
}
var realthicks = ToRealThicks(frame);
frameinfo.renZiJiaDataEventArgs = new RenZiJiaDataEventArgs()
{
Time = frameinfo.StartTime,
EndTime = frameinfo.EndTime,
IsBackw = frameinfo.direction == DIRECTION.BACKWARD,
RPeriod = mPDetect.RenZiJiaPeriod,
RCnt = frameinfo.rotationCnt,
OrgBoltNo = OrgBoltNo,
RAngle = Math.Round(mPDetect.RAngle,2),
FilmLength = Math.Round(mPDetect.FilmLength,2),
FilmVelocity = Math.Round(mPDetect.FilmVelocity,2),
K = Math.Round(mProfileParam.K,3),
Thicks = realthicks,
Boltmap = map
};
frameinfo.renZiJiaDataEventArgsHasChanged = true;
}
renZiJiaDataEventArgs = frameinfo.renZiJiaDataEventArgs;
//更新到下一个frameinfo
frameinfo_index++;
i--;
continue;
}
int thick = AD2Thick(adcell.Ad);
switch (MMode)
{
case MeasureMode.Edge:
{
//均值，更新frameinfo.frame
frameinfo.SetFrameValue(Angle2BoltIndex(adcell.Angles.First()), thick , adcell.Time);
}
break;
case MeasureMode.Normal:
{
//解方程，更新frameinfo.frame
var list = from a in adcell.Angles select Angle2BoltIndex(a);
frameinfo.SetFrameValue(list, thick * 2, adcell.Time);
}
break;
default:
//case MeasureMode.Bag:
{
//解方程，更新frameinfo.frame
var list = from a in adcell.Angles select Angle2BoltIndex(a);
frameinfo.SetFrameValue(list, thick * 4, adcell.Time);
}
break;
}
frameinfo.EndTime = adcell.Time;
frameinfo.NoEndAD = mADList.Index2No(i);
}
mADListToDoNo_ToFilmInfo = mADListToDoNo;
//检测数据更新情况，放入bulkdata
for (int i = 0; i < mFrameInfoList.Count; i++)
{
FRAME_INFO frameinfo = mFrameInfoList[i];
switch (MMode)
{
case MeasureMode.Normal:
case MeasureMode.Bag:
{
//最后检查一下是否需要解方程
frameinfo.SolveFormula();
}
break;
}
if (frameinfo.HasChanged)//数据检测过，需要更新bulkdata里面的数据, 大部分发生在扫描过程中，还没结束一幅图
{
//重新分区
if (IsNeedMap())
{
Dictionary<int, int> m = new Dictionary<int, int>();
for (int j = 0; j < Map.Count(); j++)
m.Add(Map[j].OldNo - 1, Map[j].NewNo - 1);
frameinfo.frame_map = Misc.MyMath.Map(frameinfo.frame, m);
}
int[] thicks = IsNeedMap() ? frameinfo.frame_map : frameinfo.frame;
if (frameinfo.bookmark != -1)
{
if (!mBulkData.Change(frameinfo.bookmark, 0, thicks,
Direction2FR_DATA_TYPE(frameinfo.direction),
frameinfo.StartTime))
{
//修改失败，肯定是 bulkdata被清空了
frameinfo.bookmark = -1;
}
}
if (frameinfo.bookmark == -1)
{
mBulkData.Save();
//添加新的
frameinfo.bookmark = mBulkData.Add(thicks,
Direction2FR_DATA_TYPE(frameinfo.direction),
frameinfo.StartTime);
if (EPCType == RenZiJiaFixEPCType.EPCA10)
mEPCA10.CheckToSample();
}
}
}
if(mFrameInfoList.Count()>0)
{
FRAME_INFO frameinfo = null;
try
{
frameinfo = mFrameInfoList.Last(f => f.HasChanged);
}
catch
{
}
if (frameinfo != null)
{
int[] thicks = IsNeedMap() ? frameinfo.frame_map : frameinfo.frame;
mBulkDb.SetTempFrame(0, ToRealThicks(thicks));
}
}
foreach (var frameinfo in mFrameInfoList)
{
frameinfo.Submit();
}
#region sqlite3 历史数据保存
if (mFrameInfoList.Any((frameinfo) => frameinfo.renZiJiaDataEventArgsHasChanged))
{
//下辊检测
if (mHistoryDb.localDb.IsProfileFinished)
{
AddProfile();
}
}
//检测数据更新情况，放入数据库, 数据不能被修改
foreach (var frameinfo in mFrameInfoList)
{
if (frameinfo.renZiJiaDataEventArgsHasChanged)
{
frameinfo.renZiJiaDataEventArgsHasChanged = false;
if (frameinfo.scandata_id == null)
{
//添加数据
var lc_scandata = Lc_AutoMapperProfile.Mapper.Map<Lc_ScanData>(frameinfo.renZiJiaDataEventArgs);
mHistoryDb.AddScanData(lc_scandata);
frameinfo.scandata_id = lc_scandata.ID;
}
else
{
//修改数据
var lc_scandata = Lc_AutoMapperProfile.Mapper.Map<Lc_ScanData>(frameinfo.renZiJiaDataEventArgs);
lc_scandata.ID = (Int64)frameinfo.scandata_id;
mHistoryDb.UpdateScanData(lc_scandata);
}
}
}
#endregion
//当数据被修改，只推送最后一次的数据
if (renZiJiaDataEventArgs != null)
DataEvent?.Invoke(this, renZiJiaDataEventArgs);
}
double[] ToRealThicks(IEnumerable<int> frame)
{
return frame.Select(t =>
{
if (Misc.MyBase.ISVALIDATA(t))
return t / 100.0;
else
return double.NaN;
}).ToArray();
}
protected override void OnPoll()
{
if (EPCType == RenZiJiaFixEPCType.EPCA10)
mEPCA10.OnPoll();
OnPoll_UpdateADList();
OnPoll_UpdateFrameInfo();
}
public override bool Start()
{
//以前的 Start()
IsRunning = true;
mBulkData.InitPush();
//清空临时数据
mBulkDb.SetTempFrame(0, null);
#region sqlite3 历史数据保存
CheckProfile();
mProfileParam.PropertyChanged += MProfileParam_PropertyChanged;
#endregion
FObjBase.PollModule.Current.Poll_Config(
FObjBase.PollModule.POLL_CONFIG.ADD,
onpoll_func,
TimeSpan.FromSeconds(1));
return true;
}
#region sqlite3 历史数据保存
string[] profile_propertynames_add = new string[]{
"PName",
"OrderNo",
"Number"
};
string[] profile_propertynames_update = new string[]{
"Target",
"TolerancePercent"
};
void CheckProfile()
{
if (mHistoryDb.localDb.IsProfileFinished)
{
//复位 膜纵向位置
AddProfile();
}
else
{
if (mHistoryDb.localDb.CurrProfile != null)
{
Db_Profile dB_Profile = mHistoryDb.localDb.CurrProfile;
if ((dB_Profile.PName != mProfileParam.PName) ||
(dB_Profile.OrderNo != mProfileParam.OrderNo) ||
(dB_Profile.Number != mProfileParam.Number))
{
AddProfile();
}
else
{
//继续上一次生产！！！！
UpdateProfile();
}
}
else
{
//异常
AddProfile();
}
}
}
void AddProfile()
{
mHistoryDb.AddProfile(new Db_Profile()
{
PName = mProfileParam.PName,
OrderNo = mProfileParam.OrderNo,
Number = mProfileParam.Number,
Target = mProfileParam.Target,
TolerancePercent = mProfileParam.TolerancePercent,
StartTime = DateTime.Now,
EndTime = DateTime.Now
});
}
void UpdateProfile()
{
mHistoryDb.UpdateProfile(new Db_Profile()
{
PName = mProfileParam.PName,
OrderNo = mProfileParam.OrderNo,
Number = mProfileParam.Number,
Target = mProfileParam.Target,
TolerancePercent = mProfileParam.TolerancePercent,
});
}
private void MProfileParam_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (profile_propertynames_add.Contains(e.PropertyName))
{
FObjBase.PollModule.Current.Poll_JustOnce(
() =>
{
if (!mHistoryDb.localDb.IsProfileFinished)
{
mHistoryDb.FinishProfile();
}
AddProfile();//新
}, this, MARKNO_PROFILE_ADD);
}
else if (profile_propertynames_update.Contains(e.PropertyName))
{
FObjBase.PollModule.Current.Poll_JustOnce(
() =>
{
UpdateProfile();//修改
}, this, MARKNO_PROFILE_CHANGED);
}
}
#endregion
bool Load()
{
return Misc.SaveToXmlHepler.Load("renzijiafix.xml",this);
}
void Save()
{
Misc.SaveToXmlHepler.Save("renzijiafix.xml", this);
}
/// <summary>
/// 获取 厚度列表
/// </summary>
/// <param name="begin">开始时间</param>
/// <param name="AsyncDelegate">retdata = GetRollListReponse</param>
/// <param name="AsyncState"></param>
public void GetADList(DateTime begin, AsyncCBHandler AsyncDelegate, object AsyncState)
{
var p = new GetADListReponse
{
datas = mADList.FindAll(a => a.Time >= begin).Select(a => new ADSingle() { dt = a.Time,
thick = AD2Thick(a.Ad) }).ToList()
};
AsyncDelegate(AsyncState, p);
}
}
}