protected void ParseDataReceived()
{
byte[] DataIn = null;
byte[] DataOut = null;
bool Conecta = false;
EnumReceived ReceivedWaitACK = default(EnumReceived);
string sStationModel = "";
int iErrors = 0; //Unused
string sCommandProtocol = "";
string SoftwareVersion = "";
string HardwareVersion = "";
switch (m_StatusConnect)
{
case StatusConnect.WaitNAKorHS:
case StatusConnect.WaitHS:
// esperanndo NAK de protocolo 01 o inicio de trama handshake (DLE-STX) de protocolo 02
DataIn = ReadBytes();
//
// Conexión protocolo 02 (por tramas)
//
// Nuevo protocolo 2: puede venir una trama de handshaking
// verificar si viene una trama y cargar en FrameDatain
if (((DataIn.Length > 0 && DataIn[0] == ASCII_DLE) & m_StatusConnect == StatusConnect.WaitNAKorHS) ||
(m_StatusConnect == StatusConnect.WaitHS))
{
m_Conection_FrameProtocol = CStationBase.Protocol.Protocol_02;
// seguir leyendo en buffer de entrada
iErrors = m_FrameDataIn02.DecodeCheckReceivedData(DataIn, -1, ref m_MessageFIFOIn);
// ha recibido un frame
if (m_MessageFIFOIn.Number > 0)
{
// verificar trama Handshake y obtener número de dispositivo del PC asignado por la estación
// si conecta = false -> frames leídos sin handshaking
Conecta = false;
foreach (CDllFifoMessages.MessageDll message in m_MessageFIFOIn.GetTable)
{
// FID a recibir FDh
// Control Handshake 00h
// El número de dispositivo asignado vendrá tanto en TargetDevice como en los datos
// Filtramos las direcciones origen
if (message.Command == (byte)EnumCommandFrame_02_SOLD.M_HS &&
message.FID == 0xFD &&
STATION_ADDRESS_AVAILABLES.Contains(message.SourceDevice))
{
m_pcNumDevice = message.TargetDevice;
m_stationNumDevice = message.SourceDevice;
Conecta = true;
break;
}
}
}
else if (m_FrameDataIn02.GetFrame().Length > 0)
{
// ha recibido parte de un frame, seguir leyendo
m_StatusConnect = StatusConnect.WaitHS;
break;
}
else
{
Conecta = false;
}
//
// Conexión protocolo 01
//
}
else
{
foreach (byte byt in DataIn)
{
if (byt == ASCII_NAK)
{
// protocolo conexión 01
Conecta = true;
m_Conection_FrameProtocol = CStationBase.Protocol.Protocol_01;
}
else
{
// si no es protocolo conexión 02, todos han de ser NAK
m_Conection_FrameProtocol = CStationBase.Protocol.Protocol_undefined;
Conecta = false;
break;
}
}
}
//Conexion no válida
if (Conecta == false)
{
CloseConnection();
m_StatusConnect = StatusConnect.Search;
m_Timer_Search.Stop();
m_Timer_Search.Interval = MS_NEW_SEARCH;
m_Timer_Search.Start();
break;
}
// conexión válida -> responder, según protocolo
try
{
switch (m_Conection_FrameProtocol)
{
case CStationBase.Protocol.Protocol_01:
// send SYN
SendBytes(new byte[] { ASCII_SYN });
m_Timer_Search.Interval = MS_WAIT_ACK;
m_StatusConnect = StatusConnect.WaitACK;
break;
case CStationBase.Protocol.Protocol_02:
// responder con Handshake y ACK en Datos
// 04/04/2016 Limpiar buffer de entrada para la próxima consulta
m_MessageFIFOIn.Reset(); // inicializa los mensajes de entrada
m_FrameDataIn02.Reset(); // inicializa buffer de entrada
DataOut = new byte[1];
DataOut[0] = (byte)EnumCommandFrame_02_SOLD.M_ACK;
// XOR porque es respuesta
m_FrameDataOut02.EncodeFrame(DataOut, (byte)(m_pcNumDevice ^ 0x80), m_stationNumDevice, (byte)EnumCommandFrame_02_SOLD.M_HS, (byte)(0xFD));
SendBytes(m_FrameDataOut02.GetStuffedFrame());
// enviar solicitud de firmware
DataOut = new byte[0];
byte FIDSent_1 = (byte)237;
// 26/06/2014 El FIRMWARE se pide siempre al Device 0 (en protocolo 02), porque en las touch el HANDSHAKE lo emite el device COM y devuelve COM
//FrameDataOut02.EncodeFrame(DataOut, pcNumDevice, stationNumDevice, Stack_apl_JBC.EnumCommandFrame.M_FIRMWARE, FIDSent)
// 05/11/2014 Se vuelve a enviar al device de conexión y se analiza en WaitFW si se debe enviar al 00
//FrameDataOut02.EncodeFrame(DataOut, pcNumDevice, 0, Stack_apl_JBC_BURST.EnumCommandFrame.M_FIRMWARE, FIDSent)
m_FrameDataOut02.EncodeFrame(DataOut, m_pcNumDevice, m_stationNumDevice, (byte)EnumCommandFrame_02_SOLD.M_FIRMWARE, FIDSent_1);
SendBytes(m_FrameDataOut02.GetStuffedFrame());
m_Timer_Search.Interval = MS_WAIT_FIRMWARE;
m_StatusConnect = StatusConnect.WaitFW;
break;
}
}
catch (Exception)
{
CloseConnection();
m_StatusConnect = StatusConnect.Search;
m_Timer_Search.Interval = MS_NEW_SEARCH;
}
break;
case StatusConnect.WaitACKofHS:
// esperanndo ACK (o NAK) de protocolo 02 de un handshake emitido por el PC
DataIn = ReadBytes();
//
// Respuesta handshake de PC protocolo 02
//
// verificar si viene una trama de respuesta de Handshake y cargar en FrameDatain
if (DataIn.Length > 0 && DataIn[0] == ASCII_DLE)
{
m_Conection_FrameProtocol = CStationBase.Protocol.Protocol_02;
// seguir leyendo en buffer de entrada
iErrors = m_FrameDataIn02.DecodeCheckReceivedData(DataIn, -1, ref m_MessageFIFOIn);
// ha recibido un frame
if (m_MessageFIFOIn.Number > 0)
{
// verificar trama respuesta de Handshake
// si conecta = false -> frames leídos sin handshaking
Conecta = false;
foreach (CDllFifoMessages.MessageDll message in m_MessageFIFOIn.GetTable)
{
// FID a recibir FDh
// Control Handshake 00h
// El número de dispositivo asignado vendrá tanto en TargetDevice como en los datos
// Filtramos las direcciones origen
if (message.Command == (byte)EnumCommandFrame_02_SOLD.M_HS & message.FID == 0xFD)
{
if (message.Datos[0] == (byte)EnumCommandFrame_02_SOLD.M_ACK)
{
m_pcNumDevice = message.TargetDevice;
m_stationNumDevice = message.SourceDevice;
Conecta = true;
break;
}
else
{
Conecta = false;
}
}
}
}
else if (m_FrameDataIn02.GetFrame().Length > 0)
{
// ha recibido parte de un frame, seguir leyendo
m_StatusConnect = StatusConnect.WaitACKofHS;
break;
}
else
{
Conecta = false;
}
}
//Conexion no válida
if (Conecta == false)
{
CloseConnection();
m_StatusConnect = StatusConnect.Search;
m_Timer_Search.Stop();
m_Timer_Search.Interval = MS_NEW_SEARCH;
m_Timer_Search.Start();
break;
}
// conexión válida -> solicitar FIRMWARE
try
{
switch (m_Conection_FrameProtocol)
{
case CStationBase.Protocol.Protocol_02:
// enviar solicitud de firmware
m_MessageFIFOIn.Reset(); // inicializa los mensajes de entrada
m_FrameDataIn02.Reset(); // inicializa buffer de entrada
// enviar solicitud de firmware
DataOut = new byte[0];
byte FIDSent_2 = (byte)237;
m_FrameDataOut02.EncodeFrame(DataOut, m_pcNumDevice, m_stationNumDevice, (byte)EnumCommandFrame_02_SOLD.M_FIRMWARE, FIDSent_2);
SendBytes(m_FrameDataOut02.GetStuffedFrame());
m_Timer_Search.Interval = MS_WAIT_FIRMWARE;
m_StatusConnect = StatusConnect.WaitFW;
break;
}
}
catch (Exception)
{
CloseConnection();
m_StatusConnect = StatusConnect.Search;
m_Timer_Search.Interval = MS_NEW_SEARCH;
}
break;
case StatusConnect.WaitFW:
// se espera la respuesta a la solicitud de FIRMWARE (para los 2 protocolos de conexión 01 y 02)
DataIn = ReadBytes();
// esperando trama de firmware del protocolo de conexión 02
if (m_Conection_FrameProtocol == CStationBase.Protocol.Protocol_02)
{
// quizás checkear devices
iErrors = m_FrameDataIn02.DecodeCheckReceivedData(DataIn, -1, ref m_MessageFIFOIn);
if (m_MessageFIFOIn.Number > 0)
{
// ha recibido un frame
// analizar trama y obtener dato station model y protocolo
// si conecta = false -> frames leídos sin FIRMWARE
Conecta = false;
foreach (CDllFifoMessages.MessageDll message in m_MessageFIFOIn.GetTable)
{
// Control Firmware
// analizar trama y obtener dato station model
if (message.Command == (byte)EnumCommandFrame_02_SOLD.M_FIRMWARE)
{
string sFirmw = System.Text.Encoding.UTF8.GetString(message.Datos);
string[] aFirmw = sFirmw.Split(':');
if (aFirmw.Length < 2)
{
m_StatusConnect = StatusConnect.Search;
m_Timer_Search.Stop();
m_Timer_Search.Interval = MS_NEW_SEARCH;
m_Timer_Search.Start();
break;
}
sCommandProtocol = aFirmw[0].Trim();
sStationModel = aFirmw[1].Trim(); // format: model_modeltype_modelversion
SoftwareVersion = aFirmw[2].Trim();
HardwareVersion = aFirmw[3].Trim();
CStationBase.Protocol commandProtocol = default(CStationBase.Protocol);
switch (sCommandProtocol)
{
case "01":
commandProtocol = CStationBase.Protocol.Protocol_01;
break;
case "02":
commandProtocol = CStationBase.Protocol.Protocol_02;
break;
default:
commandProtocol = CStationBase.Protocol.Protocol_01;
break;
}
// ver si el FIRMWARE me ha devuelto como modelo COM_DTE_01, por lo que es una DME
// no actualizada y debo pedir el FIRMWARE (y continuar) con el devide H00
if (commandProtocol == CStationBase.Protocol.Protocol_02 & sStationModel.Substring(0, 3) == "COM")
{
// OJO, borrar lista de mensajes de entrada para recibir de nuevo el M_FIRMWARE
// si no lo hacemos, se queda el mensaje anterior en la lista y se lee el primero que encuentra (el mismo)
// 04/04/2016 Limpiar buffer de entrada para la próxima consulta
m_MessageFIFOIn.Reset(); // inicializa los mensajes de entrada
m_FrameDataIn02.Reset(); // inicializa buffer de entrada
// volver a enviar solicitud de firmware pero al device 0
DataOut = new byte[0];
byte FIDSent = (byte)(message.FID + 1);
m_stationNumDevice = (byte)0;
m_FrameDataOut02.EncodeFrame(DataOut, m_pcNumDevice, m_stationNumDevice, (byte)EnumCommandFrame_02_SOLD.M_FIRMWARE, FIDSent);
SendBytes(m_FrameDataOut02.GetStuffedFrame());
m_Timer_Search.Interval = MS_WAIT_FIRMWARE;
m_StatusConnect = StatusConnect.WaitFW;
}
else
{
//Se prepara para una nueva conexión
m_StatusConnect = StatusConnect.Search;
if (m_Timer_Search != null)
{
m_Timer_Search.Interval = MS_NEW_SEARCH;
}
// nueva conexión
RaiseNewConnection(commandProtocol, sStationModel, SoftwareVersion, HardwareVersion);
}
break;
}
}
}
else if (m_FrameDataIn02.GetFrame().Length > 0)
{
// ha recibido parte de un frame, seguir leyendo
m_StatusConnect = StatusConnect.WaitFW;
break;
}
// esperando trama de firmware del protocolo de conexión 01
}
else if (m_Conection_FrameProtocol == CStationBase.Protocol.Protocol_01)
{
// quizás checkear devices
iErrors = m_FrameDataIn01.DecodeCheckReceivedData(DataIn, -1, ref m_MessageFIFOIn);
if (m_MessageFIFOIn.Number > 0)
{
// ha recibido un frame
// analizar trama y obtener dato station model y protocolo
// si conecta = false -> frames leídos sin FIRMWARE
Conecta = false;
foreach (CDllFifoMessages.MessageDll message in m_MessageFIFOIn.GetTable)
{
// Control Firmware
// analizar trama y obtener dato station model y protocolo
if (message.Command == (byte)EnumCommandFrame_01_SOLD.M_FIRMWARE)
{
string sFirmw = System.Text.Encoding.UTF8.GetString(message.Datos);
string[] aFirmw = sFirmw.Split(':');
if (aFirmw.Length < 3)
{
m_StatusConnect = StatusConnect.Search;
m_Timer_Search.Stop();
m_Timer_Search.Interval = MS_NEW_SEARCH;
m_Timer_Search.Start();
break;
}
sCommandProtocol = aFirmw[0].Trim();
sStationModel = aFirmw[1].Trim(); // format: model_modeltype?_modelversion
// 01/06/2016 Edu Se detecta que en protocolo 01, al grabar un UID de 20 caracteres, añade los últimos 7 también al Software del string de FIRMWARE,
// por lo tanto se toman sólo los 7 primeros caracteres del software y del hardware
SoftwareVersion = aFirmw[2].Trim().Substring(0, 7);
HardwareVersion = aFirmw[3].Trim().Substring(0, 7);
CStationBase.Protocol commandProtocol = default(CStationBase.Protocol);
switch (sCommandProtocol)
{
case "01":
commandProtocol = CStationBase.Protocol.Protocol_01;
break;
case "02":
commandProtocol = CStationBase.Protocol.Protocol_02;
break;
default:
commandProtocol = CStationBase.Protocol.Protocol_01;
break;
}
//Se prepara para una nueva conexión
m_StatusConnect = StatusConnect.Search;
if (m_Timer_Search != null)
{
m_Timer_Search.Interval = MS_NEW_SEARCH;
}
RaiseNewConnection(commandProtocol, sStationModel, SoftwareVersion, HardwareVersion);
break;
}
}
}
else if (m_FrameDataIn01.GetFrame().Length > 0)
{
// ha recibido parte de un frame, seguir leyendo
m_StatusConnect = StatusConnect.WaitFW;
break;
}
}
break;
case StatusConnect.WaitACK:
// Protocol 01: waiting ACK
// se espera la respuesta a la solicitud de FIRMWARE (para los 2 protocolos de conexión 01 y 02)
DataIn = ReadBytes();
ReceivedWaitACK = EnumReceived.Null;
foreach (byte byt in DataIn)
{
if (byt == ASCII_ACK)
{
ReceivedWaitACK = EnumReceived.ACK;
}
else if (byt == ASCII_NAK)
{
ReceivedWaitACK = EnumReceived.NAK;
}
else //Todos han de ser ACK o NAK
{
ReceivedWaitACK = EnumReceived.Other;
break;
}
}
switch (ReceivedWaitACK)
{
case EnumReceived.Null: // si no ha llegado nada
break;
// seguir esperando
case EnumReceived.ACK: // si todo lo que ha llegado son NAK menos el último que es un ACK
try
{
SendBytes(new byte[] { ASCII_ACK });
}
catch (Exception)
{
CloseConnection();
m_StatusConnect = StatusConnect.Search;
m_Timer_Search.Interval = MS_NEW_SEARCH;
break;
}
m_StatusConnect = StatusConnect.WaitNum;
m_Timer_Search.Interval = MS_WAIT_ACK;
break;
case EnumReceived.NAK: // si todos son NAK salir y esperar más caracteres
break;
// seguir esperando
case EnumReceived.Other: // si ha llegado algo inesperado
CloseConnection();
m_StatusConnect = StatusConnect.Search;
m_Timer_Search.Interval = MS_NEW_SEARCH;
break;
default:
break;
}
break;
case StatusConnect.WaitNum:
// ProtocolO de conexión 01, se espera el número del PC (device)
// se espera sólo el número del PC
m_pcNumDevice = System.Convert.ToByte(ReadBytes(1)[0]);
m_stationNumDevice = (byte)0;
try
{
SendBytes(new byte[] { ASCII_ACK });
}
catch (Exception)
{
CloseConnection();
m_StatusConnect = StatusConnect.Search;
m_Timer_Search.Interval = MS_NEW_SEARCH;
break;
}
// enviar solicitud de firmware
DataOut = new byte[0];
m_FrameDataOut01.EncodeFrame(DataOut, m_pcNumDevice, m_stationNumDevice, (byte)EnumCommandFrame_01_SOLD.M_FIRMWARE);
SendBytes(m_FrameDataOut01.GetStuffedFrame());
m_Timer_Search.Interval = MS_WAIT_FIRMWARE;
m_StatusConnect = StatusConnect.WaitFW;
m_FrameDataIn01.Reset(); // inicializa buffer de entrada
break;
}
}
private void phl_DataReceived(ref byte[] Data)
{
lock (LockReceived)
{
#if LibraryTest
DataReceivedRawDataEvent(Data);
#endif
m_MessageFIFOIn.Reset();
int iErrors = 0;
int iUndecodedBytes = 0;
switch (m_FrameProtocol)
{
case CStationBase.Protocol.Protocol_01:
iErrors = m_FrameDataIn01.DecodeCheckReceivedData(Data, m_pcNumDevice, ref m_MessageFIFOIn);
iUndecodedBytes = m_FrameDataIn01.CountFrameData();
break;
case CStationBase.Protocol.Protocol_02:
iErrors = m_FrameDataIn02.DecodeCheckReceivedData(Data, m_pcNumDevice, ref m_MessageFIFOIn);
iUndecodedBytes = m_FrameDataIn02.CountFrameData();
break;
}
if (m_Flowcontrol == EnumFrameFlowControl.BURST)
{
// received data as messages
List <CDllFifoMessages.MessageDll> Messages = new List <CDllFifoMessages.MessageDll>();
foreach (CDllFifoMessages.MessageDll Mess in m_MessageFIFOIn.GetTable)
{
Messages.Add(Mess);
}
#if LibraryTest
if (DataReceivedFrameMessagesEvent != null)
{
DataReceivedFrameMessagesEvent(Messages);
}
#endif
if (DataReceivedMessagesEvent != null)
{
DataReceivedMessagesEvent(Messages);
}
}
else
{
foreach (CDllFifoMessages.MessageDll Mess in m_MessageFIFOIn.GetTable)
{
#if LibraryTest
if (DataReceivedFrameEvent != null) // Frame
{
DataReceivedFrameEvent(Mess.RawFrame);
}
#endif
if (DataReceivedEvent != null) // Origen, Comando, Datos(), FID
{
DataReceivedEvent(Mess.SourceDevice, Mess.Command, Mess.Datos, Mess.FID, Mess.Response);
}
//Es posible que se haya destruido el objeto antes de que salga del loop (en consecuencia de una actualización)
if (ReferenceEquals(m_MessageFIFOIn, null))
{
break;
}
}
}
}
}
