/// <summary>
/// Add a tag to the database using <paramref name="tag"/> as the root tag
/// </summary>
/// <param name="tag">Tag to use as the root tag when adding <paramref name="dependent_tag"/> to the database</param>
/// <param name="dependent_tag">Tag which is directly referenced by <paramref name="tag"/></param>
/// <returns>Hash value for tag's database entry</returns>
/// <remarks>
/// Does not modify the current root tag.
/// <paramref name="tag"/> must already already exist in the database
/// </remarks>
public int AddDependent(ITagDatabaseAddable tag, ITagDatabaseAddable dependent_tag)
{
HandleData root_data = new HandleData(tag);
HandleData data = new HandleData(dependent_tag);
return(AddDependent(root_data, data));
}
/// <summary>
/// Sets the shape inference result HandleData on tensor.
/// </summary>
/// <param name="handle"></param>
/// <param name="full_handle_data"></param>
/// <param name="graph_mode"></param>
private static void _set_handle_shapes_and_types(Tensor handle, HandleData handle_data, bool graph_mode)
{
if (!graph_mode)
{
return;
}
}
private IEnumerable <ClrHandle> EnumerateHandleWorker()
{
Debug.Assert(_handles == null);
List <ClrHandle> result = new List <ClrHandle>();
using (SOSHandleEnum handleEnum = _sos.EnumerateHandles())
{
HandleData[] handles = new HandleData[8];
int fetched = 0;
while ((fetched = handleEnum.ReadHandles(handles)) != 0)
{
for (int i = 0; i < fetched; i++)
{
ClrHandle handle = new ClrHandle(this, Heap, handles[i]);
result.Add(handle);
yield return(handle);
handle = handle.GetInteriorHandle();
if (handle != null)
{
result.Add(handle);
yield return(handle);
}
}
}
}
_handles = result;
}
public GetExcelFileForm()
{
dateRegStr = PatternMatchingString.dateRegStr;
numberRegStr = PatternMatchingString.numberRegStr;
InitializeComponent();
loadGlobalChineseCharacters = LoadGlobalChineseCharacters.GetInstance();
handleData = new HandleData();
initUI();
}
internal ClrHandle(V45Runtime clr, ClrHeap heap, HandleData handleData)
{
Address = handleData.Handle;
ulong obj;
clr.ReadPointer(Address, out obj);
Object = obj;
Type = heap.GetObjectType(obj);
uint refCount = 0;
if (handleData.Type == (int)HandleType.RefCount)
{
if (handleData.IsPegged != 0)
{
refCount = handleData.JupiterRefCount;
}
if (refCount < handleData.RefCount)
{
refCount = handleData.RefCount;
}
if (Type != null)
{
if (Type.IsCCW(obj))
{
CcwData data = Type.GetCCWData(obj);
if (data != null && refCount < data.RefCount)
{
refCount = (uint)data.RefCount;
}
}
else if (Type.IsRCW(obj))
{
RcwData data = Type.GetRCWData(obj);
if (data != null && refCount < data.RefCount)
{
refCount = (uint)data.RefCount;
}
}
}
RefCount = refCount;
}
HandleType = (HandleType)handleData.Type;
AppDomain = clr.GetAppDomainByAddress(handleData.AppDomain);
if (HandleType == HandleType.Dependent)
{
DependentTarget = handleData.Secondary;
DependentType = heap.GetObjectType(handleData.Secondary);
}
}
protected override int AddDependent(HandleData tag, HandleData dependent_tag)
{
int index = Add(dependent_tag); // add and\or get the index of the child id entry
tag_database_entry_reference_block eref;
lookup[tag.Hash].ChildIds.Add(out eref); // add a new entry reference
return(eref.EntryReference.Value = index);
}
static long CalculateHashCode64(ITagDatabaseAddable item, ref HandleData data)
{
long hash;
hash = (data.Name = item.GetTagName()).GetHashCode();
hash <<= 32;
hash |= TagInterface.TagGroup.ToUInt(data.GroupTag = item.GetGroupTag());
return(data.Hash = hash);
}
/// <summary>
/// 按要求将网格，得到新的网格
/// </summary>
/// <param name="meshData"></param>
/// <param name=""></param>
/// <returns></returns>
public static void CurveMeshStruct(HandleData handle, MeshStruct meshDataTemp, ref MeshStruct meshData)
{
for (int i = 0; i < meshData.vertices.Length; i++)
{
Vector3 item = meshData.vertices[i];
//区域内部
if (item.x > handle.LeftCenterPoint.x && item.x < handle.RightCenterPoint.x)
{
Vector3 newCenterPos = BezierUtility.CalculateBezierPoint((item.x - handle.LeftCenterPoint.x) / (handle.RightCenterPoint.x - handle.LeftCenterPoint.x), handle.LeftCenterPoint, handle.HandPoint1, handle.HandPoint2, handle.RightCenterPoint);
meshData.vertices[i].y = meshDataTemp.vertices[i].y + newCenterPos.y;
}
}
}
/// <summary>
/// 重写，内部数据处理单独封装为方法，一些重复处理在switch外完成
/// </summary>
/// <param name="unit"> 操作单元数组</param>
/// <param name="comtemp">发送信息缓存</param>
/// <param name="b_recvframe">接受到的数据字节数组</param>
/// <param name="errornum">请求操作单元的错误数</param>
/// <param name="error">错误列表</param>
/// <returns></returns>
public static Dictionary <ushort, object> MsgHandle(ushort[] unit, PrepareData.Compare comtemp, byte[] b_recvframe,
ref ushort errornum, Dictionary <ushort, ushort> error)
{
Dictionary <ushort, object> retinfo = new Dictionary <ushort, object>();
switch (HandleData.TypeofFrame(b_recvframe).frametype)
{
//接收的是长帧
case 1:
{
//接收数据的拆分
byte[] recvframeout = new byte[b_recvframe.Length - PrepareData.BUS_FRAME_MINLEN - 2];
Array.Copy(b_recvframe, PrepareData.BUS_FRAME_MINLEN, recvframeout, 0,
b_recvframe.Length - PrepareData.BUS_FRAME_MINLEN - 2);
//传入的字节数组只包括执行状态字和返回数据（除CRC外）
TransInfo(recvframeout, unit, retinfo, ref errornum, error);
#region 从右边去第一不方便，反相的对应取
//for (int i = 0; i < basebyte; i++)
//{
// byte low = sendframeout[sendframeout.Length - 2 * (i + 2)];
// byte high = sendframeout[sendframeout.Length - 2 * (i + 2) + 1];
// ushort temp = (ushort)(((ushort)(high << 8)) | low);
// //读最后一位执行状态字，看是否有错误，有错误则加到错误列表，并错误数加1
// //没有错误则读取倒数第一个值，与操作单元一起加入数据字典，取值时长度由数据字典截取
//}
#endregion
}
break;
//接收帧为短帧
case 0:
{
byte[] onlydata = ((PrepareData.Msg_Bus)ByteStruct.BytesToStruct(b_recvframe,
typeof(PrepareData.Msg_Bus))).data;
//只有执行状态字和返回数据
TransInfo(onlydata, unit, retinfo, ref errornum, error);
}
break;
//返回的代码错误
default:
{
//MessageBox.Show("返回的代码错误");
}
break;
}
return(retinfo);
}
protected override int AddDependent(HandleData tag, HandleData dependent_tag)
{
int index = Add(dependent_tag); // add and\or get the index of the child id entry
var tag_entry = lookup[tag.Hash];
var dtag_entry = lookup[dependent_tag.Hash];
tag_database_entry_reference_block eref;
dtag_entry.ReferenceIds.Add(out eref); // add a new entry reference to the dependent tag which points to this tag
eref.EntryReference.Value = tag_entry.Flags.Value;
tag_entry.ChildIds.Add(out eref); // add a new entry reference to this tag which points to the dependent tag
return eref.EntryReference.Value = index;
}
// Internal native calls that this implementation uses.
internal static int InternalAlloc(Object value, GCHandleType type)
{
int result, newIndex;
if (type == GCHandleType.Pinned)
{
throw new Exception("GCHandle for pinned objects not yet implemented");
}
do
{
if (nextFreeIndex < 0)
{
lock (handleToken) {
if (nextFreeIndex < 0)
{
if (handleTable == null)
{
handleTable = new HandleData[3];
handleTable[0].nextIndex = -1;
handleTable[1].nextIndex = 2;
handleTable[2].nextIndex = -1;
nextFreeIndex = 1;
}
else
{
int oldLength = handleTable.Length;
int newLength = oldLength * 2;
HandleData[] newTable = new HandleData[newLength];
Array.Copy(handleTable, 0, newTable, 0, oldLength);
handleTable = newTable;
for (int i = oldLength + 1; i < newLength; i++)
{
handleTable[i].nextIndex = i + 1;
}
handleTable[newLength - 1].nextIndex = -1;
nextFreeIndex = oldLength + 1;
}
}
}
}
result = nextFreeIndex;
newIndex = handleTable[result].nextIndex;
} while (Interlocked.CompareExchange(ref nextFreeIndex, newIndex, result) != result);
handleTable[result].obj = value;
handleTable[result].type = type;
// TODO: We should probably maintain a list of handles of each type
return(result);
}
/// <summary>
/// Create a new variable handle, optionally copying in `extra_handle_data`
/// </summary>
/// <param name="shape"></param>
/// <param name="dtype"></param>
/// <param name="shared_name"></param>
/// <param name="name"></param>
/// <param name="graph_mode"></param>
/// <param name="initial_value"></param>
/// <returns></returns>
public static Tensor variable_handle_from_shape_and_dtype(Shape shape, TF_DataType dtype,
string shared_name, string name, bool graph_mode, Tensor initial_value = null)
{
var container = ops.get_default_graph().Container;
var handle = gen_resource_variable_ops.var_handle_op(shape: shape,
dtype: dtype,
shared_name: shared_name,
name: name,
container: container);
if (initial_value == null)
{
initial_value = handle;
}
if (graph_mode)
{
var full_handle_data = _combine_handle_data(handle, initial_value);
_set_handle_shapes_and_types(handle, full_handle_data, graph_mode);
return(handle);
}
else
{
// We do not want two distinct ResourceVariable objects for the same
// underlying resource in the runtime.
// When in eager mode, explicitly ensure so here. When in graph mode, it's
// ensured by always generating different variable names.
var exists = gen_resource_variable_ops.var_is_initialized_op(handle);
// We create an assert Op instead of checking right away in order to be
// compatible with ASYNC execution mode. Further, since not all devices
// support string tensors, we encode the assertion string in the Op name
/*gen_logging_ops.assert(gen_math_ops.logical_not(exists),
* new[] { exists },
* name: "EagerVariableNameReuse");*/
var handle_data = new HandleData();
handle_data.IsSet = true;
handle_data.ShapeAndType.Add(new HandleShapeAndType
{
Dtype = dtype.as_datatype_enum(),
Shape = shape.as_proto()
});
_set_handle_shapes_and_types(handle, handle_data, graph_mode);
return(handle);
}
}
protected override int AddDependent(HandleData tag, HandleData dependent_tag)
{
int index = Add(dependent_tag); // add and\or get the index of the child id entry
var tag_entry = lookup[tag.Hash];
var dtag_entry = lookup[dependent_tag.Hash];
tag_database_entry_reference_block eref;
dtag_entry.ReferenceIds.Add(out eref); // add a new entry reference to the dependent tag which points to this tag
eref.EntryReference.Value = tag_entry.Flags.Value;
tag_entry.ChildIds.Add(out eref); // add a new entry reference to this tag which points to the dependent tag
return(eref.EntryReference.Value = index);
}
private static HandleData get_eager_safe_handle_data(Tensor handle)
{
if (handle == IntPtr.Zero)
{
var data = new HandleData();
data.ShapeAndType.Add(new HandleShapeAndType
{
Shape = handle.TensorShape.as_proto(),
Dtype = handle.dtype.as_datatype_enum()
});
return(data);
}
else
{
return(HandleData.Parser.ParseFrom(handle.BufferToArray()));
}
}
/// <summary>
/// 接收到返回包的处理方法
/// </summary>
/// <param name="error"></param>
/// <param name="b_recvframe"></param>
/// <returns></returns>
public static Dictionary <long, ushort> MsgHandle(ref ushort error, byte[] b_recvframe)
{
Dictionary <long, ushort> retinfo = new Dictionary <long, ushort>();
//如果是短帧，一定没有查找到文件，相反如果是长帧一定查询到文件
switch (HandleData.TypeofFrame(b_recvframe).frametype)
{
//长帧（查询到文件）
case 1:
{
//接收数据的拆分
byte[] recvframeout = new byte[b_recvframe.Length - PrepareData.BUS_FRAME_MINLEN - 2];
Array.Copy(b_recvframe, PrepareData.BUS_FRAME_MINLEN, recvframeout, 0,
b_recvframe.Length - PrepareData.BUS_FRAME_MINLEN - 2);
//传入的字节数组只包括执行状态字和返回数据（除CRC外）
TransInfo(recvframeout, retinfo);
}
break;
//短帧（未查询到文件）
//不存在符合要求的文件、查询出错、配置文件应该会有，设备出厂默认配置、查询错误返回错误代码
case 0:
{
byte[] errortemp = new byte[2];
PrepareData.Msg_Bus temp = (PrepareData.Msg_Bus)ByteStruct.BytesToStruct(
b_recvframe,
typeof(PrepareData.Msg_Bus));
//从原始数据中截取两个首字节，错误代码只有两个字节
Array.Copy(temp.data, 0, errortemp, 0, 2);
error = BitConverter.ToUInt16(errortemp, 0);
error = (ushort)ByteStruct.BytesToStruct(errortemp, typeof(ushort));
retinfo = null;
}
break;
//错误
default:
{
retinfo = null;
//MessageBox.Show("获取文件信息的长短帧错误！");
}
break;
}
return(retinfo);
}
protected override int Add(HandleData data)
{
int index = -1;
tag_database_entry_block entry;
if (!lookup.TryGetValue(data.Hash, out entry)) // hey, not in the database
{
index = db.Entries.Count; // count will be the index of our new entry
db.Entries.Add(out entry); // add a new entry
entry.Name.Value = data.Name; // set the name
entry.GroupTag.Value = data.GroupTag; // set the group tag
lookup.Add(data.Hash, entry); // add entry to the dictionary
return(entry.Flags.Value = index);
}
return(entry.Flags.Value);
}
private void tb_print_Click(object sender, RoutedEventArgs e)
{
if (!issave)
{
MessageAlert.Alert("请先提交数据！"); return;
}
HandleData hd = new HandleData();
// hd.Checkdatashow =_historycheckdatalist;
List <CheckDatashow> ptintcds = new List <CheckDatashow>();
if (hd.filterdata())
{
// if (hd._successcheckdatashow.Count > 0) { ptintcds = hd._successcheckdatashow; }
// else { ptintcds = hd.getprint(); }
}
// PrintSingleCheckdata psc = PrintSingleCheckdata.GetPrintSingleCheckdata(_wrench, ptintcds,_juser ,_zuser );
// psc.Show();
}
internal override Dictionary <ulong, List <ulong> > GetDependentHandleMap(CancellationToken cancelToken)
{
Dictionary <ulong, List <ulong> > result = new Dictionary <ulong, List <ulong> >();
using (SOSHandleEnum handleEnum = _sos.EnumerateHandles())
{
if (handleEnum == null)
{
return(result);
}
HandleData[] handles = new HandleData[32];
int fetched;
while ((fetched = handleEnum.ReadHandles(handles)) != 0)
{
for (int i = 0; i < fetched; i++)
{
cancelToken.ThrowIfCancellationRequested();
HandleType type = (HandleType)handles[i].Type;
if (type != HandleType.Dependent)
{
continue;
}
if (ReadPointer(handles[i].Handle, out ulong address))
{
if (!result.TryGetValue(address, out List <ulong> value))
{
result[address] = value = new List <ulong>();
}
value.Add(handles[i].Secondary);
}
}
}
return(result);
}
}
protected override int Add(HandleData data)
{
int index = -1;
tag_database_entry_block entry;
if (!lookup.TryGetValue(data.Hash, out entry)) // hey, not in the database
{
index = db.Entries.Count; // count will be the index of our new entry
db.Entries.Add(out entry); // add a new entry
// set the name
entry.Name.Value = new byte[data.Name.Length + 1];
System.Text.Encoding.ASCII.GetBytes(data.Name, 0, data.Name.Length, entry.Name.Value, 0);
entry.GroupTag.Value = data.GroupTag; // set the group tag
entry.HandleDataHigh.Value = (int)((data.Hash >> 32) & 0xFFFFFFFF);
lookup.Add(data.Hash, entry); // add entry to the dictionary
return entry.Flags.Value = index;
}
return entry.Flags.Value;
}
/// <summary>
/// Sets the shape inference result HandleData on tensor.
/// </summary>
/// <param name="handle"></param>
/// <param name="handle_data"></param>
/// <param name="graph_mode"></param>
private static void _set_handle_shapes_and_types(Tensor tensor, HandleData handle_data, bool graph_mode)
{
if (!graph_mode)
{
return;
}
var size = handle_data.ShapeAndType.Count;
var shapes = new IntPtr[size];
var types = new DataType[size];
var ranks = new int[size];
for (int i = 0; i < size; i++)
{
var shapeAndType = handle_data.ShapeAndType[i];
types[i] = shapeAndType.Dtype;
ranks[i] = shapeAndType.Shape.UnknownRank ? -1 : shapeAndType.Shape.Dim.Count;
var dims = shapeAndType.Shape.Dim.Select(x => x.Size).ToArray();
}
}
protected override int Add(HandleData data)
{
int index = -1;
tag_database_entry_block entry;
if (!lookup.TryGetValue(data.Hash, out entry)) // hey, not in the database
{
index = db.Entries.Count; // count will be the index of our new entry
db.Entries.Add(out entry); // add a new entry
// set the name
entry.Name.Value = new byte[data.Name.Length + 1];
System.Text.Encoding.ASCII.GetBytes(data.Name, 0, data.Name.Length, entry.Name.Value, 0);
entry.GroupTag.Value = data.GroupTag; // set the group tag
entry.HandleDataHigh.Value = (int)((data.Hash >> 32) & 0xFFFFFFFF);
lookup.Add(data.Hash, entry); // add entry to the dictionary
return(entry.Flags.Value = index);
}
return(entry.Flags.Value);
}
/// <summary>
/// 写操作单元响应处理
/// </summary>
/// <param name="error">错误的数目</param>
/// <param name="errornum">错误列表</param>
/// <param name="b_recvframe">接受到的原始数据帧（接受的全部字节）</param>
/// <returns></returns>
public static int MsgHandle(Dictionary <ushort, ushort> error, ref ushort errornum, byte[] b_recvframe, ushort[] unit)
{
switch (HandleData.TypeofFrame(b_recvframe).frametype)
{
//接收到的是长帧
case 1:
{
byte[] onlydata = new byte[b_recvframe.Length - PrepareData.BUS_FRAME_MINLEN - 2];
Array.Copy(b_recvframe, PrepareData.BUS_FRAME_MINLEN, onlydata, 0, onlydata.Length);
TransInfo(error, ref errornum, onlydata, unit);
break;
}
//接收到的是短帧
case 0:
{
byte[] onlydata = ((PrepareData.Msg_Bus)ByteStruct.BytesToStruct(b_recvframe, typeof(PrepareData.Msg_Bus))).data;
TransInfo(error, ref errornum, onlydata, unit);
break;
}
//判断长短帧错误
default:
{
break;
}
}
//写操作单元完成
if (0 == errornum)
{
return(1);
}
//写操作单元存在错误
else
{
return(0);
}
}
void StartUdpServer()
{
//create a new server
Console.WriteLine("Listening to clients");
// Thread to listen for incomming messages
udpListener = new UdpListener(new IPEndPoint(IPAddress.Any, 9601));
Thread listenerThread = new Thread(() => udpListener.Listen());
listenerThread.Start();
// Thread to process the incomming messages (Since network is faster than actual execution of code)
HandleData handleData = new HandleData(gameControlCenter);
Thread handleDataThread = new Thread(() => handleData.subscribeToEvent(udpListener));
handleDataThread.Start();
// Thread to broadcast gamestate to all players in a fixed interval
Broadcaster broadCaster = new Broadcaster(gameControlCenter);
Thread broadcasterThread = new Thread(() => broadCaster.BroadcastGameState());
broadcasterThread.Start();
}
public void SetUp()
{
DeviceRecord mockDataDevice = new DeviceRecord();
mockDataDevice.CompanyId = 1;
mockDataDevice.Company = "Test1";
TrackerRecord mockDataTracker = new TrackerRecord();
mockDataTracker.PartnerId = 2;
mockDataTracker.PartnerName = "Test2";
Mock <ITrackerDataHandler> mockTrackerHandler = new Mock <ITrackerDataHandler>();
Mock <IDeviceDataHandler> mockDeviceHandler = new Mock <IDeviceDataHandler>();
mockTrackerHandler.Setup(x => x.GetTrackerRecord(It.IsAny <string>())).Returns(mockDataTracker);
mockDeviceHandler.Setup(x => x.GetDeviceRecord(It.IsAny <string>())).Returns(mockDataDevice);
handleData = new HandleData(mockDeviceHandler.Object, mockTrackerHandler.Object);
}
/// <summary>
/// 获取错误信息的帧处理
/// </summary>
/// <param name="b_recvframe">接收到的字节数组（完整的）</param>
/// <returns></returns>
public static string MsgHandle(byte[] b_recvframe)
{
string explain;
switch (HandleData.TypeofFrame(b_recvframe).frametype)
{
//接收的是长帧
case 1:
{
//接收数据的拆分
byte[] recvframeout = new byte[b_recvframe.Length - PrepareData.BUS_FRAME_MINLEN - 2];
Array.Copy(b_recvframe, PrepareData.BUS_FRAME_MINLEN, recvframeout, 0,
b_recvframe.Length - PrepareData.BUS_FRAME_MINLEN - 2);
explain = Encoding.ASCII.GetString(recvframeout);
}
break;
//接收帧为短帧
case 0:
{
byte[] onlydata = ((PrepareData.Msg_Bus)ByteStruct.BytesToStruct(b_recvframe,
typeof(PrepareData.Msg_Bus))).data;
explain = Encoding.ASCII.GetString(onlydata);
}
break;
//返回的代码错误
default:
{
//如果返回的为null的话，那么请求错误代码失败（内容上的失败，毕竟已完成前序校验）
explain = null;
}
break;
}
return(explain);
}
protected override int AddDependent(HandleData tag, HandleData dependent_tag)
{
int index = Add(dependent_tag); // add and\or get the index of the child id entry
tag_database_entry_reference_block eref;
lookup[tag.Hash].ChildIds.Add(out eref); // add a new entry reference
return eref.EntryReference.Value = index;
}
/// <summary>
/// 接受数据的处理，数据库中存储的为字节数组
/// h2o的为float数组
/// co2的为ushort数组
/// 六组分的为short数组
/// </summary>
/// <param name="b_recvframe"></param>
/// <param name="msgsubtype">发送数据帧的子类型</param>
/// <returns></returns>
public static object MsgHandle(byte[] b_recvframe, byte msgsubtype)
{
byte[] sampledata;
int datalen;
int point;
List <H2OPoint> h2odata = new List <H2OPoint>();
List <ushort> co2data = new List <ushort>();
List <short> sixgasdata = new List <short>();
switch (HandleData.TypeofFrame(b_recvframe).frametype)
{
//长帧
case 1:
{
//去除了CRC校验2字节
datalen = b_recvframe.Length - PrepareData.BUS_FRAME_MINLEN - 2;
sampledata = new byte[datalen];
Array.Copy(b_recvframe, PrepareData.BUS_FRAME_MINLEN, sampledata, 0, datalen);
switch (msgsubtype)
{
//H2O
case (byte)MSGEncoding.ReadBuffer.ReadH2OCache:
{
//AW、T、ppm一组
point = datalen / 12;
for (int i = 0; i < point; i++)
{
//更新h20采样点为结构体（实际h2o采样点只有一个）
H2OPoint temp = new H2OPoint();
byte[] _h2odata = new byte[4];
Array.Copy(sampledata, 4 * i, _h2odata, 0, 4);
temp.h2o_AW = BitConverter.ToSingle(_h2odata, 0);
Array.Copy(sampledata, 4 * i + 4, _h2odata, 0, 4);
temp.h2o_T = BitConverter.ToSingle(_h2odata, 0);
Array.Copy(sampledata, 4 * i + 8, _h2odata, 0, 4);
temp.h2o_PPM = BitConverter.ToSingle(_h2odata, 0);
///原始顺序存储采样点数据
//for (int j = 0; j < 3; j++)
//{
// byte[]_h2odata = new byte[4];
// //四个四个字节的取数据
// Array.Copy(sampledata , 4*(3*i+j) , _h2odata , 0 , 4);
// h2odata.Add(BitConverter.ToSingle(_h2odata , 0));
//}
}
}
break;
//CO2
case (byte)MSGEncoding.ReadBuffer.ReadCO2Cache:
{
point = datalen / 2;
for (int i = 0; i < point; i++)
{
byte[] _co2data = new byte[2];
Array.Copy(sampledata, 2 * i, _co2data, 0, 2);
co2data.Add(BitConverter.ToUInt16(_co2data, 0));
}
}
break;
//6组分
case (byte)MSGEncoding.ReadBuffer.ReadGasCache:
{
point = datalen / 2;
for (int i = 0; i < point; i++)
{
byte[] _sixgasdata = new byte[2];
Array.Copy(sampledata, 2 * i, _sixgasdata, 0, 2);
sixgasdata.Add(BitConverter.ToInt16(_sixgasdata, 0));
}
}
break;
default:
{
//MessageBox.Show("读缓存过程错误！");
}
break;
}
}
break;
//短帧
case 0:
{
sampledata = ((PrepareData.Msg_Bus)(ByteStruct.BytesToStruct(b_recvframe,
typeof(PrepareData.Msg_Bus)))).data;
datalen = sampledata.Length;
switch (msgsubtype)
{
//H20必定为长帧，至少为三个浮点数位12字节
//case 0x00:
// {
// }
// break;
//CO2
case (byte)MSGEncoding.ReadBuffer.ReadCO2Cache:
{
point = datalen / 2;
for (int i = 0; i < point; i++)
{
byte[] _co2data = new byte[2];
Array.Copy(sampledata, 2 * i, _co2data, 0, 2);
co2data.Add(BitConverter.ToUInt16(_co2data, 0));
}
}
break;
//6组分
case (byte)MSGEncoding.ReadBuffer.ReadGasCache:
{
point = datalen / 2;
for (int i = 0; i < point; i++)
{
byte[] _sixgasdata = new byte[2];
Array.Copy(sampledata, 2 * i, _sixgasdata, 0, 2);
sixgasdata.Add(BitConverter.ToInt16(_sixgasdata, 0));
}
}
break;
default:
{
//MessageBox.Show("读缓存过程存在错误！");
}
break;
}
}
break;
}
if ((byte)MSGEncoding.ReadBuffer.ReadGasCache == msgsubtype)
{
return(sixgasdata.ToArray <short>());
}
else
if ((byte)MSGEncoding.ReadBuffer.ReadCO2Cache == msgsubtype)
{
return(co2data.ToArray <ushort>());
}
else
{
return(h2odata.ToArray <H2OPoint>());
}
}
/// <summary>
/// 函数内完成交互，直到接收完成
/// 返回数据为空，且error为0x00，说明文件读取完成
/// 返回错误代码，且数据域为空为产生错误，例如：找不到文件
/// 返回数据域不为空，且error为0x00，说明正常读取文件
/// </summary>
/// <param name="b_recvframe">接收到的字节数组,未拆包的</param>
/// <param name="error">错误代码</param>
/// <returns>已接收多少字节</returns>
public static int MsgHandle(HandleData.TypeRet hdtr,
byte[] b_recvframe, ref ushort error)
{
//执行状态字和文件数据
byte[] recvdata;
//字节型执行状态字
byte[] _statecode = new byte[2];
//不包括执行状态字和CRC校验的文件数据
byte[] filedata;
//转换为ushort类型的执行状态字
ushort statecode;
//文件数据的长度（不包括执行状态字和CRC校验）
int datalen = 0;
int donerecvinmen = 0;
byte packetnum = hdtr.packetnum;
ReadFile.Parameter sender = (ReadFile.Parameter)Define.index_obj[packetnum];
switch (HandleData.TypeofFrame(b_recvframe).frametype)
{
//长帧
//statecode == 0表示无错误，且为长帧，表示肯定datalen肯定大于0
//如果datalen == 0则肯定为短帧情况，且表示文件接收完成
case 1:
{ //去除了CRC校验2字节（包括执行状态字和文件数据）
recvdata = new byte[b_recvframe.Length - PrepareData.BUS_FRAME_MINLEN - 2];
Array.Copy(b_recvframe, PrepareData.BUS_FRAME_MINLEN, recvdata, 0,
recvdata.Length);
Array.Copy(recvdata, 0, _statecode, 0, 2);
statecode = BitConverter.ToUInt16(_statecode, 0);
//去除了返回状态字2字节
datalen = recvdata.Length - 2;
//不能出现状态执行为0且数据长度为0的情况
//因为这是长帧，这种情况只能出现在短帧的情况下
//if (0 == statecode && datalen > 0)
if (0 == statecode)
{
//不包括执行状态字和CRC校验码的文件数据
filedata = new byte[datalen];
Array.Copy(recvdata, 2, filedata, 0, datalen);
//该帧属于以接收文件的部分(若讨论文件接收完毕，到短帧中处理)
if (filepool.ContainsKey(packetnum))
{
FileItem fitemp = (FileItem)filepool[packetnum];
byte[] lastfiledata = fitemp.filedata;
byte[] datatemp = new byte[datalen + lastfiledata.Length];
Array.Copy(lastfiledata, 0, datatemp, 0, lastfiledata.Length);
Array.Copy(recvdata, 0, datatemp, lastfiledata.Length, datalen);
fitemp.Index += (ushort)datalen;
fitemp.filedata = datatemp;
filepool[packetnum] = fitemp;
}
//该帧是要传送文件的第一帧，要重新建立缓冲
else
{
FileItem fitemp = new FileItem();
fitemp.filename = sender.filename;
fitemp.filedata = recvdata;
fitemp.Index += (ushort)datalen;
filepool.Add(packetnum, fitemp);
}
}
donerecvinmen = datalen;
error = statecode;
}
break;
//短帧(分类处理，错误和不错误 文件传输结束)
case 0:
{
recvdata = ((PrepareData.Msg_Bus)ByteStruct.BytesToStruct(b_recvframe,
typeof(PrepareData.Msg_Bus))).data;
int count = ((PrepareData.Msg_Bus)ByteStruct.BytesToStruct(b_recvframe,
typeof(PrepareData.Msg_Bus))).dataLen;
datalen = count - 2;
Array.Copy(recvdata, 0, _statecode, 0, 2);
statecode = BitConverter.ToUInt16(_statecode, 0);
//传回的文件不存在错误
if (0 == statecode)
{
if (datalen > 0)
{
filedata = new byte[datalen];
Array.Copy(recvdata, 2, filedata, 0, datalen);
//byte packetnum = hdtr.packetnum;
//ReadFile.Parameter sender = (ReadFile.Parameter)Define.index_obj[packetnum];
//该帧属于以接收文件的部分(若讨论文件接收完毕，到短帧中处理)
if (filepool.ContainsKey(packetnum))
{
FileItem fitemp = (FileItem)filepool[packetnum];
byte[] lastfiledata = fitemp.filedata;
byte[] datatemp = new byte[datalen + lastfiledata.Length];
Array.Copy(lastfiledata, 0, datatemp, 0, lastfiledata.Length);
Array.Copy(recvdata, 0, datatemp, lastfiledata.Length, datalen);
fitemp.filedata = datatemp;
fitemp.Index += (ushort)datalen;
filepool[packetnum] = fitemp;
}
//该帧是要传送文件的第一帧，要重新建立缓冲
else
{
FileItem fitemp = new FileItem();
fitemp.filename = sender.filename;
fitemp.filedata = recvdata;
fitemp.Index += (ushort)datalen;
filepool.Add(packetnum, fitemp);
}
}
//errorcode和datalen都为0，文件传输结束帧
else
{
//不论存在还是不存在都使用create模式，如果文件存在那么就直接覆盖
string filename = sender.filename.ToString();
string path = "d:\\ " + filename + ".txt";
//如果指定位置已经存在该文件
if (File.Exists(path))
{
//MessageBox.Show("接收到的文件已存在，正在准备覆盖源文件！");
}
FileItem fitemp = (FileItem)filepool[hdtr.packetnum];
byte[] lastfiledata = fitemp.filedata;
FileStream tempfile = new FileStream(path, FileMode.Create, FileAccess.Write);
tempfile.Write(lastfiledata, 0, lastfiledata.Length);
tempfile.Flush();
tempfile.Close();
}
}
donerecvinmen = datalen;
//传回的文件存在错误
error = statecode;
}
break;
//错误情况
default:
{
//MessageBox.Show("读文件（msghandle）：长短帧判断处理失败！返回值均为操作！");
}
break;
}
return(donerecvinmen);
}
protected virtual void OnHandleData(Handle handle, ArraySegment <byte> data)
{
HandleData?.Invoke(handle, data);
}
private static void _set_handle_shapes_and_types(Tensor handle, HandleData full_handle_data, bool graph_mode)
{
}
internal Handle(HandleData data)
{
this.data = data;
}
protected override int Add(HandleData data)
{
int index = -1;
tag_database_entry_block entry;
if (!lookup.TryGetValue(data.Hash, out entry)) // hey, not in the database
{
index = db.Entries.Count; // count will be the index of our new entry
db.Entries.Add(out entry); // add a new entry
entry.Name.Value = data.Name; // set the name
entry.GroupTag.Value = data.GroupTag; // set the group tag
lookup.Add(data.Hash, entry); // add entry to the dictionary
return entry.Flags.Value = index;
}
return entry.Flags.Value;
}
IEnumerator LoadConfig( )
{
List <WWW> wwwTemp = new List <WWW>();
string url = "";
string baseUrl = "";
//同步加载路径
if (Application.platform == RuntimePlatform.Android)
{
baseUrl = Application.streamingAssetsPath + "/Android/";
}
else if (Application.platform == RuntimePlatform.IPhonePlayer)
{
baseUrl = Application.streamingAssetsPath + "/iOS/";
}
else
{
baseUrl = "file:" + Application.streamingAssetsPath + "/StandaloneWindows/";
}
url = baseUrl + "objects_path.json";
WWW www = new WWW(url);
yield return(www);
data = JsonConvert.DeserializeObject <AssetsData>(www.text);
www.Dispose();
while (true)
{
yield return(null);
if (loadingHandleList.Count > 0)
{
HandleData _data = loadingHandleList.Dequeue();
AssetIndormation infor;
if (data.objs.TryGetValue(_data.path, out infor))
{
// wwwTemp.Clear();
for (int i = 0; i < infor.dependencies.Count; i++)
{
var dep = infor.dependencies[i];
AssetBundle bd0;
if (bundles.TryGetValue(dep, out bd0))
{
if (null != bd0)
{
continue;
}
}
WWW www1 = new WWW(baseUrl + dep);
yield return(www1);
bundles[dep] = www1.assetBundle;
}
AssetBundle bd;
if (!bundles.TryGetValue(infor.package, out bd) || null == bd)
{
WWW www1 = new WWW(baseUrl + infor.package);
yield return(www1);
bundles[infor.package] = bd = www1.assetBundle;
}
_data.asset = bd.LoadAsset(_data.path);
_data.isFinish = true;
for (int i = 0; i < infor.dependencies.Count; i++)
{
var dep = infor.dependencies[i];
AssetBundle bd0;
if (!bundles.TryGetValue(dep, out bd0) && null == bd0)
{
continue;
}
bd0.Unload(false);
}
bd.Unload(false);
}
else
{
_data.isFinish = true;
_data.error = "找不到路径为" + _data.path + "的assetbundle";
}
}
}
}
public void SetData(HandleData handleData)
{
this.m_handleData = handleData;
this.m_LabTitle.text = handleData.name;
}
