//! \brief constructor with single phase telegraph
public SinglePhaseTelegraphService(SinglePhaseTelegraph tTelegraph, System.Int32 tTimeOut, SingleDeviceAdapter tAdapter)
: base(tTelegraph, tTimeOut)
{
m_Adapter = tAdapter;
Initialize();
}
//! \brief constructor with single phase telegraph
public SinglePhaseTelegraphService(SinglePhaseTelegraph tTelegraph, SingleDeviceAdapter tAdapter)
: base(tTelegraph)
{
m_Adapter = tAdapter;
Initialize();
}
private void TestingSinglePhaseTelegraphEvent(SinglePhaseTelegraph tTelegraph, BM_TELEGRAPH_STATE State, ESCommand ReceivedCommand)
{
tTelegraph.SinglePhaseTelegraphEvent -= new SinglePhaseTelegraphEventHandler(TestingSinglePhaseTelegraphEvent);
if (State == BM_TELEGRAPH_STATE.BM_TELE_RT_SUCCESS)
{
//! raising event
OnAdapterAvailableTelegraphAutoDetectionReport
(TELEGRAPH_AUTO_DETECT_RESULT.ONE_TELEGRAPH_MATCHED, new String[1] {
tTelegraph.Type
});
}
else
{
//! raising event
OnAdapterAvailableTelegraphAutoDetectionReport
(TELEGRAPH_AUTO_DETECT_RESULT.NO_TELEGRAPH_MATCHED, null);
}
}
public override Boolean AutoDetectDeviceTelegraph()
{
List <SinglePhaseTelegraph> tTestingTelegraphsList = new List <SinglePhaseTelegraph>();
if (!Open)
{
return(false);
}
if (this.IsBusy)
{
return(false);
}
foreach (Telegraph tTelegraph in m_SupportTelegraphList)
{
if (null == tTelegraph)
{
continue;
}
SinglePhaseTelegraph tTelegraphItem = tTelegraph.GetTestTelegraph() as SinglePhaseTelegraph;
if (null != tTelegraphItem)
{
tTestingTelegraphsList.Add(tTelegraphItem);
}
}
if (0 == tTestingTelegraphsList.Count)
{
return(false);
}
foreach (SinglePhaseTelegraph tTelegraph in tTestingTelegraphsList)
{
tTelegraph.SinglePhaseTelegraphEvent += new SinglePhaseTelegraphEventHandler(TestingSinglePhaseTelegraphEvent);
}
this.TryToSendTelegraphs(tTestingTelegraphsList.ToArray());
return(true);
}
//! implement interface IBMTelegraph : TryToSendTelegraph
public System.Boolean TryToSendTelegraph(SinglePhaseTelegraph telTarget)
{
if (null == telTarget)
{
return(false);
}
if (!m_Available)
{
return(false);
}
if (null != m_Adapter)
{
m_Adapter.WriteLogLine("Try to send telegraph.");
}
/*
* SinglePhaseTelegraphService tService = new SinglePhaseTelegraphService(telTarget, m_PipelServiceTimeOut, this);
*
* if (m_Pipeline.AddService(tService))
* {
* //tService.StartSignal.WaitOne();
* return true;
* }
*/
lock (((ICollection)m_TelegrapGroupQueue).SyncRoot)
{
m_TelegrapGroupQueue.Enqueue(new SinglePhaseTelegraph[1] {
telTarget
});
m_WaitTelegraphGroup.Set();
}
this.IsWorking = true;
return(true);
}
public override System.Boolean TryToSendTelegraphs(Telegraph[] telTagets)
{
List <SinglePhaseTelegraph> tList = new List <SinglePhaseTelegraph>();
if (null == telTagets)
{
return(false);
}
foreach (Telegraph tTelegraph in telTagets)
{
SinglePhaseTelegraph tTelegraphItem = tTelegraph as SinglePhaseTelegraph;
if (null != tTelegraphItem)
{
tList.Add(tTelegraphItem);
}
else
{
tTelegraph.OnCancel();
}
}
return(TryToSendTelegraphs(tList.ToArray()));
}
//! try to send single phase telegraph
public Boolean TryToSendTelegraph(SinglePhaseTelegraph telTarget)
{
lock (((ICollection)m_qTransmit).SyncRoot)
{
try
{
//! add BatteryManageTelegraph item to queue
m_qTransmit.Enqueue(telTarget);
}
catch (System.Exception e)
{
System.Console.WriteLine(e.ToString());
return(false);
}
}
if (!IsWorking)
{
//! re-start engine
IsWorking = true;
}
return(true);
}
//private AutoResetEvent m_EngineCompleteSignal = null;
public override System.Boolean DoService()
{
if (Cancelled)
{
//! recieve cancel request
OnCancelAllPendingTelegraphs();
return(false);
}
if (FSM_SEND_TELEGRAPHS)
{
if (null == m_TelegraphList)
{
return(false);
}
if (0 == m_TelegraphList.Count)
{
return(false);
}
foreach (Telegraph tTelegraph in m_TelegraphList)
{
SinglePhaseTelegraph tTelegraphItem = tTelegraph as SinglePhaseTelegraph;
if (null == tTelegraphItem)
{
//! cancel this telegraph
m_TelegraphList.Remove(tTelegraph);
tTelegraph.OnCancel();
continue;
}
}
if (null == m_tEngine)
{
m_tEngine = m_TelegraphList[0].CreateTelegraphEngine() as SinglePhaseTelegraphEngine;
m_tEngine.ParentAdapter = m_Adapter;
m_tEngine.Priority = ThreadPriority.AboveNormal;
m_tEngine.EngineStateReportEvent += new EngineStateReport(EngineStateReportEventHandler);
m_Adapter.WriteLogLine("New telegraph engine is created.");
}
if (null != m_tEngine.CompleteSignal)
{
m_tEngine.CompleteSignal.Reset();
}
m_tEngine.TryToSendTelegraphs(m_TelegraphList.ToArray());
if (null != m_tEngine.CompleteSignal)
{
m_tEngine.CompleteSignal.WaitOne();
}
else
{
Thread.Sleep(10);
}
FSM_SEND_TELEGRAPHS = false;
FSM_WAIT_RESULT = true;
}
if (FSM_WAIT_RESULT)
{
do
{
lock (((ICollection)m_TelegraphList).SyncRoot)
{
if (0 == m_TelegraphList.Count)
{
if (null != m_tEngine)
{
try
{
m_tEngine.Dispose();
m_tEngine = null;
}
catch (Exception)
{
}
}
//m_tEngine = null;
FSM_WAIT_RESULT = false;
FSM_SEND_TELEGRAPHS = true;
return(false);
}
}
if (Cancelled)
{
FSM_WAIT_RESULT = false;
FSM_SEND_TELEGRAPHS = true;
//! recieve cancel request
OnCancelAllPendingTelegraphs();
return(false);
}
Thread.Sleep(1);
} while (true);
}
return(true);
}
//! implement interface IBMTelegraph : TryToSendTelegraph
public Boolean TryToSendTelegraph(SinglePhaseTelegraph telTarget)
{
return(m_TelegraphAdapter.TryToSendTelegraph(telTarget));
}
//! try to send telegraph(single phase)
public override System.Boolean TryToSendTelegraph(Telegraph telTarget)
{
SinglePhaseTelegraph tempTelegraph = telTarget as SinglePhaseTelegraph;
return(TryToSendTelegraph(tempTelegraph));
}
//! communication thread
protected override void DoCommunication()
{
m_StartSignal.Set();
while (null == m_Adapter)
{
m_StopRequest.WaitOne();
m_CompleteingSignal.Set();
return;
}
SinglePhaseTelegraph telTemp = null;
Byte[] temBuffer = null;
List <SinglePhaseTelegraph> WaitReplyList = new List <SinglePhaseTelegraph>();
//List<SinglePhaseTelegraph>.Enumerator ListenerEnum = WaitReplyList.GetEnumerator();
Int32 tWaitListIndex = 0;
Queue <Byte> qReceiveBuffer = new Queue <byte>();
Byte[] tempReceiveBuffer = new Byte[256];
//! internal task send telegraph
Boolean FSM_GET_QUEUE_ITEM = true;
Boolean FSM_ENCODE = false;
Boolean FSM_TRANSMIT_DATA = false;
Boolean FSM_RECEIVE_DATA = false;
//! interanl task receive telegraph
Boolean FSM_GET_LIST_ENUM = true;
Boolean FSM_GET_LIST_ITEM = false;
Boolean FSM_GET_NEXT_ITEM = false;
Boolean FSM_DECODE = false;
Boolean m_StopMessageSent = false;
SinglePhaseTelegraph teleReceive = null;
Boolean IsNoPendingTranmitItem = false;
Boolean IsNoPendingReceiveItem = true;
Int32 ReadingFailedCounter = 0;
if (m_Adapter.Open)
{
//! clean receive buffer
while (m_Adapter.ReadDevice(ref tempReceiveBuffer, "All Dropped for flushing buffer"))
{
;
}
}
while (true)
{
if (m_StopRequest.WaitOne(0, true))
{
m_CompleteingSignal.Set();
OnEngineStateReport(TELEGRAPH_ENGINE_STATE.ENGINE_STOPED);
return;
}
while (!IsNoPendingTranmitItem)
{
//! get item from telegraph queue
if (FSM_GET_QUEUE_ITEM)
{
//! get telegraph from queue
lock (((ICollection)m_qTransmit).SyncRoot)
{
if (0 != m_qTransmit.Count)
{
//! do next loop
telTemp = m_qTransmit.Dequeue();
FSM_GET_QUEUE_ITEM = false;
FSM_ENCODE = true;
IsNoPendingTranmitItem = false;
m_StopMessageSent = false;
}
else
{
IsNoPendingTranmitItem = true;
}
}
}
//! after get queue item, try to decoding
if (FSM_ENCODE)
{
lock (telTemp)
{
//! try to encode
temBuffer = telTemp.Encode();
if (null == temBuffer)
{
/*! nothing to transmit, directly check if this
* telegraph was cancelled and receive data
*/
FSM_RECEIVE_DATA = true;
}
else
{
//! try to transmit
FSM_TRANSMIT_DATA = true;
}
FSM_ENCODE = false;
}
}
//! transmit data to device
if (FSM_TRANSMIT_DATA)
{
if (m_Adapter.Open)
{
if (m_Adapter.WriteDeviceNoDebug(temBuffer))
{
//! data transmitted
FSM_RECEIVE_DATA = true;
//! rasing on communication event
m_Adapter.OnCommunication(MSG_DIRECTION.OUTPUT_MSG, temBuffer, telTemp.Description);
}
else
{
/*! failed to transmit data, rasing event and this telegraph
* will be dropped directly.
*/
telTemp.OnError(BM_TELEGRAPH_STATE.BM_TELE_RT_ERROR_FAILD_TO_WRITE_DEVICE);
FSM_GET_QUEUE_ITEM = true;
}
FSM_TRANSMIT_DATA = false; //!< reset state
}
else if (telTemp.isCancelled)
{
//! raising cancel event
telTemp.OnCancel();
FSM_TRANSMIT_DATA = false;
FSM_GET_QUEUE_ITEM = true;
}
}
if (FSM_RECEIVE_DATA)
{
//! check whether this telegraph was already cancelled.
if (telTemp.isCancelled)
{
//! raising cancel event
telTemp.OnCancel();
}
else
{
//! add this telegraph to wait reply list
WaitReplyList.Add(telTemp);
}
FSM_RECEIVE_DATA = false;
FSM_GET_QUEUE_ITEM = true; //!< reset state
}
}
Boolean bDropFlag = true;
//! get a enum from list
if (FSM_GET_LIST_ENUM)
{
if (WaitReplyList.Count > 0)
{
//! create a copy of list
#if false
ListenerEnum = WaitReplyList.GetEnumerator();
tWaitListIndex = 0;
if (ListenerEnum.MoveNext())
{
IsNoPendingReceiveItem = false;
m_StopMessageSent = false;
FSM_GET_LIST_ENUM = false;
FSM_GET_LIST_ITEM = true;
}
else
{
ListenerEnum.Dispose();
IsNoPendingReceiveItem = true;
}
#else
tWaitListIndex = 0;
IsNoPendingReceiveItem = false;
m_StopMessageSent = false;
FSM_GET_LIST_ENUM = false;
FSM_GET_LIST_ITEM = true;
#endif
}
else
{
IsNoPendingReceiveItem = true;
}
}
//! get a item from list
if (FSM_GET_LIST_ITEM)
{
#if false
if (ListenerEnum.Current.isCancelled)
{
//! illegal list item
//! raising cancel event
ListenerEnum.Current.OnCancel();
//! remove current item
WaitReplyList.Remove(ListenerEnum.Current);
FSM_GET_NEXT_ITEM = true;
}
else
{
//! get a item
teleReceive = ListenerEnum.Current;
//! try to decode
FSM_DECODE = true;
}
#else
if (WaitReplyList[tWaitListIndex].isCancelled)
{
//! illegal list item
//! raising cancel event
WaitReplyList[tWaitListIndex].OnCancel();
//! remove current item
WaitReplyList.RemoveAt(tWaitListIndex);
tWaitListIndex--;
FSM_GET_NEXT_ITEM = true;
}
else
{
//! get a item
teleReceive = WaitReplyList[tWaitListIndex];
//! try to decode
FSM_DECODE = true;
}
#endif
FSM_GET_LIST_ITEM = false;
}
//! check if there any input data
if (!IsNoPendingReceiveItem)
{
if (m_Adapter.Open)
{
if (m_Adapter.ReadDeviceNoDebug(ref tempReceiveBuffer))
{
ReadingFailedCounter = 0;
//! add data to input buffer
foreach (Byte tValue in tempReceiveBuffer)
{
qReceiveBuffer.Enqueue(tValue);
}
//Thread.Sleep(1);
}
else
{
ReadingFailedCounter++;
if (ReadingFailedCounter > 10)
{
Thread.Sleep(50);
}
}
}
}
//! decode
if (FSM_DECODE)
{
Byte[] DropData = new Byte[1];
//! drop all zeros
while (qReceiveBuffer.Count > 0)
{
if (0 != qReceiveBuffer.Peek())
{
break;
}
//! drop one data
DropData[0] = qReceiveBuffer.Dequeue();
//! raising debug event
m_Adapter.OnCommunication(MSG_DIRECTION.INPUT_MSG, DropData, "Dropping Zero");
}
Boolean tRequestDrop = false;
System.Int32 nDequeueSize = teleReceive.Decode(ref qReceiveBuffer, ref tRequestDrop);
if (0 < nDequeueSize)
{
//! decode success
System.Byte[] tempReceiveMessage = new System.Byte[nDequeueSize];
for (System.Int32 n = 0; n < nDequeueSize; n++)
{
tempReceiveMessage[n] = qReceiveBuffer.Dequeue();
}
//! raising debug event
m_Adapter.OnCommunication(MSG_DIRECTION.INPUT_MSG, tempReceiveMessage, teleReceive.Description);
WaitReplyList.Remove(teleReceive); //!< remove telegraph from listener list
tRequestDrop = false;
FSM_GET_LIST_ENUM = true; //!< reset state machine
}
else
{
//! mismatch
if (!tRequestDrop)
{
bDropFlag = false;
}
FSM_GET_NEXT_ITEM = true;
}
FSM_DECODE = false;
}
//! get next available item
if (FSM_GET_NEXT_ITEM)
{
/*
* Boolean result = false;
*
* do
* {
* try
* {
* result = ListenerEnum.MoveNext();
* break;
* }
* catch (InvalidOperationException )
* {
* try
* {
* ListenerEnum.Dispose();
* }
* catch (Exception e2)
* {
* e2.ToString();
* }
*
* ListenerEnum = WaitReplyList.GetEnumerator();
* }
* }
* while (true);
*/
tWaitListIndex++;
if (tWaitListIndex < WaitReplyList.Count)
{
//! get next item
FSM_GET_LIST_ITEM = true;
}
else
{
List <Byte> tDropDataList = new List <Byte>();
if (bDropFlag)
{
if (qReceiveBuffer.Count > 0)
{
tDropDataList.Add(qReceiveBuffer.Dequeue());
}
}
bDropFlag = true;
while (qReceiveBuffer.Count > 0)
{
if (0 != qReceiveBuffer.Peek())
{
break;
}
//! drop one data
tDropDataList.Add(qReceiveBuffer.Dequeue());
}
if (tDropDataList.Count > 0)
{
//! raising debug event
m_Adapter.OnCommunication(MSG_DIRECTION.INPUT_MSG, tDropDataList.ToArray(), "Dropping byte(s)");
}
/*
* try
* {
* ListenerEnum.Dispose();
* }
* catch (Exception e)
* {
* e.ToString();
* }
*/
FSM_GET_LIST_ENUM = true;
}
FSM_GET_NEXT_ITEM = false;
}
if (IsNoPendingTranmitItem && IsNoPendingReceiveItem)
{
//m_StartSignal.Reset();
IsNoPendingTranmitItem = false;
if (!m_StopMessageSent)
{
m_CompleteingSignal.Set();
m_StopMessageSent = true;
OnEngineStateReport(TELEGRAPH_ENGINE_STATE.ENGINE_STOPED);
}
if (qReceiveBuffer.Count > 0)
{
qReceiveBuffer.Clear();
}
}
}
}
