using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Threading;
using System.IO;
using MathNet.Numerics.LinearAlgebra.Double;
using Misc;
using FLY.Thick.BulkDataModule;
using FlyADBase;
using FLY.Thick.Base.Common;
using FLY.Thick.BlowingScan.IService;
using FLY.Thick.Base.Server;
using FObjBase;
using FLY.Thick.BlowingScan.Common;
using FLY.Thick.Blowing.IService;
using FLY.Thick.Blowing.Server;
using FLY.Thick.Blowing.Server.Model;
using HistoryDb = FLY.Thick.BlowingScan.Server.Model.HistoryDb;
namespace FLY.Thick.BlowingScan.Server
{
public class GM_BlowingScan:GM_ScanMotion, IBlowingScanService,ISaveToXml
{
#region 延时操作，markno
const int MARKNO_SAVE = 1;
const int MARKNO_PROFILE_ADD = 87;
const int MARKNO_PROFILE_CHANGED = 88;
#endregion
/// <summary>
///边界查找模块
/// </summary>
private BorderSearch mBorderSearch;
/// <summary>
///人字架位置检测器
/// </summary>
public BlowingDetect mPDetect;
/// <summary>
/// AD值转厚度值
/// </summary>
private AD2ThickHandler AD2Thick;
/// <summary>
/// 扫描数据库
/// </summary>
private IBulkDataServiceAdd mBulkData;
BlowingProfileParam mProfileParam;
HistoryDb mHistoryDb;
BulkDb mBulkDb;
/// <summary>
/// 上幅数据解方程失败，bookmark被释放出来
/// </summary>
private int freebm=-1;
private int GetFreeBm()
{
int r = freebm;
freebm = -1;
return r;
}
private void SetFreeBm(int bm)
{
freebm = bm;
}
/// <summary>
/// 动态数据组合
/// </summary>
private DynArea mDynArea;
/// <summary>
/// 扫描脉冲检测
/// </summary>
private ScanPosDetect mScanPosDetect;
/// <summary>
/// 当前扫描号
/// </summary>
public int ScanNo =0;
class ScanPosCell
{
public DateTime dt = DateTime.MinValue;
public int pos;//位于膜的位置,不是机架
public int thick;//两层的厚度
//由pos转换!!
public double angle1;//上层 位于膜泡的角度
public double angle2;//下层 位于膜泡的角度
public Misc.DIRECTION direction;//只有一整副数据都是同一个方向，才能解方程
public ScanPosCell Clone()
{
ScanPosCell scanpos = new ScanPosCell();
scanpos.dt = dt;
scanpos.pos = pos;
scanpos.thick = thick;
scanpos.angle1 = angle1;
scanpos.angle2 = angle2;
scanpos.direction = direction;
return scanpos;
}
}
class EquationCell
{
public Dictionary<int,int> boltPower=new Dictionary<int,int>();//key=boltindex, value=power
public int thick=0;
public int mainBolt;//主分区号
public void Add(int boltindex1, int boltindex2, int thick)
{
if (boltPower.ContainsKey(boltindex1))
{
boltPower[boltindex1]++;
}
else
{
boltPower.Add(boltindex1, 1);
}
if (boltPower.ContainsKey(boltindex2))
{
boltPower[boltindex2]++;
}
else
{
boltPower.Add(boltindex2, 1);
}
this.thick += thick;
}
public override string ToString()
{
string str = "";
foreach (var b in boltPower)
{
str += "[" + b.Key.ToString() + "," + b.Value.ToString() + "] ";
}
return str;
}
public double[] GetPower(int nbolts)
{
double[] power = new double[nbolts];
for (int i = 0; i < power.Count(); i++)
power[i] = 0;
foreach (var kv in boltPower)
{
power[kv.Key] = kv.Value;
}
return power;
}
public int GetAvg()
{
int cnt=0;
for (int i = 0; i < boltPower.Count(); i++)
{
cnt += boltPower.Values.ElementAt(i);
}
if (cnt > 0)
return thick / cnt;
else
return Misc.MyBase.NULL_VALUE;
}
}
class ScanInfoCell
{
public ScanInfoCell Clone()
{
ScanInfoCell scaninfo = new ScanInfoCell(ScanNo, thicks.Count());
scaninfo.Direction = Direction;
scaninfo.ScanNo = ScanNo;
scaninfo.IsFull = IsFull;
scaninfo.IndexOfToGetTime = IndexOfToGetTime;
foreach(ScanPosCell scanpos in frame)
{
scaninfo.frame.Add(scanpos.Clone());
}
scaninfo.width = width;
scaninfo.beginPos = beginPos;
scaninfo.endPos = endPos;
scaninfo.lockbm = lockbm;
return scaninfo;
}
public enum GetAngleResult
{
/// <summary>
/// 全部grid 数据已经获取，而且都成功转为方程
/// </summary>
AllGet,
/// <summary>
/// 部分grid 数据已经获取，这次转化了一些方程
/// </summary>
PartGet,
/// <summary>
/// 什么都没干，没有转化为任何方程
/// </summary>
NothingToDo
}
public GetAngleResult GetAngle(BlowingDetect rdetect, int orgboltno, int sensorWidth)
{
bool bHasNewData = false;
for (; IndexOfToGetAngle < IndexOfToGetTime; IndexOfToGetAngle++)
{
int i = IndexOfToGetAngle;
ScanPosCell scanpos = frame[i];
BlowingDetect.FilmInfo filminfo;
if (scanpos.dt == DateTime.MinValue)
{
}
int ret = rdetect.GetFilmInfo(
out filminfo,
scanpos.dt,
width,
scanpos.pos
);
if (ret == 1)
{
//发生在未来，等下一次Poll
if (IsFull)
return GetAngleResult.NothingToDo;
else
{
if (bHasNewData)
return GetAngleResult.PartGet;
else
return GetAngleResult.NothingToDo;
}
}
//成功获取
scanpos.angle1 = filminfo.angle1;
scanpos.angle2 = filminfo.angle2;
scanpos.direction = filminfo.direction;
if (IndexOfToGetAngle == 0)
{
Direction = scanpos.direction;
}
else
{
if (Direction != scanpos.direction)
{
Direction = DIRECTION.FIX;
}
}
//探头直径转为角度范围
double sensor_angle = 180.0 * sensorWidth / width;
if (AddEquation(i, orgboltno, sensor_angle))
bHasNewData = true;
}
if (IsFull)
return GetAngleResult.AllGet;
else
{
if (bHasNewData)
return GetAngleResult.PartGet;
else
return GetAngleResult.NothingToDo;
}
}
int GetBoltIndexFromAngle(double a, int orgboltno)
{
int boltno1st = 1;
int nbolts = thicks.Count();
int boltindex = (int)(a / 360 * nbolts);
boltindex += orgboltno - boltno1st;
if (boltindex >= nbolts)
boltindex -= nbolts;
return boltindex;
}
int boltindex1_last = -1;
/// <summary>
/// 完成了一些方程，返回true
/// </summary>
/// <param name="scanpos_idx"></param>
/// <param name="orgboltno">复位区号</param>
/// <param name="sensor_angle">探头直径对应的角度范围</param>
/// <returns></returns>
bool AddEquation(int scanpos_idx, int orgboltno, double sensor_angle)
{
ScanPosCell scanpos = frame[scanpos_idx];
if (equationList.Count() == 0)//复位记录
boltindex1_last = -1;
EquationCell equation = new EquationCell();
equationList.Add(equation);
int boltindex1 = GetBoltIndexFromAngle(scanpos.angle1, orgboltno);
equation.mainBolt = boltindex1;
equation.Add(
GetBoltIndexFromAngle(scanpos.angle1, orgboltno),
GetBoltIndexFromAngle(scanpos.angle2, orgboltno),
scanpos.thick);
//添加直径范围内的方程
for (int i = 1; i < sensor_angle / 2; i++)
{
equation.Add(
GetBoltIndexFromAngle(scanpos.angle1 + i, orgboltno),
GetBoltIndexFromAngle(scanpos.angle2 + i, orgboltno),
scanpos.thick);
equation.Add(
GetBoltIndexFromAngle(scanpos.angle1 - i, orgboltno),
GetBoltIndexFromAngle(scanpos.angle2 - i, orgboltno),
scanpos.thick);
}
if (boltindex1_last != boltindex1)//记录不同，通知外部是时候解方程了
{
boltindex1_last = boltindex1;
return true;
}
return false;
}
public int GetAvg()
{
if (equationList.Count() < 0)
return Misc.MyBase.NULL_VALUE;
int sum = 0;
int cnt = 0;
for (int i = 0; i < equationList.Count(); i++)
{
EquationCell equation = equationList[i];
int a = equation.GetAvg();
if (Misc.MyBase.ISVALIDATA(a))
{
sum += a;
cnt++;
}
}
if (cnt > 0)
return sum / cnt;
else
return Misc.MyBase.NULL_VALUE;
}
//public void SaveEquation(StreamWriter sw)
//{
// for (int i = 0; i < equationList.Count(); i++)
// {
// EquationCell equation = equationList[i];
// string s = ScanNo.ToString();
// s +=","+ Direction.ToString();
// s += "," + StartTime.ToString();
// s+=","+equation.thick.ToString();
// for (int j = 0; j < equation.boltPower.Count(); j++)
// {
// int boltindex = equation.boltPower.Keys.ElementAt(j);
// s += "," + boltindex.ToString();
// s += "," + equation.boltPower[boltindex].ToString();
// }
// sw.WriteLine(s);
// }
//}
//public static void SaveEquation_Header(StreamWriter sw)
//{
// string s = "序号,方向,时间,总厚度,序号1,数量1,序号2,数量2";
// sw.WriteLine(s);
//}
public ScanInfoCell(int scanNo, int nbolts)
{
Reset(scanNo);
thicks = new int[nbolts];
for (int i = 0; i < nbolts; i++)
{
thicks[i] = Misc.MyBase.NULL_VALUE;
}
}
/// <summary>
/// 开始测量时间
/// </summary>
public DateTime StartTime;
/// <summary>
/// 结束测量时间
/// </summary>
public DateTime EndTime;
/// <summary>
/// 旋转架旋转的方向，当同一次扫描中，有两个方向，Direction= Fix；
/// </summary>
public Misc.DIRECTION Direction;
/// <summary>
/// 扫描号，必须唯一！！！！！
/// </summary>
public int ScanNo;
/// <summary>
/// grid数据，已经全部放入！！！！！
/// </summary>
public bool IsFull;
/// <summary>
/// 准备要去获取时间的ScanPosCell序号, -1, 整个scaninfo 都发生在过去，作废
/// </summary>
public int IndexOfToGetTime;
/// <summary>
/// 准备要去转角度的ScanPosCell序号
/// </summary>
public int IndexOfToGetAngle;
/// <summary>
/// 快速解方法，equationList序号
/// </summary>
public int IndexOfToSolveEquationQuick;
public void Reset(int scanNo)
{
ScanNo = scanNo;
frame.Clear();
equationList.Clear();
IsFull = false;
IndexOfToGetTime = 0;
IndexOfToGetAngle = 0;
Direction = DIRECTION.FORWARD;
}
/// <summary>
/// 复位数据；一幅grid成功生成,重新获取pos,thick,time,angle,equation
/// </summary>
/// <param name="beginPos"></param>
/// <param name="endPos"></param>
public void Reset_IsFull(int beginPos, int endPos)
{
this.beginPos = beginPos;
this.endPos = endPos;
this.width = endPos - beginPos + 1;//膜宽
this.IsFull = true;
equationList.Clear();
frame.Clear();
IndexOfToGetTime = 0;
IndexOfToGetAngle = 0;
}
void ClearFrame()
{
equationList.Clear();
frame.Clear();
IndexOfToGetTime = 0;
IndexOfToGetAngle = 0;
}
public void Reset2GetAngle()
{
IndexOfToGetAngle = 0;
equationList.Clear();
for (int i = 0; i < thicks.Count(); i++)
thicks[i] = Misc.MyBase.NULL_VALUE;
}
/// <summary>
/// 原始数据(时间，位置，总厚度
/// </summary>
public List<ScanPosCell> frame=new List<ScanPosCell>();
/// <summary>
/// 膜的宽度
/// </summary>
public int width=-1;
/// <summary>
/// 膜边界左
/// </summary>
public int beginPos;
/// <summary>
/// 膜边界右
/// </summary>
public int endPos;
/// <summary>
/// 方程列表
/// </summary>
public List<EquationCell> equationList=new List<EquationCell>();
/// <summary>
/// 下面解方程得到的一幅数据对应的数据，与 StartTime 不一样
/// </summary>
public DateTime thicks_dt;
/// <summary>
/// 一幅数据
/// </summary>
public int[] thicks;
/// <summary>
/// 经过分区表后的结果
/// </summary>
public int[] thicks_map;
/// <summary>
/// 对应bulkdata 的数据, -1, 没有对应的bookmark，因为从来都没数据
/// </summary>
public int bookmark=-1;
/// <summary>
/// 锁定 bookmark，只要解过一次方程，bookmark 就会被锁定，不能再修改
/// </summary>
public bool lockbm = false;
public class SolveQuickResult
{
/// <summary>
/// 新得到数据开始序号
/// </summary>
public int start_index;
/// <summary>
/// 新得到数据长度,这是一个环形队列
/// </summary>
public int len=0;
}
/// <summary>
/// 快速解方程
/// </summary>
/// <param name="org_thicks">上一幅完成的数据</param>
/// <param name="power">上一幅图所占的权重,当前只占1</param>
/// <returns></returns>
public SolveQuickResult SolveQuick(int[] org_thicks, int power)
{
List<int> updateboltindex = new List<int>();
for (int i = IndexOfToSolveEquationQuick; i < equationList.Count; i++, IndexOfToSolveEquationQuick++)
{
EquationCell equation = equationList[i];
int mainpower = equation.boltPower[equation.mainBolt];
double sum = 0;
for (int j = 0; j < equation.boltPower.Count; j++)
{
int boltindex = equation.boltPower.Keys.ElementAt(j);
if (boltindex != equation.mainBolt)
{
if (org_thicks == null)
{
mainpower += equation.boltPower[boltindex];
}
else if (!Misc.MyBase.ISVALIDATA(org_thicks[boltindex]))
{
mainpower += equation.boltPower[boltindex];
}
else
{
sum += equation.boltPower[boltindex] * org_thicks[boltindex];
}
}
}
int mainBolt_value = (org_thicks != null)? org_thicks[equation.mainBolt]:Misc.MyBase.NULL_VALUE;
if (Misc.MyBase.ISVALIDATA(mainBolt_value))
{
thicks[equation.mainBolt] = (mainBolt_value * power + (int)((equation.thick - sum) / mainpower)) / (power + 1);
}
else
{
thicks[equation.mainBolt] = (int)((equation.thick - sum) / mainpower);
}
updateboltindex.Add(equation.mainBolt);
}
SolveQuickResult result = new SolveQuickResult();
if (updateboltindex.Count > 0)
{
result.start_index = updateboltindex.Min();
result.len = updateboltindex.Max() - updateboltindex.Min() + 1;
}
return result;
}
}
/// <summary>
/// 每次扫描的数据,
/// 不是每一幅数据都能解出方程，
/// 因为要连续3幅才能解出方程
/// </summary>
private RList<ScanInfoCell> mScanInfoList;
/// <summary>
/// 与 mScanInfoList 基本一样
/// </summary>
private RList<FlyData_BlowingScan> mBufList;
#region ISaveToXml
public string[] GetSavePropertyNames()
{
return new string[]{
"ChannelCnt",
"BPC",
"OrgBoltNo",
"SolveCnt",
"Smooth",
"SensorWidth",
"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>
/// 人字架复位时,对应的螺丝号，0° 对应的 螺丝号
/// </summary>
public int OrgBoltNo { get; set; } = 1;
private int smooth = 1;
/// <summary>
/// 平滑
/// </summary>
public int Smooth
{
get { return smooth; }
set
{
if (value < 0)
value = 0;
if (smooth != value)
{
smooth = value;
}
}
}
/// <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;
}
}
}
}
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;
}
/// <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;
}
}
#endregion
/// <summary>
/// 应用
/// </summary>
public void Apply()
{
Save();
}
/// <summary>
/// 扫描一次推送事件
/// </summary>
public event RenZiJiaDataEventHandler DataEvent;
#endregion
/// <summary>
/// 缓冲区第一个记录序号
/// </summary>
public int FirstBM { get; set; } = -1;
/// <summary>
/// 缓冲区最后一个记录序号
/// </summary>
public int LastBM { get; protected set; } = -1;
private int sensorwidth = 250;
/// <summary>
/// 探头宽度，用于解方程，可以与实际不符合 单位脉冲
/// </summary>
public int SensorWidth
{
get { return sensorwidth; }
set
{
if (value < 1)
value = 1;
if (sensorwidth != value)
{
sensorwidth = value;
}
}
}
private int solvecnt = 4;
/// <summary>
/// 多少次扫描解一次方程
/// </summary>
public int SolveCnt
{
get { return solvecnt; }
set
{
if (value < 3)
value = 3;
if (solvecnt != value)
{
solvecnt = 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 (SolveCnt > 20)
{
SolveCnt = 5;
}
if (!checkParamErr_map(Map))
{
IsUsedMap = false;
Map = new List<BoltMapCell>();
}
}
static GM_BlowingScan()
{
Misc.SaveToXmlHepler.Regist(typeof(BoltMapCell));
}
/// <summary>
///
/// </summary>
/// <param name="flyad"></param>
/// <param name="gsample"></param>
public GM_BlowingScan(FlyAD7 flyad, GSample gsample)
: base(flyad, gsample)
{
mPDetect = new BlowingDetect();
mScanInfoList = new RList<ScanInfoCell>(30);
mBufList = new RList<FlyData_BlowingScan>(100);
mScanPosDetect = new ScanPosDetect();
ChannelCnt = 44;//加热棒数量
BPC = 2;//分区数量/加热棒数量
OrgBoltNo = 10;//复位时，测厚仪对应的螺丝号
SolveCnt = 5;
mPDetect.Load();
Load();
//检测参数
mPDetect.CheckParamErr();
checkParamErr();
if (SolveCnt < 3)
SolveCnt = 3;
PropertyChanged+=new PropertyChangedEventHandler(RenZiJiaScan_PropertyChanged);
mPDetect.PropertyChanged += (s, e) =>
{
NotifyPropertyChanged(e.PropertyName);
};
mPDetect.FilmInfoChangedEvent += new BlowingDetect.FilmInfoChangedEventHandler(mPDetect_FilmInfoChangedEvent);
mPDetect.ClearEvent += new BlowingDetect.ClearEventHandler(mPDetect_ClearEvent);
mPDetect.Init(mFlyAD);
mScanPosDetect.Init(mFlyAD);
ScanCnt = -1;
}
bool Load()
{
return Misc.SaveToXmlHepler.Load("renzijiascan.xml", this);
}
void Save()
{
Misc.SaveToXmlHepler.Save("renzijiascan.xml", this);
}
/// <summary>
///
/// </summary>
/// <param name="bulkdata"></param>
/// <param name="borderSearch"></param>
/// <param name="dynArea"></param>
/// <param name="func_ad2thick"></param>
/// <param name="profileParam"></param>
/// <param name="historyDb"></param>
/// <param name="bulkDb"></param>
public void Init(
IBulkDataServiceAdd bulkdata,
BorderSearch borderSearch,
DynArea dynArea,
AD2ThickHandler func_ad2thick,
BlowingProfileParam profileParam,
HistoryDb historyDb, BulkDb bulkDb
)
{
AD2Thick = func_ad2thick;
mBulkData = bulkdata;
mBorderSearch = borderSearch;
mDynArea = dynArea;
mProfileParam = profileParam;
mHistoryDb = historyDb;
mBulkDb = bulkDb;
//接收PollScan的推送
DataPosEvent += new EndEventHandler(pollScan_DataPosEvent);
EndEvent += new EndEventHandler(pollScan_EndEvent);
//记录调试数据
MarkDebugInit();
}
#region 记录原始数据
DateTime markdebug_dt = DateTime.MinValue;
int markdebug_lastBm = -1;
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.GetBufList((asyncState, retData) =>
{
var reponse = retData as GetBufListReponse;
var cells = reponse.datas;
if (cells.Count() == 0)
{
//没有数据
markdebug_lastBm = reponse.lastbm;
return;
}
int new_cnt = reponse.lastbm - markdebug_lastBm;
if (new_cnt > cells.Count())
new_cnt = cells.Count();
markdebug_lastBm = reponse.lastbm;
if (new_cnt <= 0)
return;
List<Model.Lc_OrgScanData> lc_OrgScanDatas = new List<Model.Lc_OrgScanData>();
for (int i = 0; i < new_cnt; i++)
{
int index = reponse.datas.Count() - new_cnt + i;
var data = reponse.datas[index];
var times = data.ThicksDt.Where(dt => dt != DateTime.MinValue);
if (times.Count() == 0)
continue;
Model.Lc_OrgScanData lcOrgScanData = new Model.Lc_OrgScanData();
lcOrgScanData.Time = times.Min();
lcOrgScanData.FilmBegin = data.FilmRange.Begin;
lcOrgScanData.FilmEnd = data.FilmRange.End;
lcOrgScanData.PosOfGrid = data.PosOfGrid;
lcOrgScanData.K = mProfileParam.K;
lcOrgScanData.Thicks = ToRealThicks(data.Thicks);
lcOrgScanData.ThicksDt = data.ThicksDt;
lc_OrgScanDatas.Add(lcOrgScanData);
}
mHistoryDb.AddOrgScanDatas(lc_OrgScanDatas);
}, null);
markdebug_dt = DateTime.Now;
},
TimeSpan.FromMinutes(1));
}
#endregion
double[] ToRealThicks(IEnumerable<int> frame)
{
return frame.Select(t =>
{
if (Misc.MyBase.ISVALIDATA(t))
return t / 100.0;
else
return double.NaN;
}).ToArray();
}
void RenZiJiaScan_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "NBolts")
{
//所有数据删除
mScanInfoList.Clear();
//TODO!!!!!
//停下来
}
}
void mPDetect_FilmInfoChangedEvent(object sender, BlowingDetect.FilmInfoChangedEventArgs e)
{
// 找到 e.Time 对应的 scaninfo
for (int i = 0; i < mScanInfoList.Count; i++)
{
ScanInfoCell scaninfo = mScanInfoList[i];
if (scaninfo.IndexOfToGetTime > 0)
{
DateTime dt_start = scaninfo.frame[0].dt;
DateTime dt_end = scaninfo.frame[scaninfo.IndexOfToGetTime-1].dt;
if (e.Time < dt_end)//找到了
{
for (int j = i; j < mScanInfoList.Count; j++)
{
scaninfo = mScanInfoList[j];
scaninfo.IndexOfToGetAngle = 0;
}
return;
}
}
}
}
void mPDetect_ClearEvent(object sender)
{
//已经很久没数据，清空全部！！！！！！！
//scanposdetect
mScanPosDetect.ScanNo = ScanNo;
if (mScanInfoList.Count > 0)
{
mScanInfoList.Clear();
//scaninfo
ScanInfoCell scaninfo = new ScanInfoCell(ScanNo, NBolts);
//scaninfo.bookmark = bookmark;
mScanInfoList.Add(scaninfo);
}
}
#region 1.grid 数据 转 ScanPosCell.(pos,thick) 放入 mScanInfoList.Last()
/// <summary>
/// 动态获取！！！！
/// </summary>
/// <param name="obj"></param>
/// <param name="e"></param>
void pollScan_DataPosEvent(object obj, FlyADBase.MiniGridEventArgs e)
{
DIRECTION direction = e.direction;
int posOfGrid = e.posOfGrid;
int start_idx = e.grid_start;
int start_pos = e.grid_start * e.posOfGrid;
int[] dat = e.buf;
//-------------------------------------
//DIR
mDynArea.Direction = direction;
mDynArea.AD = dat[0];
mDynArea.Thick = AD2Thick(dat[0]);
if (mScanInfoList.Count == 0)
return;
ScanInfoCell scaninfocell = mScanInfoList.Last();
if (scaninfocell.width <= 0)
{
//刚开始，连膜边都还没找到
return;
}
//找边界前，要对数据进行校正
//尽可能不要两个边的数据，N2是边界向内减, 只是不要更多的数据而已
int bp = scaninfocell.beginPos + mBorderSearch.N2;
int ep = scaninfocell.endPos - mBorderSearch.N2;
//对应的grid号
int bp_idx = bp / posOfGrid;
int ep_idx = ep / posOfGrid;
if(bp_idx < start_idx)
bp_idx = start_idx;
if(ep_idx > (start_idx+dat.Length-1))
ep_idx = start_idx+dat.Length-1;
for (int i = bp_idx; i <= ep_idx; i++)
{
int idx = i - start_idx;
int pos = i * posOfGrid + posOfGrid / 2;//一个grid的中间脉冲，也就是大概而已
int thick = Misc.MyBase.NULL_VALUE;
if (Misc.MyBase.ISVALIDATA(dat[idx]))
thick = AD2Thick(dat[idx])*2;
pos -= scaninfocell.beginPos;//膜上面的位置
scaninfocell.frame.Add(new ScanPosCell() { pos = pos, thick = thick });
}
OnPoll_GetTime2();
}
void pollScan_EndEvent(object obj, FlyADBase.MiniGridEventArgs e)
{
DIRECTION direction = e.direction;
int posOfGrid = e.posOfGrid;
int start_idx = e.grid_start;
int start_pos = e.grid_start * e.posOfGrid;
int[] dat = e.buf;
//int scaninfo_idx = mScanInfoList.FindIndex(sil => sil.IndexOfToGetTime < sil.frame.Count);
//if ((scaninfo_idx>0) && (mScanInfoList.Count - scaninfo_idx > 1) )
//{
// //有问题
//}
ScanNo++;
mScanPosDetect.ScanNo = ScanNo;
if(gsample.Samples[0].AD <= 0)
{
//无温修AD
if (mScanInfoList.Count == 0)
return;
ScanInfoCell scaninfo = mScanInfoList.Last();
if (scaninfo.bookmark != -1)
mBulkData.ChangeEmply(scaninfo.bookmark);
scaninfo.Reset(ScanNo);
return;
}
//找边界
bool ret = mBorderSearch.FindFilm(direction, posOfGrid, start_idx, dat);
if (!ret)//不能找到边界！！！没膜！！！！
{
mBorderSearch.Init();
}
//设置扫描范围
//POLLSCAN----------------------------------------
Range scanrange = mBorderSearch.GetScanRange();
ScanStart = scanrange.Begin;// beginPos;
ScanEnd = scanrange.End;// endPos;
if (!ret)
{
if (mScanInfoList.Count == 0)
return;
ScanInfoCell scaninfo = mScanInfoList.Last();
if (scaninfo.bookmark != -1)
mBulkData.ChangeEmply(scaninfo.bookmark);
scaninfo.Reset(ScanNo);
return;
}
//必须设置好 mBorderSearch.SensorWidth，它就是探头直径
Range border = mBorderSearch.GetBorder(direction);
if (mScanInfoList.Count == 0)//安全检查，不可能发生的！！！！！
return;
ScanInfoCell scaninfocell = mScanInfoList.Last();
//膜宽，和位置一起计算旋转架上的角度
scaninfocell.Reset_IsFull(border.Begin, border.End);
//尽可能不要两个边的数据，N2是边界向内减, 只是不要更多的数据而已
Range boltrange = mBorderSearch.GetBoltRange(direction);
//对应的grid号
int bp_idx = boltrange.Begin / posOfGrid;
int ep_idx = boltrange.End / posOfGrid;
if (bp_idx < start_idx)
bp_idx = start_idx;
if (ep_idx > (start_idx + dat.Length - 1))
ep_idx = start_idx + dat.Length - 1;
for (int i = bp_idx; i <= ep_idx; i++)
{
int idx = i - start_idx;
int pos = i * posOfGrid + posOfGrid / 2;//一个grid的中间脉冲，也就是大概而已
int thick = Misc.MyBase.NULL_VALUE;
if (Misc.MyBase.ISVALIDATA(dat[idx]))
thick = AD2Thick(dat[idx]) * 2;
pos -= border.Begin;//膜上面的位置
scaninfocell.frame.Add(new ScanPosCell() { pos = pos, thick = thick });
}
//或取每个数据对应的时间点
OnPoll_GetTime2();
//把扫描数据放多一份到 mBufList
PushToBufList(e, border, scaninfocell.ScanNo);
//插入纵向数据
#region sqlite3 历史数据保存
{
List<double> boltValues = new List<double>();
double boltwidth = scaninfocell.width * 1.0 / (NBolts / 2);
int boltIdx = 0;
double boltSum = 0;
int boltCnt = 0;
for (int i = 0; i < scaninfocell.frame.Count(); i++)
{
int idx = (int)(scaninfocell.frame[i].pos / boltwidth);
if (boltIdx != idx)
{
if (boltCnt > 0)
{
boltValues.Add(boltSum / boltCnt);
boltSum = 0;
boltCnt = 0;
}
}
boltIdx = idx;
if (Misc.MyBase.ISVALIDATA(scaninfocell.frame[i].thick))
{
boltSum += scaninfocell.frame[i].thick / 2 / 100.0;
boltCnt++;
}
}
if (boltCnt > 0)
{
boltValues.Add(boltSum / boltCnt);
boltSum = 0;
boltCnt = 0;
}
mHistoryDb.AddTrendData(new Lc_TrendData()
{
Time = DateTime.Now,
K = mProfileParam.K,
Thicks = boltValues.ToArray()
});
}
#endregion
//创建一个新的 scaninfocell
//为下一趟即时扫描作准备
scaninfocell = new ScanInfoCell(ScanNo,NBolts);
direction = (direction == DIRECTION.FORWARD) ? DIRECTION.BACKWARD : DIRECTION.FORWARD;
border = mBorderSearch.GetBorder(direction);
scaninfocell.beginPos = border.Begin;
scaninfocell.endPos = border.End;
scaninfocell.width = border.Width;//膜宽
scaninfocell.IsFull = false;
mScanInfoList.RAdd(scaninfocell);
}
void PushToBufList(MiniGridEventArgs e, Range border, int scanNo)
{
DIRECTION direction = e.direction;
int posOfGrid = e.posOfGrid;
int start_idx = e.grid_start;
int start_pos = e.grid_start * e.posOfGrid;
int[] dat = e.buf;
FlyData_BlowingScan f = new FlyData_BlowingScan();
f.FilmRange = border;
f.PosOfGrid = posOfGrid;
f.Thicks = new int[mFlyAD.PosLen/ posOfGrid];
f.ThicksDt = new DateTime[f.Thicks.Count()];
//对应的grid号
for (int i = 0; i < f.Thicks.Count(); i++)
{
int idx = i - start_idx;
int pos = i * posOfGrid + posOfGrid / 2;//一个grid的中间脉冲，也就是大概而已
int thick = Misc.MyBase.NULL_VALUE;
if (idx >= 0 && idx < dat.Count())
{
if (Misc.MyBase.ISVALIDATA(dat[idx]))
thick = AD2Thick(dat[idx]) * 2;
}
f.Thicks[i] = thick;
DateTime dt = DateTime.MinValue;
if (Misc.MyBase.ISVALIDATA(thick))
{
int ret = mScanPosDetect.GetTime(pos, scanNo, out dt);
}
f.ThicksDt[i] = dt;
}
f.RotateCnt = mPDetect.RotationCnt;
if (mPDetect.mLimitList.Count() > 0)
{
LimitCell lc = mPDetect.mLimitList.Last();
f.SignNo = lc.no;
f.Time = lc.dt_begin;
f.LeaveTime = lc.dt_end;
}
else
{
f.SignNo = -1;
f.Time = DateTime.MinValue;
f.LeaveTime = DateTime.MinValue;
}
f.LimitSignTime = mPDetect.LimitSignTime;
f.RotatePeriod = mPDetect.RenZiJiaPeriod;
f.Velocity = mPDetect.FilmVelocity;
mBufList.RAdd(f);
FirstBM = mBufList.Index2No(0);
LastBM = mBufList.GetLastNo();
}
#endregion
#region 2.填入 ScanPosCell.(dt)
/// <summary>
/// 找到一幅数据，每个grid 对应的时间点
/// </summary>
void OnPoll_GetTime2()
{
ScanInfoCell scaninfo = mScanInfoList.Last();
for (; scaninfo.IndexOfToGetTime < scaninfo.frame.Count; scaninfo.IndexOfToGetTime++)
{
int i = scaninfo.IndexOfToGetTime;
ScanPosCell scanpos = scaninfo.frame[i];
//还原为机架位置
int pos = scaninfo.beginPos + scanpos.pos;
DateTime dt;
int ret = mScanPosDetect.GetTime(pos, scaninfo.ScanNo, out dt);
if (ret == -2)
{
//发生在过去，不正常
}
else if (ret == 1)//这个是未来的，等下一次Poll
{
return;
}
else if (dt == DateTime.MinValue)
{
//出错， 把scaninfo 删除掉
//mScanInfoList.RemoveAt(scaninfo_idx);
//scaninfo_idx--;
break;
}
//成功获取
scanpos.dt = dt;
if (i == 0)
{
scaninfo.StartTime = dt;
scaninfo.thicks_dt = dt;
}
scaninfo.EndTime = dt;
}
}
#endregion
#region 3.填入 ScanPosCell.(angle1,angle2), 且转为 Equation
void OnPoll_GetAngle()
{
int scaninfo_idx = mScanInfoList.FindIndex(
sil =>
(sil.IndexOfToGetAngle < sil.IndexOfToGetTime));
if (scaninfo_idx == -1)
{
return;//全部都转换完成！！
}
while (true)
{
ScanInfoCell scaninfo = mScanInfoList[scaninfo_idx];
ScanInfoCell.GetAngleResult result = scaninfo.GetAngle(mPDetect, OrgBoltNo, SensorWidth);
if (result == ScanInfoCell.GetAngleResult.NothingToDo)
{
//getangle 失败，发生在未来，等下一次Poll
break;
}
//解方程，画数据！！
ToThicks(scaninfo_idx);
//全部GetAngle 成功，下一个scaninfo
scaninfo_idx++;
if (scaninfo_idx >= mScanInfoList.Count)
break;//已经没有了
}
}
class CalSolveCnt
{
List<int> list = new List<int>();
const int listcap = 5;
void Add(int cnt)
{
list.Add(cnt);
if (list.Count > listcap)
list.RemoveAt(0);
}
public int Max()
{
if (list.Count > 0)
return list.Max();
else
return 4;
}
Misc.DIRECTION direction = DIRECTION.FIX;
int cnt = 0;
public bool Check(Misc.DIRECTION direction)
{
if (this.direction != direction)
{
if((this.direction!=Misc.DIRECTION.FIX) && (cnt>3))
Add(cnt);
cnt = 0;
}
cnt++;
this.direction = direction;
return OK();
}
public bool OK()
{
if (list.Count >= listcap)
{
return true;
}
return false;
}
}
CalSolveCnt mCalSolveCnt = new CalSolveCnt();
bool ToThicks_SolveEquation(int scaninfo_idx)
{
ScanInfoCell scaninfo = mScanInfoList[scaninfo_idx];
if (scaninfo.Direction == DIRECTION.FIX)//当前是Fix 不解方程
return false;
//解方程数量检测，免得一直数量不足，解不了方程
//if (mCalSolveCnt.Check(scaninfo.Direction))
//{
// if (SolveCnt > (mCalSolveCnt.Max()-1))
// {
// SolveCnt = (mCalSolveCnt.Max() - 1);
// }
//}
if (scaninfo_idx < (SolveCnt - 1))
return false;
//全部方向都必须一致，当然也不能是Fix
//for (int i = 0; i < (SolveCnt - 1); i++)
//{
// if (scaninfo.Direction != mScanInfoList[scaninfo_idx - 1 - i].Direction)
// return false;
//}
int avg = scaninfo.GetAvg();
if (!Misc.MyBase.ISVALIDATA(avg))//平均值不合法！！！！
return false;
if (avg < 500)//值太小！！！
return false;
List<EquationCell> equationlist = new List<EquationCell>();
////全部平均值相差不能超过 5%
//for (int i = 0; i < SolveCnt; i++)
//{
// int a = mScanInfoList[scaninfo_idx - 1 - i].GetAvg();
// if (Math.Abs((a - avg) / avg) > 0.05)
// return false;
// equationlist.AddRange(mScanInfoList[scaninfo_idx - i].equationList);
//}
int cnt = 0;
for (int i = scaninfo_idx; i >=0; i--)
{
if (mScanInfoList[i].Direction == DIRECTION.FIX)
continue;
cnt++;
double a = mScanInfoList[i].GetAvg();
double p = (a - avg) / avg;
if (Math.Abs(p) > 0.05)
return false;
equationlist.AddRange(mScanInfoList[i].equationList);
if (cnt >= SolveCnt)
break;
}
if (cnt < SolveCnt)//方程不够！！！！
return false;
if (equationlist.Count < 100)//方程数太少
return false;
//2105 条方程，耗时 0.3s
SolveEquation(mScanInfoList[scaninfo_idx].thicks, equationlist);
//不能有任何一个NULL_VALUE
for (int i = 0; i < scaninfo.thicks.Count(); i++)
{
if (scaninfo.thicks[i] > 1000000)
return false;
if (scaninfo.thicks[i] < -10000)
return false;
}
//检测
{
int sigma = Misc.MyMath.Sigma(scaninfo.thicks);
int avg2 = Misc.MyMath.Avg(scaninfo.thicks);
double p = 1.0 * (avg2 - avg) / avg;
if (Math.Abs(p) > 0.05)//变化太大，不可能！！！
return false;
p = 1.0 * sigma / avg2;
if (Math.Abs(p) > 0.5) //波动太大,异常
return false;
}
//最后处理，滤波，平滑
if (Smooth > 0)
{
int[] data = new int[scaninfo.thicks.Count()];
for (int i = 0; i < scaninfo.thicks.Count(); i++)
{
int sum = 0;
for (int j = 0; j < (Smooth * 2 + 1); j++)
{
int index = i + j - Smooth;
if (index < 0)
index += scaninfo.thicks.Count();
else if (index >= scaninfo.thicks.Count())
index -= scaninfo.thicks.Count();
sum += scaninfo.thicks[index];
}
data[i] = (int)(sum / (Smooth * 2 + 1));
}
Array.Copy(data, scaninfo.thicks, data.Count());
}
scaninfo.thicks_dt = mScanInfoList[scaninfo_idx - (SolveCnt-1)].StartTime;
return true;
}
enum BindingMotion
{
Add,
Remove
}
void BookmarkRestartToBinding(int scaninfo_idx, BindingMotion motion)
{
if (motion == BindingMotion.Add)
{
if (mScanInfoList[scaninfo_idx].bookmark == -1)
{
int bookmark = mScanInfoList[scaninfo_idx].bookmark;
mBulkData.ChangeEmply(bookmark);
//删除与 bulkdata 关系
mScanInfoList[scaninfo_idx].bookmark = -1;
for (int i = mScanInfoList.Count()-1;i>(scaninfo_idx + 1); i--)
{
if (mScanInfoList[i].bookmark != -1)
{
int tmp = bookmark;
bookmark = mScanInfoList[i].bookmark;
mScanInfoList[i].bookmark = tmp;
}
}
}
}
else
{
if (mScanInfoList[scaninfo_idx].bookmark != -1)
{
int bookmark = mScanInfoList[scaninfo_idx].bookmark;
mBulkData.ChangeEmply(bookmark);
//删除与 bulkdata 关系
mScanInfoList[scaninfo_idx].bookmark = -1;
for (int i = scaninfo_idx + 1; i < mScanInfoList.Count(); i++)
{
if (mScanInfoList[i].bookmark != -1)
{
int tmp = bookmark;
bookmark = mScanInfoList[i].bookmark;
mScanInfoList[i].bookmark = tmp;
}
}
}
}
}
FR_DATA_TYPE Direction2FR_DATA_TYPE(Misc.DIRECTION direction)
{
if (direction == DIRECTION.FORWARD)
return FR_DATA_TYPE.INVALID;
else
return FR_DATA_TYPE.VALID;
}
bool ToThicks(int scaninfo_idx)
{
ScanInfoCell scaninfo = mScanInfoList[scaninfo_idx];
if (scaninfo.IsFull)//所有grid数据都获取完，解方程
{
if (scaninfo.lockbm)
{
//不需要再解方程，算thicks 的值！！！
return false;
}
if (ToThicks_SolveEquation(scaninfo_idx))
{
//解方程成功
if (scaninfo.bookmark == -1)
scaninfo.bookmark = GetFreeBm();
//重新分区
if (IsNeedMap())
{
Dictionary<int, int> map = new Dictionary<int, int>();
for (int i = 0; i < Map.Count(); i++)
map.Add(Map[i].OldNo - 1, Map[i].NewNo - 1);
scaninfo.thicks_map = Misc.MyMath.Map(scaninfo.thicks, map);
}
//更新数据库内容
{
int[] frame;
List<BoltMapCell> map;
if (IsNeedMap())
{
frame = scaninfo.thicks_map;
map = new List<BoltMapCell>();
foreach (var m in Map)
map.Add(m.Clone());
}
else
{
frame = scaninfo.thicks;
map = null;
}
var realthicks = ToRealThicks(frame);
var renZiJiaDataEventArgs = new RenZiJiaDataEventArgs()
{
Time = scaninfo.thicks_dt,
EndTime = scaninfo.EndTime,
IsBackw = scaninfo.Direction == DIRECTION.BACKWARD,
RPeriod = mPDetect.RenZiJiaPeriod,
RCnt = mPDetect.RotationCnt,
OrgBoltNo = OrgBoltNo,
RAngle = mPDetect.RAngle,
FilmLength = mPDetect.FilmLength,
FilmVelocity = mPDetect.FilmVelocity,
K = mProfileParam.K,
Thicks = realthicks,
Boltmap = map
};
DataEvent?.Invoke(this, renZiJiaDataEventArgs);
//TODO 需要检查是否重复写入了！！！！！
#region sqlite3 历史数据保存
var lc_scandata = Lc_AutoMapperProfile.Mapper.Map<Lc_ScanData>(renZiJiaDataEventArgs);
mHistoryDb.AddScanData(lc_scandata);
#endregion
}
int[] thicks = IsNeedMap()? scaninfo.thicks_map:scaninfo.thicks;
if (scaninfo.bookmark == -1)
{
scaninfo.bookmark = mBulkData.Add(thicks, Direction2FR_DATA_TYPE(scaninfo.Direction), scaninfo.thicks_dt);
}
else
{
mBulkData.Change(scaninfo.bookmark, 0, thicks, Direction2FR_DATA_TYPE(scaninfo.Direction), scaninfo.thicks_dt);
}
mBulkData.Save();
}
else
{
//失败，删除！！！
for (int i = 0; i < scaninfo.thicks.Count(); i++)
scaninfo.thicks[i] = Misc.MyBase.NULL_VALUE;
if (scaninfo.bookmark != -1)
{
mBulkData.ChangeEmply(scaninfo.bookmark);
SetFreeBm(scaninfo.bookmark);
scaninfo.bookmark = -1;
}
}
scaninfo.lockbm = true;
return true;
}
else
{
//还没获取完所有grid, 简易解方程，只认为 mainBolt 是未知的，其它都是已知的,用上一幅数据的值
//这样的数据不需要放在数据库中！！！！！！
int[] org_thick = null;
if (scaninfo_idx != 0)
org_thick = mScanInfoList[scaninfo_idx - 1].thicks;
ScanInfoCell.SolveQuickResult result = scaninfo.SolveQuick(org_thick,SolveCnt-1);
if (result.len > 0)
{
//如果scaninfo.bookmark ==-1 ,也就是没有对应的 bulkdata 数据，创建一个
//先从freebm 获取，不行再创建新的
if (scaninfo.bookmark == -1)
scaninfo.bookmark = GetFreeBm();
if (scaninfo.bookmark == -1)
scaninfo.bookmark = mBulkData.AddEmply();
int[] thicks = scaninfo.thicks.Where((t, i) => (i >= result.start_index && i < (result.start_index + result.len))).ToArray();
mBulkData.Change(
scaninfo.bookmark,
result.start_index, thicks, Direction2FR_DATA_TYPE(scaninfo.Direction), scaninfo.thicks_dt);
mBulkDb.SetTempFrame(0, ToRealThicks(thicks));
}
}
return false;
}
/// <summary>
/// 解方程
/// </summary>
/// <param name="equationList">N条方程</param>
/// <param name="frame_out">输出的结果</param>
void SolveEquation(int[] frame_out, List<EquationCell> equationList)
{
int nrow = equationList.Count();
//A~AX = A~B
//转换为 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 (EquationCell ec in equationList)
{
double[] datas = ec.GetPower(NBolts);
matrixA.SetRow(rowindex, datas);
matrixAT.SetColumn(rowindex, datas);
vectorB[rowindex] = ec.thick;
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++)
{
frame_out[i] = (int)X[i];
}
}
#endregion
/// <summary>
/// 开始扫描
/// </summary>
/// <returns></returns>
public override bool Start()
{
bool b = base.Start();
if (!b)
return false;
//设置扫描范围
int beginPos, endPos;
mBorderSearch.Init();
mBorderSearch.GetScanRange(out beginPos, out endPos);
ScanNo++;
//scanposdetect
mScanPosDetect.ScanNo = ScanNo;
//scaninfo
ScanInfoCell scaninfo = new ScanInfoCell(ScanNo, NBolts);
mScanInfoList.Add(scaninfo);
mBulkData.InitPush();
//清空临时数据
mBulkDb.SetTempFrame(0, null);
#region sqlite3 历史数据保存
CheckProfile();
mProfileParam.PropertyChanged += MProfileParam_PropertyChanged;
#endregion
return base.Start2(beginPos, endPos);
}
#region sqlite3 历史数据保存
string[] profile_propertynames_add = new string[]{
"PName",
"OrderNo",
"Number"
};
string[] profile_propertynames_update = new string[]{
"Target",
"TolerancePercent"
};
/// <summary>
/// 检查产品信息更新情况，是否需要新加单，或者更新单信息
/// </summary>
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
/// <summary>
/// 停止扫描
/// </summary>
public override void Stop()
{
#region sqlite3 历史数据保存
mProfileParam.PropertyChanged -= MProfileParam_PropertyChanged;
#endregion
base.Stop();
//已经停止
//删除全部
mScanInfoList.Clear();
}
/// <summary>
/// 周期动作处理
/// </summary>
protected override void OnPoll()
{
base.OnPoll();
OnPoll_GetAngle();
}
/// <summary>
/// 获取 缓冲区列表
/// </summary>
/// <param name="AsyncDelegate">retData 为 </param>
/// <param name="AsyncState"></param>
public void GetBufList(AsyncCBHandler AsyncDelegate, object AsyncState)
{
GetBufListReponse p = new GetBufListReponse();
p.lastbm = LastBM;
p.firstbm = FirstBM;
p.datas = mBufList;
AsyncDelegate(AsyncState, p);
}
}
/// <summary>
/// 扫描位置检测
/// 里面的列表会缓存一些旧数据，如1次扫描前的位置信息。
/// 什么时候删除，由ScanPosDetect 自行决定，使用者不用关心
/// </summary>
public class ScanPosDetect
{
/// <summary>
/// IOStatus 推送出来扫描位置与时间
/// </summary>
class PosCell
{
public DateTime dt;
public int position;
public override string ToString()
{
return dt.ToString() + " pos=" + position.ToString();
}
}
class PosCellList
{
public int scanNo;
private List<PosCell> mPosList = new List<PosCell>();
public void Add(int position, DateTime dt)
{
if (mPosList.Count() > 0)
{
if (mPosList.Last().position == position)
{
mPosList.Last().dt = dt;
return;
}
}
mPosList.Add(new PosCell() { position = position, dt = dt });
}
private DateTime GetTime(int position, int idx)
{
double d_pos = mPosList[idx].position - mPosList[idx + 1].position;
TimeSpan ts = mPosList[idx].dt - mPosList[idx + 1].dt;
long ticks = (long)((position - mPosList[idx + 1].position) / d_pos * ts.Ticks);
return mPosList[idx + 1].dt + new TimeSpan(ticks);
}
/// <summary>
/// 获取位置对应的数据点.
/// 返回
/// -1:position在列表的前面;
/// 0:position在列表的里面
/// 1:position在列表的后面
/// </summary>
/// <param name="position"></param>
/// <param name="dt"></param>
/// <returns></returns>
public int GetTime(int position, out DateTime dt)
{
dt = DateTime.MinValue;
//TODO
if (mPosList.Count < 2)
return -1;
//通过列表最前面的数据，与最后面的数据，确认方向
DIRECTION direction;
if (mPosList.First().position < mPosList.Last().position)
direction = DIRECTION.FORWARD;
else
direction = DIRECTION.BACKWARD;
int idx;
if (direction == DIRECTION.FORWARD)
{
idx = mPosList.FindIndex(p => position <= p.position);
}
else
{
idx = mPosList.FindIndex(p => position >= p.position);
}
if (idx == -1)
{
//在列表后面
dt = GetTime(position, mPosList.Count - 2);
return 1;
}
else if (idx == 0)
{
//在列表前面
dt = GetTime(position, 0);
return -1;
}
else
{
//在列表里面
dt = GetTime(position, idx - 1);
return 0;
}
}
}
//TODO
private List<PosCellList> mPosLists = new List<PosCellList>();
private int lastGetTimeScanNo=-1;
private int scanNo;//当前扫描号。每扫描一次，scanNo++
public int ScanNo
{
get {
return scanNo;
}
set {
if (scanNo != value)
{
//Clear(ScanNo, -2);
scanNo = value;
}
}
}
/// <summary>
/// 删除scanNo 偏移 offset 之前的数据
/// </summary>
/// <param name="scanNo"></param>
/// <param name="offset"></param>
public void Clear(int scanNo,int offset)
{
if (mPosLists.Count == 0)//没数据
return;
int index = mPosLists.FindIndex(pl => pl.scanNo == scanNo);
if (index == -1)
return;//可能还没出现
index += offset;
if (index < 0)
return;//没有之前的数据
mPosLists.RemoveRange(0, index + 1);
}
public void Clear()
{
mPosLists.Clear();
}
public ScanPosDetect()
{
}
public void Init(IFlyAD flyad)
{
flyad.IStatusChangedEvent += new IStatusChangedEventHandler(flyad_IStatusChangedEvent);
}
void flyad_IStatusChangedEvent(object sender, IStatusChangedEventArgs e)
{
PosCellList poslist;
if (mPosLists.Count == 0)
mPosLists.Add(new PosCellList() { scanNo = ScanNo });
else
{
poslist = mPosLists.Last();
if (poslist.scanNo != ScanNo)
{
mPosLists.Add(new PosCellList() { scanNo = ScanNo });
}
}
poslist = mPosLists.Last();
poslist.Add(e.Position,e.Time);
//保持20个
//if (mPosLists.Count() > 20)
//{
// mPosLists.RemoveAt(0);
//}
}
/// <summary>
/// 获取pos 对应的时间;
/// 返回 -1 数据在 列表前;
/// 返回 0 数据在列表内;
/// 返回 1 数据在列表外;
/// </summary>
/// <param name="position">位置</param>
/// <param name="scanNo">扫描号</param>
/// <returns></returns>
public int GetTime(int position, int scanNo, out DateTime dt)
{
if (lastGetTimeScanNo != scanNo)
{
//TODO
Clear(lastGetTimeScanNo, -8);
lastGetTimeScanNo = scanNo;
}
dt = DateTime.MinValue;
if (mPosLists.Count == 0)//没数据
return 1;
int d = scanNo - mPosLists[0].scanNo;
if (d < 0)
{
//发生在过去
//不正常
return -2;
}
int index = mPosLists.FindIndex(pl => pl.scanNo == scanNo);
if (index == -1)
return 1;//可能还没出现
PosCellList poslist = mPosLists[index];
int ret = poslist.GetTime(position, out dt);
if( (ret == 1) && (index != (mPosLists.Count - 1)))
return 0;
else if( (ret == -1) && (index != 0))
return 0;
else
return ret;
}
}
}