Beispiel #1
0
        private void readStatusSystem(byte[] array)
        {
            Structures.FlashResult buffer = new Structures.FlashResult();
            object obj = new Structures.FlashResult();

            StructConvert.ByteArrayToStructure(array, ref obj);
            buffer = (Structures.FlashResult)obj;

            Enums.Status status;

/*			if (commandOut != Enums.Commands.StatusSystem)
 *                      {
 *                              if (commandOut == Enums.Commands.ReadFlash)
 *                              {
 *                                      MainWindow.Logger.Info("Чтение EEPROM завершено");
 *                                      Device.StatusProgress = Enums.StatusProgress.Finish;
 *                                      // TODO разрешить работать кнопке сохранить ЕЕПРОМ
 *                              }
 *                              commandOut = Enums.Commands.ZeroCommand;
 *                      }
 */         status = (Enums.Status)buffer.Status;
            if (status != Enums.Status.OK)
            {
                MainWindow.Logger.Error("Ошибка операции: {0}", status);
                commandOut            = Enums.Commands.ZeroCommand;
                Device.StatusProgress = Enums.StatusProgress.Alarm;                //Finish
                Function = Enums.FunctionalMode.Disable;
            }
        }
Beispiel #2
0
        private void readProgramVerifyFlash(byte[] array)
        {
            Structures.FlashResult buffer = new Structures.FlashResult();
            object obj = new Structures.FlashResult();

            StructConvert.ByteArrayToStructure(array, ref obj);
            buffer = (Structures.FlashResult)obj;

            Enums.Status status = (Enums.Status)buffer.Status;
            if (status != Enums.Status.OK)
            {
                MainWindow.Logger.Error("Ошибка операции: {0}", status);
                commandOut            = Enums.Commands.ZeroCommand;
                Device.StatusProgress = Enums.StatusProgress.Alarm;
                Function = Enums.FunctionalMode.Disable;
            }
            //Device.AddressOffset += Device.LengthSend; // TODO uncomment
            if (TaskToProcess == 1)
            {
                TaskToProcess = 0;
            }
        }
Beispiel #3
0
        private void readVersionSoft(byte[] array)
        {
            Structures.FlashVersion buffer = new Structures.FlashVersion();
            object obj = new Structures.FlashVersion();

            StructConvert.ByteArrayToStructure(array, ref obj);
            buffer = (Structures.FlashVersion)obj;

            Device.InfoDevice.DeviceAddress     = buffer.FromNetAddress;
            Device.InfoDevice.VersionBootloader = buffer.VersionBootLoader;
            Device.InfoDevice.Machine           = (Enums.Machine)buffer.Machine;
            Device.InfoDevice.NumberMachine     = buffer.NumberMachine;
            Device.InfoDevice.TypeCpu           = (Enums.CpuIdentificator)buffer.TypeCpu;

            Device.InfoDevice.AddressUserCodeBegin = buffer.AddressUserCodeBegin;
            Device.InfoDevice.AddressUserCodeEnd   = buffer.AddressUserCodeEnd;

            Device.InfoDevice.AddressEepromBegin = buffer.AddressEepromBegin;
            Device.InfoDevice.AddressEepromEnd   = buffer.AddressEepromEnd;

            Function = Enums.FunctionalMode.Disable;
        }
Beispiel #4
0
        private void readEraseFlash(byte[] array)
        {
            Structures.FlashResult buffer = new Structures.FlashResult();
            object obj = new Structures.FlashResult();

            StructConvert.ByteArrayToStructure(array, ref obj);
            buffer = (Structures.FlashResult)obj;

            Enums.Status status = (Enums.Status)buffer.Status;
            if (status != Enums.Status.OK)
            {
                MainWindow.Logger.Error("Ошибка операции: {0}", status);
                Device.StatusProgress = Enums.StatusProgress.Alarm;
                Function = Enums.FunctionalMode.Disable;
            }
            else
            {
                MainWindow.Logger.Trace("Очистка завершена");
                Device.StatusProgress = Enums.StatusProgress.Finish;
                Function = Enums.FunctionalMode.Disable;
            }

            commandOut = Enums.Commands.ZeroCommand;
        }
Beispiel #5
0
        private void readReadFlash(byte[] array)
        {
            Structures.FlashReadWrite buffer = new Structures.FlashReadWrite();
            object obj = new Structures.FlashReadWrite();

            StructConvert.ByteArrayToStructure(array, ref obj);
            buffer = (Structures.FlashReadWrite)obj;

            if (Function == Enums.FunctionalMode.ReadEeprom)
            {
                if (buffer.LengthData == 0)                 // Чтение завершено
                {
                    MainWindow.Logger.Trace("Чтение EEPROM завершено");
                    Device.StatusProgress = Enums.StatusProgress.Finish;
                    Function = Enums.FunctionalMode.Disable;
                }

                for (int i = 0; i < buffer.LengthData * 2; i++)
                {
                    Device.EepromData.Add(buffer.Data[i]);
                }
            }
            else if (Function == Enums.FunctionalMode.ReadFlash)
            {
                for (int i = 0; i < buffer.LengthData * 2; i++)
                {
                    Device.FlashData.Add(buffer.Data[i]);
                }

                if (buffer.LengthData == 0)                 // Чтение завершено
                {
                    MainWindow.Logger.Trace("Чтение Flash завершено");
                    Device.StatusProgress = Enums.StatusProgress.Finish;
                    Function = Enums.FunctionalMode.Disable;
                }
            }
            else if (Function == Enums.FunctionalMode.ReadRegion)
            {
                for (int i = 0; i < buffer.LengthData * 2; i++)
                {
                    Device.RegionData.Add(buffer.Data[i]);
                }

                if (buffer.LengthData == 0)                 // Чтение завершено
                {
                    MainWindow.Logger.Trace("Чтение области завершено");
                    Device.StatusProgress = Enums.StatusProgress.Finish;
                    Function = Enums.FunctionalMode.Disable;
                }
            }

            if (buffer.LengthData != 0)
            {
                Device.StatusProgress = Enums.StatusProgress.Inderterminate;
            }

            if (TaskToProcess == 1)
            {
                TaskToProcess = 0;
            }
        }
Beispiel #6
0
        public byte[] PrepareMessage(bool answered)
        {
            byte[]         array   = null;
            Enums.Commands command = Enums.Commands.ZeroCommand;
            ushort         task    = TaskToProcess;

            try
            {
                switch (Function)
                {
                case Enums.FunctionalMode.Disable:
                    command = Enums.Commands.StatusSystem;
                    break;

                case Enums.FunctionalMode.VersionSoftware:
                    command = Enums.Commands.VersionSoft;
                    break;

                case Enums.FunctionalMode.EraseEeprom:
                    Device.StatusProgress = Enums.StatusProgress.Inderterminate;

                    command             = Enums.Commands.EraseFlash;
                    Device.AddressBegin = Device.InfoDevice.AddressEepromBegin;
                    Device.AddressEnd   = Device.InfoDevice.AddressEepromEnd;
                    break;

                case Enums.FunctionalMode.EraseFlash:
                    Device.StatusProgress = Enums.StatusProgress.Inderterminate;

                    command             = Enums.Commands.EraseFlash;
                    Device.AddressBegin = Device.InfoDevice.AddressUserCodeBegin;
                    Device.AddressEnd   = Device.InfoDevice.AddressUserCodeEnd;
                    break;

                case Enums.FunctionalMode.EraseRegion:
                    Device.StatusProgress = Enums.StatusProgress.Inderterminate;

                    command             = Enums.Commands.EraseFlash;
                    Device.AddressBegin = Device.Region.BeginAddress;
                    Device.AddressEnd   = Device.Region.EndAddress;
                    break;

                case Enums.FunctionalMode.ProgramEeprom:
                case Enums.FunctionalMode.ProgramFlash:
                case Enums.FunctionalMode.ProgramRegion:
                    if (Device.DataToWrite == null)
                    {
                        break;
                    }
                    if (Device.DataToWrite.Count == 0)
                    {
                        break;
                    }
                    Device.StatusProgress = Enums.StatusProgress.Work;
                    command = Enums.Commands.ProgramVerifyFlash;
                    if (task == 0 && !answered)
                    {
                        task = 2;
                    }
                    if (Device.DataToWrite.Count - Device.AddressOffset == 0)
                    {
                        Device.StatusProgress = Enums.StatusProgress.Finish;
                        Function = Enums.FunctionalMode.Disable;
                        command  = Enums.Commands.ZeroCommand;
                        MainWindow.Logger.Trace("Запись завершена");
                    }
                    break;

                case Enums.FunctionalMode.ReadEeprom:
                case Enums.FunctionalMode.ReadFlash:
                case Enums.FunctionalMode.ReadRegion:
                    if (task == 0 && !answered)
                    {
                        task = 2;
                    }
                    command = Enums.Commands.ReadFlash;
                    break;
                }

//				if (command == Enums.Commands.ZeroCommand)
//					command = commandOut;
                switch (command)
                {
                case Enums.Commands.ZeroCommand:
                    array = prepareStatusSystem();
                    break;

                case Enums.Commands.VersionSoft:
                    array = prepareVersionSoft();
                    break;

                case Enums.Commands.StatusSystem:
                    array = prepareStatusSystem();
                    break;

                case Enums.Commands.ReadFlash:
                    array = prepareReadFlash(task);
                    break;

                case Enums.Commands.EraseFlash:
                    array = prepareEraseFlash(task);
                    break;

                case Enums.Commands.ProgramVerifyFlash:
                    array = prepareProgramVerifyFlash(task);
                    break;

                case Enums.Commands.FinishProgramFlash:
                    array = null;
                    break;

                case Enums.Commands.RebootDevice:
                    array = null;
                    break;
                }
            }
            catch (Exception ex)
            {
                MainWindow.Logger.Error(ex);
            }
            return(array);
        }
Beispiel #7
0
 public void SetFunction(Enums.FunctionalMode function)
 {
     Function      = function;
     TaskToProcess = 1;
 }