internal Stack_phl(RoutinesLibrary.IO.SerialPort Port, int FrameWindowSizeInBytes)
{
m_SerialPort_Int = new RoutinesLibrary.IO.SerialPort(Port.GetSerialPort);
m_SerialPort_Int.DataReceived += new RoutinesLibrary.IO.SerialPort.DataReceivedEventHandler(SerialPort_Int_DataReceived);
m_FrameWindowSizeInBytes_USB = FrameWindowSizeInBytes;
m_TypeConnect = EnumConnect.USB;
}
internal Stack_dll(ref RoutinesLibrary.IO.SerialPort Port, byte _pcNumDevice, CStationBase.Protocol _FrameProtocol, EnumFrameFlowControl _Flowcontrol, int frameWindow)
{
m_phl = new Stack_phl(Port, (MAX_FRAME_LENGTH * frameWindow) + MAX_FRAME_LENGTH);
m_phl.DataReceived += phl_DataReceived;
m_phl.ErrorConnect += phl_ErrorConnect;
Initialize(_pcNumDevice, _FrameProtocol, _Flowcontrol, frameWindow);
}
public CCommunicationChannel(CConnectionData connectionData)
{
m_mode = connectionData.Mode;
m_sourceAddress = connectionData.PCNumDevice;
if (m_mode == SearchMode.USB)
{
m_pSerialPort = connectionData.pSerialPort;
}
else if (m_mode == SearchMode.ETH)
{
m_pWinSock = connectionData.pWinSock;
}
m_frameProtocol = connectionData.FrameProtocol;
}
internal void Eraser()
{
//Debug.Print("StackPhl.Eraser")
if (m_TypeConnect == EnumConnect.USB)
{
m_SerialPort_Int.Dispose();
m_SerialPort_Int.DataReceived -= new RoutinesLibrary.IO.SerialPort.DataReceivedEventHandler(SerialPort_Int_DataReceived);
m_SerialPort_Int = null;
}
else if (m_TypeConnect == EnumConnect.TCP)
{
m_WinSockClient_Int.Dispose();
m_WinSockClient_Int.DataReceived -= new RoutinesLibrary.Net.Protocols.TCP.TCP.DataReceivedEventHandler(WinSockClient_Int_DataReceived);
m_WinSockClient_Int.ClosedConnectionTCP -= new RoutinesLibrary.Net.Protocols.TCP.TCP.ClosedConnectionTCPEventHandler(WinSockClient_Int_ClosedConnection);
m_WinSockClient_Int = null;
}
}
public void Dispose()
{
m_mutexStackAddressMessages.WaitOne();
if (m_htStackAddressMessages != null)
{
foreach (DictionaryEntry stack in m_htStackAddressMessages)
{
((CStackMessages)stack.Value).Dispose();
}
m_htStackAddressMessages.Clear();
m_htStackAddressMessages = null;
}
m_mutexStackAddressMessages.Release();
m_pSerialPort = null;
m_pWinSock = null;
m_mutexStackDll.WaitOne();
if (m_StackDll != null)
{
#if LibraryTest
m_StackDll.DataSentFrame -= StackDll_DataSentFrame;
m_StackDll.DataReceivedFrame -= StackDll_DataReceivedFrame;
m_StackDll.DataReceivedFrameMessages -= StackDll_DataReceivedFrame_Burst;
m_StackDll.DataSentRawData -= StackDll_DataSentRawData;
m_StackDll.DataReceivedRawData -= StackDll_DataReceivedRawData;
#endif
m_StackDll.Eraser();
m_StackDll = null;
//m_StackDll.DataReceived += DataReceived;
//m_StackDll.DataReceivedMessages += DataReceived_Burst;
//m_StackDll.ErrorConnect += Event_ConnectionError;
}
m_mutexStackDll.Release();
}
protected override void RaiseNewConnection(CStationBase.Protocol commandProtocol, string sStationModel, string SoftwareVersion, string HardwareVersion)
{
//Cuando una estacion con un k60 esta apagada pero el usb esta conectado, sigue alimentandose.
if (CheckStationModel(sStationModel))
{
//Genera el evento Nueva conexion, de protocolo de conexión/trama 02
CConnectionData connectionData = new CConnectionData();
connectionData.Mode = SearchMode.USB;
connectionData.pSerialPort = m_SerialPort_Int;
connectionData.PCNumDevice = m_pcNumDevice;
connectionData.StationNumDevice = m_stationNumDevice;
connectionData.FrameProtocol = m_Conection_FrameProtocol;
connectionData.CommandProtocol = commandProtocol;
connectionData.StationModel = sStationModel;
connectionData.SoftwareVersion = SoftwareVersion;
connectionData.HardwareVersion = HardwareVersion;
//Cambia de referencia al puerto porque la anterior ya ha sido asignada
//m_SerialPort_Int.DataReceived -= new RoutinesLibrary.IO.SerialPort.DataReceivedEventHandler(SerialPort_Int_DataReceived);
m_SerialPort_Int.Dispose(false);
m_SerialPort_Int = null;
if (NewConnectionEvent != null)
{
NewConnectionEvent(ref connectionData);
}
}
else
{
//Conexion no válida
//m_SerialPort_Int.DataReceived -= new RoutinesLibrary.IO.SerialPort.DataReceivedEventHandler(SerialPort_Int_DataReceived);
m_SerialPort_Int.Dispose();
m_Timer_Search.Stop();
m_Timer_Search.Interval = MS_NEW_SEARCH;
m_Timer_Search.Start();
}
}
public void Timer_Search_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
//Este timer se desactiva siempre al entrar y se debe hacer un start siempre qu se salga
bool bRestartTimer = true;
string SearchingPort = "";
lock (m_LockTimer)
{
StatusConnect StatusConnect_New = new StatusConnect();
switch (m_StatusConnect)
{
case StatusConnect.StopSearch:
// si se solicitó un puerto
if (!string.IsNullOrEmpty(m_PortSearch) || m_StartHandshake)
{
bRestartTimer = false;
}
break;
case StatusConnect.WaitSearch:
// begin to searching thru the port list
if (string.IsNullOrEmpty(m_PortSearch))
{
string[] portlist = System.IO.Ports.SerialPort.GetPortNames();
if (!ReferenceEquals(Type.GetType("Mono.Runtime"), null))
{
List <string> availablePorts = new List <string>();
foreach (string c in portlist)
{
if (c.Contains("ttyUSB") || c.Contains("ttyACM"))
{
availablePorts.Add(c);
}
}
portlist = availablePorts.ToArray();
}
m_PortsList = new ReadOnlyCollection <string>(portlist);
}
else
{
List <string> tempList = new List <string>();
tempList.Add(m_PortSearch);
m_PortsList = new ReadOnlyCollection <string>(tempList);
m_iReintentosSobrePuertoSolicitado = 0;
}
m_IndexPort = m_PortsList.Count - 1;
StatusConnect_New = StatusConnect.Search;
if (m_Timer_Search != null)
{
m_Timer_Search.Interval = MS_NEW_SEARCH;
}
break;
case StatusConnect.Search:
case StatusConnect.RetryHS:
// next in the port list or retry Handshake
try
{
if (m_StatusConnect == StatusConnect.RetryHS)
{
m_iReintentosSobrePuertoSolicitado++; // aumentar reintentos
m_IndexPort++; // reintentar con el índice anterior
}
if (m_IndexPort < 0)
{
StatusConnect_New = StatusConnect.WaitSearch;
if (m_Timer_Search != null)
{
m_Timer_Search.Interval = MS_WAIT_SEARCH;
}
}
else
{
SerialPort NewSP = new SerialPort();
SearchingPort = m_PortsList[m_IndexPort];
NewSP.PortName = m_PortsList[m_IndexPort];
if (!(RoutinesLibrary.IO.SerialPort.isOpen(NewSP)))
{
m_SerialPort_Int = new RoutinesLibrary.IO.SerialPort(NewSP);
m_SerialPort_Int.DataReceived += new RoutinesLibrary.IO.SerialPort.DataReceivedEventHandler(SerialPort_Int_DataReceived);
m_SerialPort_Int.ConfigPort(m_PortConfig);
m_IndexPort--;
if (m_Timer_Search != null)
{
m_Timer_Search.Interval = MS_WAIT_NAK;
}
m_MessageFIFOIn.Reset(); // preparar lista de tramas recibidas
m_FrameDataIn01.Reset(); // preparar buffer de entrada
m_FrameDataOut01.Reset(); // preparar buffer de salida
m_FrameDataIn02.Reset(); // preparar buffer de entrada
m_FrameDataOut02.Reset(); // preparar buffer de salida
if (m_StartHandshake)
{
StatusConnect_New = StatusConnect.WaitACKofHS;
m_Conection_FrameProtocol = CStationBase.Protocol.Protocol_02;
SendHandshake();
}
else
{
StatusConnect_New = StatusConnect.WaitNAKorHS;
m_Conection_FrameProtocol = CStationBase.Protocol.Protocol_undefined;
}
}
else
{
//m_SerialPort_Int.DataReceived -= new RoutinesLibrary.IO.SerialPort.DataReceivedEventHandler(SerialPort_Int_DataReceived);
//TODO: Tiene sentido???
StatusConnect_New = StatusConnect.Search;
m_IndexPort--;
if (m_SerialPort_Int != null)
{
m_SerialPort_Int.Dispose();
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(System.Reflection.MethodInfo.GetCurrentMethod().Name + ". Error: " + ex.Message);
//Error. Se prepara para una nueva busqueda
StatusConnect_New = StatusConnect.Search;
if (m_Timer_Search != null)
{
m_Timer_Search.Interval = MS_NEW_SEARCH;
}
//m_SerialPort_Int.DataReceived -= new RoutinesLibrary.IO.SerialPort.DataReceivedEventHandler(SerialPort_Int_DataReceived);
m_SerialPort_Int.Dispose();
}
break;
case StatusConnect.WaitNAKorHS:
//TimeOut. Se prepara para una nueva busqueda
// HANDSHAKE DE ESTACIÓN
StatusConnect_New = StatusConnect.Search;
if (m_Timer_Search != null)
{
m_Timer_Search.Interval = MS_NEW_SEARCH;
}
//m_SerialPort_Int.DataReceived -= new RoutinesLibrary.IO.SerialPort.DataReceivedEventHandler(SerialPort_Int_DataReceived);
m_SerialPort_Int.Dispose();
// si se solicitó un puerto, reintentar 5 veces
if (!string.IsNullOrEmpty(m_PortSearch))
{
if (m_iReintentosSobrePuertoSolicitado >= MAX_REINTENTOS_SOBRE_PUERTO_SOLICITADO)
{
if (NoConexionEvent != null)
{
NoConexionEvent(m_PortSearch);
}
StatusConnect_New = StatusConnect.StopSearch;
// no rearranca el timer
bRestartTimer = false;
}
else
{
StatusConnect_New = StatusConnect.RetryHS;
}
}
break;
case StatusConnect.WaitACKofHS:
//TimeOut. Se prepara para una nueva busqueda
// HANDSHAKE DE PC
StatusConnect_New = StatusConnect.Search;
if (m_Timer_Search != null)
{
m_Timer_Search.Interval = MS_NEW_SEARCH;
}
//m_SerialPort_Int.DataReceived -= new RoutinesLibrary.IO.SerialPort.DataReceivedEventHandler(SerialPort_Int_DataReceived);
m_SerialPort_Int.Dispose();
// si se solicitó handshake desde el PC, reintentar 5 veces
if (m_iReintentosSobrePuertoSolicitado >= MAX_REINTENTOS_SOBRE_PUERTO_SOLICITADO)
{
// si se especificó un puerto, detener. si no, sigue el StatusConnect.Search
if (!string.IsNullOrEmpty(m_PortSearch))
{
if (NoConexionEvent != null)
{
NoConexionEvent(m_PortSearch);
}
StatusConnect_New = StatusConnect.StopSearch;
// no rearranca el timer
bRestartTimer = false;
}
}
else
{
StatusConnect_New = StatusConnect.RetryHS;
}
break;
case StatusConnect.WaitACK:
//TimeOut. Se prepara para una nueva busqueda
StatusConnect_New = StatusConnect.Search;
if (m_Timer_Search != null)
{
m_Timer_Search.Interval = MS_NEW_SEARCH;
}
//m_SerialPort_Int.DataReceived -= new RoutinesLibrary.IO.SerialPort.DataReceivedEventHandler(SerialPort_Int_DataReceived);
m_SerialPort_Int.Dispose();
break;
case StatusConnect.WaitNum:
//TimeOut. Se prepara para una nueva busqueda
StatusConnect_New = StatusConnect.Search;
if (m_Timer_Search != null)
{
m_Timer_Search.Interval = MS_NEW_SEARCH;
}
//m_SerialPort_Int.DataReceived -= new RoutinesLibrary.IO.SerialPort.DataReceivedEventHandler(SerialPort_Int_DataReceived);
m_SerialPort_Int.Dispose();
break;
case StatusConnect.WaitFW:
case StatusConnect.WaitHS:
//TimeOut protocolo 2. Se prepara para una nueva busqueda
//Debug.Print("Timer_Search_Elapsed-WaitFM timeout")
StatusConnect_New = StatusConnect.Search;
if (m_Timer_Search != null)
{
m_Timer_Search.Interval = MS_NEW_SEARCH;
}
//m_SerialPort_Int.DataReceived -= new RoutinesLibrary.IO.SerialPort.DataReceivedEventHandler(SerialPort_Int_DataReceived);
m_SerialPort_Int.Dispose();
break;
}
m_StatusConnect = StatusConnect_New;
try
{
if (bRestartTimer && m_Timer_Search != null)
{
m_Timer_Search.Start();
}
}
catch (Exception)
{
}
}
}
