public static void CopyData(CStationInfoData stationInfo,
dc_Station_Sold_Info dcStationInfo)
{
stationInfo.UUID = dcStationInfo.UUID;
stationInfo.ParentUUID = dcStationInfo.ParentUUID;
stationInfo.StationType = (eStationType)dcStationInfo.StationType;
stationInfo.Protocol = dcStationInfo.Protocol;
stationInfo.COM = dcStationInfo.COM;
stationInfo.ConnectionType = dcStationInfo.ConnectionType;
CConvertFeaturesFromDC.CopyData(stationInfo.Features, dcStationInfo.Features);
for (var i = 0; i <= dcStationInfo.InfoUpdateFirmware.Length - 1; i++)
{
CFirmwareStation stationMicro = new CFirmwareStation();
CConvertFirmwareVersionFromDC.CopyData(stationMicro, dcStationInfo.InfoUpdateFirmware[i]);
stationInfo.StationMicros.Add(i, stationMicro);
}
stationInfo.Model = dcStationInfo.Model;
stationInfo.ModelType = dcStationInfo.ModelType;
stationInfo.ModelVersion = dcStationInfo.ModelVersion;
stationInfo.PortCount = dcStationInfo.PortCount;
stationInfo.SupportedTools = new GenericStationTools[dcStationInfo.SupportedTools.Length - 1 + 1];
for (var i = 0; i <= dcStationInfo.SupportedTools.Length - 1; i++)
{
stationInfo.SupportedTools[(int)i] = (GenericStationTools)(dcStationInfo.SupportedTools[i]);
}
stationInfo.TempLevelsCount = dcStationInfo.TempLevelsCount;
stationInfo.Version_Software = dcStationInfo.Version_Software;
stationInfo.Version_Hardware = dcStationInfo.Version_Hardware;
}
public static void CopyData(CFirmwareStation firmwareVersion,
dc_FirmwareStation dcFirmwareVersion)
{
firmwareVersion.StationUUID = dcFirmwareVersion.stationUUID;
firmwareVersion.Model = dcFirmwareVersion.model;
firmwareVersion.ModelVersion = dcFirmwareVersion.modelVersion;
firmwareVersion.ProtocolVersion = dcFirmwareVersion.protocolVersion;
firmwareVersion.HardwareVersion = dcFirmwareVersion.hardwareVersion;
firmwareVersion.SoftwareVersion = dcFirmwareVersion.softwareVersion;
firmwareVersion.FileName = dcFirmwareVersion.fileName;
}
internal List <CFirmwareStation> GetVersionMicrosFirmware()
{
List <CFirmwareStation> versionMicros = new List <CFirmwareStation>();
//Add version
foreach (DictionaryEntry stationMicroEntry in m_StationData.Info.StationMicros)
{
CFirmwareStation stationMicro = new CFirmwareStation();
stationMicro.StationUUID = ((CFirmwareStation)stationMicroEntry.Value).StationUUID;
stationMicro.Model = ((CFirmwareStation)stationMicroEntry.Value).Model;
stationMicro.ModelVersion = ((CFirmwareStation)stationMicroEntry.Value).ModelVersion;
stationMicro.ProtocolVersion = ((CFirmwareStation)stationMicroEntry.Value).ProtocolVersion;
stationMicro.HardwareVersion = ((CFirmwareStation)stationMicroEntry.Value).HardwareVersion;
stationMicro.SoftwareVersion = ((CFirmwareStation)stationMicroEntry.Value).SoftwareVersion;
stationMicro.FileName = ((CFirmwareStation)stationMicroEntry.Value).FileName;
versionMicros.Add(stationMicro);
}
return(versionMicros);
}
public void ProcessMessageResponse(uint Numstream, byte[] Datos, byte Command, byte Origen)
{
//
//Check source address
//
if (Origen != m_StationNumDevice)
{
//Para las sub estaciones sólo escuchamos a la siguiente dirección (DME(0x10) -> PSE(0x20) -> PSE (0x30))
if (m_StationData.Info.Features.SubStations && (m_StationNumDevice + (int)EnumAddress.NEXT_SUBSTATION_ADDRESS) == Origen)
{
//Las direcciones que vengan del mismo bloque de estación
}
else if ((Origen & (byte)EnumAddress.MASK_STATION_ADDRESS) == m_StationNumDevice)
{
}
else
{
return;
}
}
//
//Sent message
//
MessageHashtable.Message MessageInt = new MessageHashtable.Message();
int Puerto = 0;
//Dim Tool As Integer
string sDatos = "";
string[] aDatos = null;
string sTemp = "";
//Recuperar mensaje
if (m_MessagesSentManager.ReadMessage(Numstream, ref MessageInt))
{
m_MessagesSentManager.RemoveMessage(Numstream);
//La estación SF solo tiene un puerto y no viene especificado en el protocolo
Puerto = 0;
//Mensajes recibidos sin petición. (Firmware -> sub estación)
//Para la DME touch enviamos las peticiones del modo continuo al dspic33 en vez de a la estación
}
else if (Command != (byte)EnumCommandFrame_02_SF.M_HS &
Command != (byte)EnumCommandFrame_02_SF.M_NACK &
Command != (byte)EnumCommandFrame_02_SF.M_FIRMWARE)
{
return;
}
//
//Command
//
if (Command == (byte)EnumCommandFrame_02_SF.M_HS)
{
//Si se recibe una trama de handshake de otra dirección, es posible que se trate de otra estación
if (Origen != m_StationNumDevice)
{
ReadDeviceVersions(Origen);
}
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_EOT)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_ACK)
{
if (EndedTransactionEvent != null)
{
EndedTransactionEvent(Numstream);
}
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_NACK)
{
Debug.Print("NACK Error: {0} Sent opcode: H{1:X2}", (Datos[0]).ToString(), Datos[1]);
if (NACKTransactionEvent != null)
{
NACKTransactionEvent(Numstream);
}
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_SYN)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_DEVICEID)
{
clsStationUID stationUUID = new clsStationUID(Datos);
m_StationData.Info.UUID = stationUUID.UID;
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_DEVICEID)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_RESET)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_FIRMWARE)
{
if (Datos.Length == 0)
{
}
string datosVersions = Encoding.UTF8.GetString(Datos);
string[] arrayVersions = datosVersions.Split(':');
if (arrayVersions.Length < 4)
{
}
//protocolo
string protocolo = arrayVersions[0];
//modelo
string model = arrayVersions[1];
string[] arrayModelData = arrayVersions[1].Split('_');
string modelModel = arrayModelData[0];
string modelType = "";
if (arrayModelData.Length > 1)
{
modelType = arrayModelData[1];
}
int modelVersion = -1;
if (arrayModelData.Length > 2)
{
if (Information.IsNumeric(arrayModelData[2]))
{
modelVersion = int.Parse(arrayModelData[2]);
}
}
//soft y hard versions
string versionSw = arrayVersions[2];
string versionHw = arrayVersions[3];
//La trama viene del micro principal
if (Origen == m_StationNumDevice)
{
m_StationData.Info.Protocol = protocolo;
m_StationData.Info.Model = modelModel;
m_StationData.Info.ModelType = modelType;
m_StationData.Info.ModelVersion = modelVersion;
m_StationData.Info.Version_Software = versionSw;
m_StationData.Info.Version_Hardware = versionHw;
//La trama viene de una estación conectada a otra estación (p.e. DME -> PSE -> PSE -> PSE)
}
else if (((Origen & (byte)EnumAddress.MASK_STATION_ADDRESS) == Origen) && CheckStationModel(model))
{
CConnectionData connectionData = new CConnectionData();
//connectionData.Mode -> no es necesario por que será el mismo que el padre
//connectionData.pSerialPort -> no es necesario por que será el mismo que el padre
//connectionData.PCNumDevice -> no es necesario por que será el mismo que el padre
connectionData.StationNumDevice = Origen;
//connectionData.FrameProtocol = -> no es necesario por que será el mismo que el padre
//connectionData.CommandProtocol -> no es necesario por que será el mismo que el padre
connectionData.StationModel = model;
connectionData.SoftwareVersion = versionSw;
connectionData.HardwareVersion = versionHw;
if (Detected_SubStationEvent != null)
{
Detected_SubStationEvent(connectionData);
}
}
//Guardamos la información del micro
if ((Origen & (byte)EnumAddress.MASK_STATION_ADDRESS) == m_StationNumDevice)
{
//Guardar información del micro
if (!m_StationData.Info.StationMicros.Contains(Origen))
{
CFirmwareStation micro = new CFirmwareStation();
micro.Model = m_StationData.Info.Model;
micro.HardwareVersion = versionHw;
micro.SoftwareVersion = versionSw;
m_StationData.Info.StationMicros.Add(Origen, micro);
}
}
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_CLEARMEMFLASH)
{
if (ClearingFlashFinishedEvent != null)
{
ClearingFlashFinishedEvent();
}
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_SENDMEMADDRESS)
{
if (AddressMemoryFlashFinishedEvent != null)
{
AddressMemoryFlashFinishedEvent();
}
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_SENDMEMDATA)
{
if (DataMemoryFlashFinishedEvent != null)
{
DataMemoryFlashFinishedEvent();
}
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_ENDPROGR)
{
if (EndProgFinishedEvent != null)
{
EndProgFinishedEvent();
}
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_DISPENSERMODE)
{
if (Datos.Length != 2)
{
return;
}
m_PortData[Puerto].ToolStatus.DispenserMode = (DispenserMode_SF)Datos[0];
if (m_PortData[Puerto].ToolStatus.DispenserMode == DispenserMode_SF.PROGRAM)
{
m_StationData.Settings.SelectedProgram = (Datos[1]);
}
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_DISPENSERMODE)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_PROGRAM)
{
if (Datos.Length != 21)
{
return;
}
byte program = System.Convert.ToByte(Datos[0] - 1); //indexado 1-35
m_StationData.Settings.Programs[program].Name = Encoding.ASCII.GetString(Datos, 1, 8).Trim();
m_StationData.Settings.Programs[program].Length_1 = BitConverter.ToUInt16(Datos, 9);
m_StationData.Settings.Programs[program].Speed_1 = BitConverter.ToUInt16(Datos, 11);
m_StationData.Settings.Programs[program].Length_2 = BitConverter.ToUInt16(Datos, 13);
m_StationData.Settings.Programs[program].Speed_2 = BitConverter.ToUInt16(Datos, 15);
m_StationData.Settings.Programs[program].Length_3 = BitConverter.ToUInt16(Datos, 17);
m_StationData.Settings.Programs[program].Speed_3 = BitConverter.ToUInt16(Datos, 19);
if (m_StationData.Settings.Programs[program].Name == "--------" &&
m_StationData.Settings.Programs[program].Length_1 == 0 &&
m_StationData.Settings.Programs[program].Speed_1 == 0 &&
m_StationData.Settings.Programs[program].Length_2 == 0 &&
m_StationData.Settings.Programs[program].Speed_2 == 0 &&
m_StationData.Settings.Programs[program].Length_3 == 0 &&
m_StationData.Settings.Programs[program].Speed_3 == 0)
{
m_StationData.Settings.Programs[program].Enabled = OnOff._OFF;
}
else
{
m_StationData.Settings.Programs[program].Enabled = OnOff._ON;
}
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_PROGRAM)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_PROGRAMLIST)
{
if (Datos.Length != 35)
{
return;
}
Array.Copy(Datos, m_StationData.Settings.ConcatenateProgramList, Datos.Length);
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_PROGRAMLIST)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_SPEED)
{
if (Datos.Length != 2)
{
return;
}
//decimas de milimetro
m_PortData[Puerto].ToolStatus.Speed.InMillimetersPerSecond(System.Convert.ToDouble((double)BitConverter.ToUInt16(Datos, 0) / 10));
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_SPEED)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_LENGTH)
{
if (Datos.Length != 2)
{
return;
}
//decimas de milimetro
m_PortData[Puerto].ToolStatus.Length.InMillimeters(System.Convert.ToDouble((double)BitConverter.ToUInt16(Datos, 0) / 10));
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_LENGTH)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_STARTFEEDING)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_STOPTFEEDING)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_FEEDING)
{
if (Datos.Length != 5)
{
return;
}
m_PortData[Puerto].ToolStatus.FeedingState = (OnOff)(Datos[0]);
if (m_PortData[Puerto].ToolStatus.DispenserMode == DispenserMode_SF.CONTINUOUS)
{
m_PortData[Puerto].ToolStatus.FeedingPercent = System.Convert.ToUInt16(0);
m_PortData[Puerto].ToolStatus.FeedingLength.InMillimeters(BitConverter.ToUInt16(Datos, 1));
}
else if (m_PortData[Puerto].ToolStatus.DispenserMode == DispenserMode_SF.DISCONTINUOUS)
{
m_PortData[Puerto].ToolStatus.FeedingPercent = BitConverter.ToUInt16(Datos, 1);
m_PortData[Puerto].ToolStatus.FeedingLength.InMillimeters(0);
}
else if (m_PortData[Puerto].ToolStatus.DispenserMode == DispenserMode_SF.PROGRAM)
{
m_PortData[Puerto].ToolStatus.FeedingPercent = BitConverter.ToUInt16(Datos, 1);
m_PortData[Puerto].ToolStatus.FeedingLength.InMillimeters(0);
m_StationData.Settings.SelectedProgram = (Datos[3]);
}
else if (m_PortData[Puerto].ToolStatus.DispenserMode == DispenserMode_SF.CONCATENATION)
{
m_PortData[Puerto].ToolStatus.FeedingPercent = BitConverter.ToUInt16(Datos, 1);
m_PortData[Puerto].ToolStatus.FeedingLength.InMillimeters(0);
m_StationData.Settings.SelectedProgram = (Datos[3]);
}
m_PortData[Puerto].ToolStatus.CurrentProgramStep = Datos[0];
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_BACKWARDMODE)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_BACKWARDMODE)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_RESETSTATION)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_PIN)
{
if (Datos.Length != 4)
{
return;
}
m_StationData.Settings.PIN = Encoding.UTF8.GetString(Datos);
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_PIN)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_STATIONLOCKED)
{
if (Datos.Length != 1)
{
return;
}
m_StationData.Settings.StationLocked = (OnOff)(Datos[0]);
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_STATIONLOCKED)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_BEEP)
{
if (Datos.Length != 1)
{
return;
}
m_StationData.Settings.Beep = (OnOff)(Datos[0]);
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_BEEP)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_LENGTHUNIT)
{
if (Datos.Length != 1)
{
return;
}
m_StationData.Settings.LengthUnit = (CLength.LengthUnit)(Datos[0]);
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_LENGTHUNIT)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_STATERROR)
{
if (Datos.Length != 1)
{
return;
}
m_StationData.Status.ErrorStation = (StationError)(Datos[0]);
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_RESETERROR)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_DEVICENAME)
{
string TextoName = Encoding.UTF8.GetString(Datos);
m_StationData.Settings.Name = TextoName;
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_DEVICENAME)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_COUNTERS)
{
if (Datos.Length != 20)
{
return;
}
m_PortData[Puerto].Counters.ContTinLength = (long)(BitConverter.ToUInt64(Datos, 0));
m_PortData[Puerto].Counters.ContPlugMinutes = BitConverter.ToInt32(Datos, 8);
m_PortData[Puerto].Counters.ContWorkMinutes = BitConverter.ToInt32(Datos, 12);
m_PortData[Puerto].Counters.ContWorkCycles = BitConverter.ToInt32(Datos, 16);
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_RESETCOUNTERS)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_COUNTERSP)
{
if (Datos.Length != 20)
{
return;
}
m_PortData[Puerto].PartialCounters.ContTinLength = (long)(BitConverter.ToUInt64(Datos, 0));
m_PortData[Puerto].PartialCounters.ContPlugMinutes = BitConverter.ToInt32(Datos, 8);
m_PortData[Puerto].PartialCounters.ContWorkMinutes = BitConverter.ToInt32(Datos, 12);
m_PortData[Puerto].PartialCounters.ContWorkCycles = BitConverter.ToInt32(Datos, 16);
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_RESETCOUNTERSP)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_USB_CONNECTSTATUS)
{
if (Datos.Length == 0)
{
return;
}
sDatos = Encoding.UTF8.GetString(Datos);
if (sDatos.IndexOf(':') >= 0)
{
aDatos = sDatos.Split(':');
sTemp = aDatos[1].Trim();
}
else
{
sTemp = sDatos.Trim();
}
if (sTemp.ToUpper() == "C")
{
m_StationData.Status.ControlMode = ControlModeConnection.CONTROL;
}
else
{
m_StationData.Status.ControlMode = ControlModeConnection.MONITOR;
}
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_USB_CONNECTSTATUS)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_RBT_CONNCONFIG)
{
if (Datos.Length != 7)
{
return;
}
sDatos = Encoding.UTF8.GetString(Datos);
m_StationData.Settings.Robot.Speed = (CRobotData.RobotSpeed)Datos[0];
//Data bits in ASCII or number
if (Datos[1] >= 0 && Datos[1] <= 9)
{
m_StationData.Settings.Robot.DataBits = System.Convert.ToUInt16(Datos[1]);
}
else
{
m_StationData.Settings.Robot.DataBits = System.Convert.ToUInt16(System.Convert.ToUInt16(Datos[1] - 48));
}
switch (sDatos.Substring(2, 1))
{
case "E":
case "e":
m_StationData.Settings.Robot.Parity = CRobotData.RobotParity.Even;
break;
case "O":
case "o":
m_StationData.Settings.Robot.Parity = CRobotData.RobotParity.Odd;
break;
default:
m_StationData.Settings.Robot.Parity = CRobotData.RobotParity.None;
break;
}
if (Datos[3] == 2 || sDatos.Substring(3, 1) == "2")
{
m_StationData.Settings.Robot.StopBits = CRobotData.RobotStop.bits_2;
}
else
{
m_StationData.Settings.Robot.StopBits = CRobotData.RobotStop.bits_1;
}
if (Datos[4] == 1 || sDatos.Substring(4, 1) == "1")
{
m_StationData.Settings.Robot.Protocol = CRobotData.RobotProtocol.RS485;
}
else
{
m_StationData.Settings.Robot.Protocol = CRobotData.RobotProtocol.RS232;
}
//big endian
ushort nID = default(ushort);
//ID in ASCII or number
if (Datos[5] >= 0 && Datos[5] <= 9)
{
nID = System.Convert.ToUInt16(System.Convert.ToUInt16(Datos[5] * 10));
nID += System.Convert.ToUInt16(Datos[6]);
}
else
{
nID = System.Convert.ToUInt16(System.Convert.ToUInt16((Datos[5] - 48) * 10));
nID += System.Convert.ToUInt16(System.Convert.ToUInt16(Datos[6] - 48));
}
//UInt16.TryParse(sDatos.Substring(5, 2), nID)
m_StationData.Settings.Robot.Address = nID;
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_RBT_CONNCONFIG)
{
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_R_RBT_CONNECTSTATUS)
{
if (Datos.Length != 1)
{
return;
}
sDatos = Encoding.UTF8.GetString(Datos);
switch (sDatos)
{
case "C":
case "c":
m_StationData.Settings.Robot.Status = OnOff._ON;
break;
default:
m_StationData.Settings.Robot.Status = OnOff._OFF;
break;
}
}
else if (Command == (byte)EnumCommandFrame_02_SF.M_W_RBT_CONNECTSTATUS)
{
}
else
{
//No hacer nada
}
}
/// <summary>
/// Initialize the update process of one micro
/// </summary>
private void UpdateNextMicro()
{
//
//Select next micro to update
//
m_infoUpdateFirmwareProgress = null;
m_MicroUpdatingProgress = (short)(-1);
//Recorrer la lista de micros para encontrar el micro actualizable con la dirección más alta
foreach (DictionaryEntry microPendingUpdateEntry in m_MicrosPendingUpdate)
{
//Recorrer la lista de firmwares disponibles
foreach (CFirmwareStation infoUpdateFirmwareEntry in m_InfoUpdateFirmware)
{
//Coincide el modelo de estación
if (((CFirmwareStation)microPendingUpdateEntry.Value).Model == infoUpdateFirmwareEntry.Model)
{
//Coincide la versión de hardware
if (((CFirmwareStation)microPendingUpdateEntry.Value).HardwareVersion == infoUpdateFirmwareEntry.HardwareVersion)
{
//Hemos encontrado un micro a actualizar
//Comprobar que se vaya a cambiar la versión de software
if (((CFirmwareStation)microPendingUpdateEntry.Value).SoftwareVersion != infoUpdateFirmwareEntry.SoftwareVersion)
{
//Comprobar que dirección es más alta
if (m_MicroUpdatingProgress < System.Convert.ToByte(microPendingUpdateEntry.Key))
{
m_infoUpdateFirmwareProgress = infoUpdateFirmwareEntry;
m_MicroUpdatingProgress = System.Convert.ToByte(microPendingUpdateEntry.Key);
}
}
//Siguiente micro a buscar
break;
}
}
}
}
//
//Actualizar micro
//
//No hay más micros para actualizar
if (m_MicroUpdatingProgress == -1)
{
m_MicrosPendingUpdate = null;
if (UpdateMicroFirmwareFinishedEvent != null)
{
UpdateMicroFirmwareFinishedEvent(m_UUID);
}
}
else
{
//Obtener el modo control
m_Frames_01.WriteConnectStatus(ControlModeConnection.CONTROL);
//Enviar reset
m_Frames_01.DeviceReset();
}
}
public void ProcessMessageResponse(uint Numstream, byte[] Datos, byte Command, byte Origen)
{
//
//Check source address
//
if (Origen != m_StationNumDevice)
{
//Para las sub estaciones sólo escuchamos a la siguiente dirección (DME(0x10) -> PSE(0x20) -> PSE (0x30))
if (m_StationData.Info.Features.SubStations && (m_StationNumDevice + (int)EnumAddress.NEXT_SUBSTATION_ADDRESS) == Origen)
{
//Las direcciones que vengan del mismo bloque de estación
}
else if ((Origen & (byte)EnumAddress.MASK_STATION_ADDRESS) == m_StationNumDevice)
{
}
else
{
return;
}
}
//
//Sent message
//
MessageHashtable.Message MessageInt = new MessageHashtable.Message();
int Puerto = 0;
int Intake = 0;
string sDatos = "";
string[] aDatos = null;
string sTemp = "";
//Recuperar mensaje
if (m_MessagesSentManager.ReadMessage(Numstream, ref MessageInt))
{
m_MessagesSentManager.RemoveMessage(Numstream);
//Mensajes recibidos sin petición. (Firmware -> sub estación)
//Para la DME touch enviamos las peticiones del modo continuo al dspic33 en vez de a la estación
}
else if (Command != (byte)EnumCommandFrame_02_FE.M_HS &
Command != (byte)EnumCommandFrame_02_FE.M_NACK &
Command != (byte)EnumCommandFrame_02_FE.M_FIRMWARE)
{
return;
}
//
//Command
//
if (Command == (byte)EnumCommandFrame_02_FE.M_HS)
{
//Si se recibe una trama de handshake de otra dirección, es posible que se trate de otra estación
if (Origen != m_StationNumDevice)
{
ReadDeviceVersions(Origen);
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_EOT)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_ACK)
{
if (EndedTransactionEvent != null)
{
EndedTransactionEvent(Numstream);
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_NACK)
{
Debug.Print("NACK Error: {0} Sent opcode: H{1:X2}", (Datos[0]).ToString(), Datos[1]);
if (NACKTransactionEvent != null)
{
NACKTransactionEvent(Numstream);
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_SYN)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_DEVICEID)
{
clsStationUID stationUUID = new clsStationUID(Datos);
m_StationData.Info.UUID = stationUUID.UID;
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_DEVICEID)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_RESET)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_FIRMWARE)
{
if (Datos.Length == 0)
{
}
string datosVersions = Encoding.UTF8.GetString(Datos);
string[] arrayVersions = datosVersions.Split(':');
if (arrayVersions.Length < 4)
{
}
//protocolo
string protocolo = arrayVersions[0];
//modelo
string model = arrayVersions[1];
string[] arrayModelData = arrayVersions[1].Split('_');
string modelModel = arrayModelData[0];
string modelType = "";
if (arrayModelData.Length > 1)
{
modelType = arrayModelData[1];
}
int modelVersion = -1;
if (arrayModelData.Length > 2)
{
if (Information.IsNumeric(arrayModelData[2]))
{
modelVersion = int.Parse(arrayModelData[2]);
}
}
//soft y hard versions
string versionSw = arrayVersions[2];
string versionHw = arrayVersions[3];
//La trama viene del micro principal
if (Origen == m_StationNumDevice)
{
m_StationData.Info.Protocol = protocolo;
m_StationData.Info.Model = modelModel;
m_StationData.Info.ModelType = modelType;
m_StationData.Info.ModelVersion = modelVersion;
m_StationData.Info.Version_Software = versionSw;
m_StationData.Info.Version_Hardware = versionHw;
//La trama viene de una estación conectada a otra estación (p.e. DME -> PSE -> PSE -> PSE)
}
else if (((Origen & (byte)EnumAddress.MASK_STATION_ADDRESS) == Origen) && CheckStationModel(model))
{
CConnectionData connectionData = new CConnectionData();
//connectionData.Mode -> no es necesario por que será el mismo que el padre
//connectionData.pSerialPort -> no es necesario por que será el mismo que el padre
//connectionData.PCNumDevice -> no es necesario por que será el mismo que el padre
connectionData.StationNumDevice = Origen;
//connectionData.FrameProtocol = -> no es necesario por que será el mismo que el padre
//connectionData.CommandProtocol -> no es necesario por que será el mismo que el padre
connectionData.StationModel = model;
connectionData.SoftwareVersion = versionSw;
connectionData.HardwareVersion = versionHw;
if (Detected_SubStationEvent != null)
{
Detected_SubStationEvent(connectionData);
}
}
//Guardamos la información del micro
if ((Origen & (byte)EnumAddress.MASK_STATION_ADDRESS) == m_StationNumDevice)
{
//Guardar información del micro
if (!m_StationData.Info.StationMicros.Contains(Origen))
{
CFirmwareStation micro = new CFirmwareStation();
micro.Model = m_StationData.Info.Model;
micro.HardwareVersion = versionHw;
micro.SoftwareVersion = versionSw;
m_StationData.Info.StationMicros.Add(Origen, micro);
}
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_CLEARMEMFLASH)
{
if (ClearingFlashFinishedEvent != null)
{
ClearingFlashFinishedEvent();
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_SENDMEMADDRESS)
{
if (AddressMemoryFlashFinishedEvent != null)
{
AddressMemoryFlashFinishedEvent();
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_SENDMEMDATA)
{
if (DataMemoryFlashFinishedEvent != null)
{
DataMemoryFlashFinishedEvent();
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_ENDPROGR)
{
if (EndProgFinishedEvent != null)
{
EndProgFinishedEvent();
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_SUCTIONLEVEL)
{
if (Datos.Length != 1)
{
return;
}
//valor común para todos los puertos
for (int i = 0; i <= m_PortData.Length - 1; i++)
{
m_PortData[i].ToolStatus.SuctionLevel = (SuctionLevel_FE)(Datos[0]);
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_SUCTIONLEVEL)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_FLOW)
{
if (Datos.Length != 2)
{
return;
}
//valor común para todos los puertos
for (int i = 0; i <= m_PortData.Length - 1; i++)
{
m_PortData[i].ToolStatus.Flow = BitConverter.ToUInt16(Datos, 0);
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_SPEED)
{
if (Datos.Length != 2)
{
return;
}
//valor común para todos los puertos
for (int i = 0; i <= m_PortData.Length - 1; i++)
{
m_PortData[i].ToolStatus.Speed = BitConverter.ToUInt16(Datos, 0);
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_SELECTFLOW)
{
if (Datos.Length != 2)
{
return;
}
//valor común para todos los puertos
for (int i = 0; i <= m_PortData.Length - 1; i++)
{
m_PortData[i].ToolStatus.SelectedFlow_x_Mil = BitConverter.ToUInt16(Datos, 0);
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_SELECTFLOW)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_STANDINTAKES)
{
if (Datos.Length != 1)
{
return;
}
m_PortData[Puerto].ToolStatus.StandIntakes = Datos[0];
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_STANDINTAKES)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_INTAKEACTIVATION)
{
if (Datos.Length != 1)
{
return;
}
if (Intake == (int)ToolStatus_FE.WORK)
{
m_PortData[Puerto].ToolStatus.IntakeActivationWork = (OnOff)(Datos[0]);
}
else if (Intake == (int)ToolStatus_FE.STAND)
{
m_PortData[Puerto].ToolStatus.IntakeActivationStand = (OnOff)(Datos[0]);
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_INTAKEACTIVATION)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_SUCTIONDELAY)
{
if (Datos.Length != 4)
{
return;
}
if (Intake == (int)ToolStatus_FE.WORK)
{
m_PortData[Puerto].ToolStatus.SuctionDelayWork = BitConverter.ToUInt16(Datos, 0);
}
else if (Intake == (int)ToolStatus_FE.STAND)
{
m_PortData[Puerto].ToolStatus.SuctionDelayStand = BitConverter.ToUInt16(Datos, 0);
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_SUCTIONDELAY)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_DELAYTIME)
{
if (Datos.Length != 4)
{
return;
}
if (Intake == (int)ToolStatus_FE.WORK)
{
m_PortData[Puerto].ToolStatus.TimeToStopSuctionWork = BitConverter.ToUInt16(Datos, 0);
}
else if (Intake == (int)ToolStatus_FE.STAND)
{
m_PortData[Puerto].ToolStatus.TimeToStopSuctionStand = BitConverter.ToUInt16(Datos, 0);
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_ACTIVATIONPEDAL)
{
if (Datos.Length != 2)
{
return;
}
if (Datos[0] == 0)
{
m_PortData[Puerto].ToolStatus.PedalActivation = PedalAction.HOLD_DOWN;
}
else if (Datos[0] == 1)
{
m_PortData[Puerto].ToolStatus.PedalActivation = PedalAction.PULSE;
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_ACTIVATIONPEDAL)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_PEDALMODE)
{
if (Datos.Length != 2)
{
return;
}
m_PortData[Puerto].ToolStatus.PedalMode = (PedalMode)(Datos[0]);
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_PEDALMODE)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_FILTERSTATUS)
{
if (Datos.Length != 2)
{
return;
}
//valor común para todos los puertos
for (int i = 0; i <= m_PortData.Length - 1; i++)
{
m_PortData[i].ToolStatus.FilterStatus = BitConverter.ToUInt16(Datos, 0);
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_RESETFILTER)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_RESETSTATION)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_PIN)
{
if (Datos.Length != 4)
{
return;
}
m_StationData.Settings.PIN = Encoding.UTF8.GetString(Datos);
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_PIN)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_BEEP)
{
if (Datos.Length != 1)
{
return;
}
m_StationData.Settings.Beep = (OnOff)(Datos[0]);
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_BEEP)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_CONTINUOUSSUCTION)
{
if (Datos.Length != 1)
{
return;
}
m_StationData.Settings.ContinuousSuction = (OnOff)(Datos[0]);
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_CONTINUOUSSUCTION)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_STATERROR)
{
if (Datos.Length != 2)
{
return;
}
m_StationData.Status.ErrorStation = (StationError)(BitConverter.ToInt16(Datos, 0));
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_DEVICENAME)
{
string TextoName = Encoding.UTF8.GetString(Datos);
m_StationData.Settings.Name = TextoName;
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_DEVICENAME)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_COUNTERS)
{
if (Datos.Length != 40)
{
return;
}
m_PortData[0].Counters.ContPlugMinutes = BitConverter.ToInt32(Datos, 0);
m_PortData[1].Counters.ContPlugMinutes = BitConverter.ToInt32(Datos, 4);
m_PortData[0].Counters.ContIdleMinutes = BitConverter.ToInt32(Datos, 8);
m_PortData[1].Counters.ContIdleMinutes = BitConverter.ToInt32(Datos, 12);
m_PortData[0].Counters.ContWorkIntakeMinutes = BitConverter.ToInt32(Datos, 16);
m_PortData[1].Counters.ContWorkIntakeMinutes = BitConverter.ToInt32(Datos, 20);
m_PortData[0].Counters.ContStandIntakeMinutes = BitConverter.ToInt32(Datos, 24);
m_PortData[1].Counters.ContStandIntakeMinutes = BitConverter.ToInt32(Datos, 28);
m_PortData[0].Counters.ContWorkCycles = BitConverter.ToInt32(Datos, 32);
m_PortData[1].Counters.ContWorkCycles = BitConverter.ToInt32(Datos, 36);
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_RESETCOUNTERS)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_COUNTERSP)
{
if (Datos.Length != 40)
{
return;
}
m_PortData[0].PartialCounters.ContPlugMinutes = BitConverter.ToInt32(Datos, 0);
m_PortData[1].PartialCounters.ContPlugMinutes = BitConverter.ToInt32(Datos, 4);
m_PortData[0].PartialCounters.ContIdleMinutes = BitConverter.ToInt32(Datos, 8);
m_PortData[1].PartialCounters.ContIdleMinutes = BitConverter.ToInt32(Datos, 12);
m_PortData[0].PartialCounters.ContWorkIntakeMinutes = BitConverter.ToInt32(Datos, 16);
m_PortData[1].PartialCounters.ContWorkIntakeMinutes = BitConverter.ToInt32(Datos, 20);
m_PortData[0].PartialCounters.ContStandIntakeMinutes = BitConverter.ToInt32(Datos, 24);
m_PortData[1].PartialCounters.ContStandIntakeMinutes = BitConverter.ToInt32(Datos, 28);
m_PortData[0].PartialCounters.ContWorkCycles = BitConverter.ToInt32(Datos, 32);
m_PortData[1].PartialCounters.ContWorkCycles = BitConverter.ToInt32(Datos, 36);
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_RESETCOUNTERSP)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_USB_CONNECTSTATUS)
{
if (Datos.Length == 0)
{
return;
}
sDatos = Encoding.UTF8.GetString(Datos);
if (sDatos.IndexOf(':') >= 0)
{
aDatos = sDatos.Split(':');
sTemp = aDatos[1].Trim();
}
else
{
sTemp = sDatos.Trim();
}
if (sTemp.ToUpper() == "C")
{
m_StationData.Status.ControlMode = ControlModeConnection.CONTROL;
}
else
{
m_StationData.Status.ControlMode = ControlModeConnection.MONITOR;
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_USB_CONNECTSTATUS)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_RBT_CONNCONFIG)
{
if (Datos.Length != 7)
{
return;
}
sDatos = Encoding.UTF8.GetString(Datos);
m_StationData.Settings.Robot.Speed = ((CRobotData.RobotSpeed)(Datos[0]));
//Data bits in ASCII or number
if (Datos[1] >= 0 && Datos[1] <= 9)
{
m_StationData.Settings.Robot.DataBits = System.Convert.ToUInt16(Datos[1]);
}
else
{
m_StationData.Settings.Robot.DataBits = System.Convert.ToUInt16(System.Convert.ToUInt16(Datos[1] - 48));
}
switch (sDatos.Substring(2, 1))
{
case "E":
case "e":
m_StationData.Settings.Robot.Parity = CRobotData.RobotParity.Even;
break;
case "O":
case "o":
m_StationData.Settings.Robot.Parity = CRobotData.RobotParity.Odd;
break;
default:
m_StationData.Settings.Robot.Parity = CRobotData.RobotParity.None;
break;
}
if (Datos[3] == 2 || sDatos.Substring(3, 1) == "2")
{
m_StationData.Settings.Robot.StopBits = CRobotData.RobotStop.bits_2;
}
else
{
m_StationData.Settings.Robot.StopBits = CRobotData.RobotStop.bits_1;
}
if (Datos[4] == 1 || sDatos.Substring(4, 1) == "1")
{
m_StationData.Settings.Robot.Protocol = CRobotData.RobotProtocol.RS485;
}
else
{
m_StationData.Settings.Robot.Protocol = CRobotData.RobotProtocol.RS232;
}
//big endian
ushort nID = default(ushort);
//ID in ASCII or number
if (Datos[5] >= 0 && Datos[5] <= 9)
{
nID = System.Convert.ToUInt16(System.Convert.ToUInt16(Datos[5] * 10));
nID += System.Convert.ToUInt16(Datos[6]);
}
else
{
nID = System.Convert.ToUInt16(System.Convert.ToUInt16((Datos[5] - 48) * 10));
nID += System.Convert.ToUInt16(System.Convert.ToUInt16(Datos[6] - 48));
}
//UInt16.TryParse(sDatos.Substring(5, 2), nID)
m_StationData.Settings.Robot.Address = nID;
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_RBT_CONNCONFIG)
{
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_R_RBT_CONNECTSTATUS)
{
if (Datos.Length != 1)
{
return;
}
sDatos = Encoding.UTF8.GetString(Datos);
switch (sDatos)
{
case "C":
case "c":
m_StationData.Settings.Robot.Status = OnOff._ON;
break;
default:
m_StationData.Settings.Robot.Status = OnOff._OFF;
break;
}
}
else if (Command == (byte)EnumCommandFrame_02_FE.M_W_RBT_CONNECTSTATUS)
{
}
else
{
//No hacer nada
}
}
public void GetUpdateFirmware(ref System.Collections.Generic.List <CFirmwareStation> versionMicros)
{
List <CFirmwareStation> versionMicrosHostController = new List <CFirmwareStation>();
try
{
//Carpeta donde guardar la descarga
string firmwareFolder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonProgramFiles), "JBC\\JBC Station Controller Service\\Firmwares");
//Crear carpeta temporal
if (!(new Microsoft.VisualBasic.Devices.ServerComputer()).FileSystem.DirectoryExists(firmwareFolder))
{
Directory.CreateDirectory(firmwareFolder);
}
//Endpoint HostController
EndpointAddress ep = null;
m_mutexHostControllerEndpoints.WaitOne();
if (m_hostControllerEndpoints.Count > 0)
{
ep = m_hostControllerEndpoints.First();
}
m_mutexHostControllerEndpoints.ReleaseMutex();
if (ep != null)
{
//Open connection
BasicHttpBinding binding = new BasicHttpBinding(BasicHttpSecurityMode.None);
JBCHostControllerServiceClient serviceClient = new JBCHostControllerServiceClient(binding, ep);
serviceClient.Open();
//Recorrer todos los micros
for (int i = 0; i <= versionMicros.Count - 1; i++)
{
//Obtener información del firmware
HostControllerServiceReference.dc_FirmwareStation infoUpdateFirmware = new HostControllerServiceReference.dc_FirmwareStation();
infoUpdateFirmware.model = System.Convert.ToString(versionMicros.ElementAt(i).Model);
infoUpdateFirmware.hardwareVersion = System.Convert.ToString(versionMicros.ElementAt(i).HardwareVersion);
List <HostControllerServiceReference.dc_FirmwareStation> listNewInfoUpdateFirmware = new List <HostControllerServiceReference.dc_FirmwareStation>();
listNewInfoUpdateFirmware.AddRange(serviceClient.GetInfoUpdateFirmware(infoUpdateFirmware));
foreach (HostControllerServiceReference.dc_FirmwareStation dc_firmware in listNewInfoUpdateFirmware)
{
CFirmwareStation firmware = new CFirmwareStation();
firmware.Model = dc_firmware.model;
firmware.ModelVersion = dc_firmware.modelVersion;
firmware.ProtocolVersion = dc_firmware.protocolVersion;
firmware.HardwareVersion = dc_firmware.hardwareVersion;
firmware.SoftwareVersion = dc_firmware.softwareVersion;
firmware.FileName = Path.Combine(firmwareFolder, dc_firmware.fileName);
versionMicrosHostController.Add(firmware);
//Si no existe el archivo de firmware
if (!File.Exists(firmware.FileName))
{
bool bOk = false;
bool bContinue = false;
int nSequence = 1;
//Download firmware update
do
{
int nTries = 3;
bOk = false;
dc_UpdateFirmware updateFirmware = new dc_UpdateFirmware();
while (nTries > 0 && !bOk)
{
updateFirmware = serviceClient.GetFileUpdateFirmware(nSequence, dc_firmware.fileName);
bOk = updateFirmware.sequence == nSequence;
bContinue = !updateFirmware.final;
nTries--;
}
if (!bOk)
{
break;
}
nSequence++;
(new Microsoft.VisualBasic.Devices.ServerComputer()).FileSystem.WriteAllBytes(firmware.FileName, updateFirmware.bytes, true);
} while (bContinue);
}
}
}
serviceClient.Close();
}
}
catch (Exception ex)
{
LoggerModule.logger.Error(System.Reflection.MethodInfo.GetCurrentMethod().Name + ". Error: " + ex.Message);
}
versionMicros = versionMicrosHostController;
}
/// <summary>
/// Initialize the update process of one micro
/// </summary>
private void UpdateNextMicro()
{
//
//Select next micro to update
//
CFirmwareStation infoUpdateFirmware = null;
m_MicroUpdatingProgress = (short)(-1);
//Recorrer la lista de micros para encontrar el micro actualizable con la dirección más alta
foreach (DictionaryEntry microPendingUpdateEntry in m_MicrosPendingUpdate)
{
//Recorrer la lista de firmwares disponibles
foreach (CFirmwareStation infoUpdateFirmwareEntry in m_InfoUpdateFirmware)
{
//Coincide el modelo de estación
if (((CFirmwareStation)microPendingUpdateEntry.Value).Model == infoUpdateFirmwareEntry.Model)
{
//Coincide la versión de hardware
if (((CFirmwareStation)microPendingUpdateEntry.Value).HardwareVersion == infoUpdateFirmwareEntry.HardwareVersion)
{
//Hemos encontrado un micro a actualizar
//Comprobar que se vaya a cambiar la versión de software
if (((CFirmwareStation)microPendingUpdateEntry.Value).SoftwareVersion != infoUpdateFirmwareEntry.SoftwareVersion)
{
//Comprobar que dirección es más alta
if (m_MicroUpdatingProgress < System.Convert.ToByte(microPendingUpdateEntry.Key))
{
infoUpdateFirmware = infoUpdateFirmwareEntry;
m_MicroUpdatingProgress = System.Convert.ToByte(microPendingUpdateEntry.Key);
}
}
//Siguiente micro a buscar
break;
}
}
}
}
//
//Actualizar micro
//
//No hay más micros para actualizar
if (m_MicroUpdatingProgress == -1)
{
//Enviar Reset a todos los micros
foreach (byte microAddress in m_MicrosPendingReset)
{
if (m_FramesSOLD_02 != null)
{
m_FramesSOLD_02.DeviceReset(microAddress);
}
if (m_FramesHA_02 != null)
{
m_FramesHA_02.DeviceReset(microAddress);
}
if (m_FramesSF_02 != null)
{
m_FramesSF_02.DeviceReset(microAddress);
}
if (m_FramesFE_02 != null)
{
m_FramesFE_02.DeviceReset(microAddress);
}
}
m_MicrosPendingUpdate = null;
if (UpdateMicroFirmwareFinishedEvent != null)
{
UpdateMicroFirmwareFinishedEvent(m_UUID);
}
}
else
{
//Initialize variables
m_s19rec = null;
m_s19recAntAddress = 0;
string sErr = "";
//Decrypt
byte[] fileReader = File.ReadAllBytes(infoUpdateFirmware.FileName);
byte[] Key = JBC_encryption.JBC_ENCRYPTION_KEY;
byte[] IV = JBC_encryption.JBC_ENCRYPTION_IV;
string decrypted = System.Convert.ToString(RoutinesLibrary.Security.AES.DecryptStringFromBytes_AES(fileReader, Key, IV));
//Carriage Return (0x0D AKA Char 13) and Line Feed (0x0A AKA Char 10) and remove empty lines
string[] sTextLines = decrypted.Replace("\r", "").Split((char[])(new[] { '\n' }), StringSplitOptions.RemoveEmptyEntries);
//Cargamos el archivo de firmware
if (m_MicroPrograms.LoadFromData(ref sTextLines, ref sErr))
{
m_MicroPrograms.initUpdaterData();
//Actualiza el estado
m_UpdateFirmwareState = UpdateFirmwareState.ClearingFlash;
//Borrar memoria flash
if (m_FramesSOLD_02 != null)
{
m_FramesSOLD_02.ClearMemoryFlash(infoUpdateFirmware.ProtocolVersion + ":" +
infoUpdateFirmware.ModelVersion + ":" +
infoUpdateFirmware.SoftwareVersion + ":" +
infoUpdateFirmware.HardwareVersion + ":B", (byte)m_MicroUpdatingProgress);
}
if (m_FramesHA_02 != null)
{
m_FramesHA_02.ClearMemoryFlash(infoUpdateFirmware.ProtocolVersion + ":" +
infoUpdateFirmware.ModelVersion + ":" +
infoUpdateFirmware.SoftwareVersion + ":" +
infoUpdateFirmware.HardwareVersion + ":B", (byte)m_MicroUpdatingProgress);
}
if (m_FramesSF_02 != null)
{
m_FramesSF_02.ClearMemoryFlash(infoUpdateFirmware.ProtocolVersion + ":" +
infoUpdateFirmware.ModelVersion + ":" +
infoUpdateFirmware.SoftwareVersion + ":" +
infoUpdateFirmware.HardwareVersion + ":B", (byte)m_MicroUpdatingProgress);
}
if (m_FramesFE_02 != null)
{
m_FramesFE_02.ClearMemoryFlash(infoUpdateFirmware.ProtocolVersion + ":" +
infoUpdateFirmware.ModelVersion + ":" +
infoUpdateFirmware.SoftwareVersion + ":" +
infoUpdateFirmware.HardwareVersion + ":B", (byte)m_MicroUpdatingProgress);
}
//No se puede cargar el archivo de firmware probamos con el siguiente micro
}
else
{
m_MicrosPendingUpdate.Remove((byte)m_MicroUpdatingProgress);
UpdateNextMicro();
}
}
}
