/// <summary>
/// 请求命令队列
/// </summary>
private Queue<Request> requests;
/// <summary>
/// 应答数据集合
/// </summary>
private List< byte > responses;
/// <summary>
/// 发送线程同步信号
/// </summary>
private ManualResetEvent sendWaiter;
/// <summary>
/// 应答数据处理线程同步信号
/// </summary>
private ManualResetEvent receiveWaiter;

this .requests = new Queue<Request>();
this .responses = new List< byte >();
this .sendWaiter = new ManualResetEvent( false );
this .receiveWaiter = new ManualResetEvent( false );

//命令发送线程
ThreadPool.QueueUserWorkItem( new WaitCallback(Send));

//应答处理线程
ThreadPool.QueueUserWorkItem( new WaitCallback(Received));

/// <summary>
/// 启动服务
/// </summary>
public void Start()
{
try
{
if (! this .serialPort1.IsOpen)
{
this .serialPort1.Open();
}
this .requests.Clear();
// 插入初始化命令
this .Push( new Request());
this .sendWaiter.Set();
this .receiveWaiter.Set();
}
catch (Exception ex)
{
throw ex;
}
}

/// <summary>
/// 停止服务
/// </summary>
public void Stop()
{
this .sendWaiter.Reset();
this .receiveWaiter.Reset();
if ( this .serialPort1.IsOpen)
{
this .serialPort1.Close();
}
this .requests.Clear();
this .responses.Clear();
}

/// <summary>
/// 插入操作命令
/// </summary>
/// <param name="request"></param>
public void Push(Request request)
{
Monitor.Enter( this .requests);
this .requests.Enqueue(request);
Monitor.Exit( this .requests);
}

/// <summary>
/// 发送
/// </summary>
/// <param name="obj"></param>
private void Send( object obj)
{
while ( true )
{
try
{
this .sendWaiter.WaitOne();
Monitor.Enter( this .requests);
Request request = null ;
if ( this .requests.Count > 0 )
{
request = this .requests.Dequeue();
}
else if ( this .Polling)
{
this .send++;
request = new Request( this .config.Zone);
}
if (request != null )
{
byte [] buffer = request.ToBytes();
this .serialPort1.DiscardInBuffer();
this .serialPort1.Write(buffer, 0 , buffer.Length);
}
Monitor.Exit( this .requests);
Thread.Sleep(2 00 );
}
catch (Exception ex)
{
throw ex;
}
}
}

/// <summary>
/// 串口接收
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void SerialPortDataReceived( object sender, EventArgs e)
{
try
{
if ( this .serialPort1.BytesToRead > 0 )
{
byte [] buffer = new byte [ this .serialPort1.BytesToRead];
int readCount = this .serialPort1.Read(buffer, 0 , buffer.Length);
Monitor.Enter( this .responses);
this .responses.AddRange(buffer);
Monitor.Exit( this .responses);
}
}
catch (Exception ex)
{
throw ex;
}
}

/// <summary>
/// 缓存处理
/// </summary>
/// <param name="obj"></param>
private void Received( object obj)
{
while ( true )
{
this .receiveWaiter.WaitOne();
Monitor.Enter( this .responses);
if ( this .responses.Count > 0 )
{
int endIndex = this .responses.IndexOf(Request.SYMBOL_END);
if (endIndex >= 0 )
{
byte [] buffer = this .responses.GetRange( 0 , endIndex + 1 ).ToArray();
this .responses.RemoveRange( 0 , endIndex + 1 );
if (buffer.Length > 3 )
{
int cmd = buffer[ 1 ];
switch (cmd)
{
case Request.CMD_QUERY_STATE_SYSTEM:
case Request.CMD_QUERY_UNKNOWN_ZONE:
{
this .config.Update(buffer, 0 , buffer.Length);
this .Polling = true ;
if ( this .ShelvesInitialized != null )
{
this .ShelvesInitialized( this , new ShelvesInitializedEventArgs( this .config));
}
break ;
}
case Request.CMD_QUERY_STATE_LINE:
{
this .received++;
this .realtime = Realtime.Parse(buffer, 0 , buffer.Length);
if ( this .ShelvesDataReceived != null && this .realtime != null )
{
this .ShelvesDataReceived( this , new ShelvesDataReceivedEventArgs( this .realtime));
}
break ;
}
}
}
}
}
Monitor.Exit( this .responses);
Thread.Sleep( 200 );
}

/// <summary>
/// 数据接收事件参数
/// </summary>
public class ShelvesDataReceivedEventArgs : EventArgs
{
private Realtime realtime;

public ShelvesDataReceivedEventArgs(Realtime realtime)
{
this .realtime = realtime;
}

public Realtime Realtime
{
get
{
return this .realtime;
}
}
}

/// <summary>
/// 密集架数据接收事件处理
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public delegate void ShelvesDataReceivedEventHandler( object sender, ShelvesDataReceivedEventArgs e);

//以委托的方式显示在主界面

private delegate void UpdateDelegate(Realtime realtime);

//事件处理函数