Ejemplo n.º 1
0
        private void FromDosFormat(byte[] bytes)
        {
            DateTime      = bytes.GetString(0, 26);
            Signature     = bytes.GetString(26, 4);
            PanelNumber   = bytes.ToUInt16(30);
            NetworkNumber = bytes.ToUInt16(32);
            Version       = bytes.ToUInt16(34);
            MiniVersion   = bytes.ToUInt16(36);
            Reserved      = bytes.ToBytes(38, 32);
            if (Version < 210 || Version == 0x2020)
            {
                throw new Exception($"Data not loaded. Data version less than 2.10. {this.PropertiesText()}");
            }

            Length = bytes.Length;
            Coef   = ((Length * 1000L) / 20000L) * 1000L +
                     (((Length * 1000L) % 20000L) * 1000L) / 20000L;
            //float coef = (float)length/20.;

            //Main block
            var offset = 70;
            //var l = MaxConstants.MAX_TBL_BANK;
            var maxPrg = 0;
            var maxGrp = 0;

            for (var i = PointType.OUT; i <= PointType.UNIT; ++i)
            {
                if (i == PointType.TZ)
                {
                    continue;
                }

                if (i == PointType.AMON)
                {
                    if (Version < 230 && MiniVersion >= 230)
                    {
                        throw new Exception($"Versions conflict! {this.PropertiesText()}");
                    }
                    if (Version >= 230 && MiniVersion > 0)
                    {
                        continue;
                    }
                }

                if (i == PointType.ALARMM)
                {
                    if (Version < 216)
                    {
                        var size = bytes.ToUInt16(offset);
                        offset += 2;
                        var count = bytes.ToUInt16(offset);
                        offset += 2;
                        for (var j = 0; j < count; ++j)
                        {
                            //var data = bytes.ToBytes(offset, size);
                            offset += size;
                            //Alarms.Add(data);
                        }
                        continue;
                    }
                }
                else
                {
                    var count = bytes.ToUInt16(offset);
                    offset += 2;
                    var size = bytes.ToUInt16(offset);
                    offset += 2;

                    if (i == PointType.PRG)
                    {
                        maxPrg = count;
                    }
                    if (i == PointType.GRP)
                    {
                        maxGrp = count;
                    }
                    //if (count == info[i].str_size)
                    {
                        // fread(info[i].address, nitem, l, h);
                    }
                    for (var j = 0; j < count; ++j)
                    {
                        var data = bytes.ToBytes(offset, size);
                        offset += size;
                        switch (i)
                        {
                        case PointType.VAR:
                            Variables.Add(new VariablePoint(data, 0, FileVersion));
                            break;

                        case PointType.UNIT:
                            CustomUnits.Digital.Add(new CustomDigitalUnitsPoint(data, 0, FileVersion));
                            break;

                        default:
                            //Unknown.Add(data);
                            break;
                        }
                    }
                    //Console.WriteLine(string.Join(Environment.NewLine,
                    //    prg.Alarms.Select(c=>new string(c)).Where(c => !string.IsNullOrWhiteSpace(c))));
                    //offset += size * count + 2;
                }
            }

            //var l = Math.Min(maxPrg, tbl_bank[PRG]);
            for (var i = 0; i < maxPrg; ++i)
            {
                var size = bytes.ToUInt16(offset);
                offset += 2;
                //var data =
                bytes.ToBytes(offset, size);
                offset += size;
            }

            {
                var size = bytes.ToUInt16(offset);
                offset += 2;
                //prg.WrTimes = reader.ReadBytes(size);
                var schedulesCount = SchedulePoint.GetCount(FileVersion);
                //var schedulesSize = SchedulePoint.GetSize(FileVersion);
                for (var j = 0; j < size; j += schedulesCount * schedulesCount)
                {
                    //var list = new List<WrOneDay>();
                    for (var k = 0; k < schedulesCount; ++k)
                    {
                        //var data = bytes.ToBytes(offset, schedulesCount);
                        offset += schedulesCount;
                        //list.Add(WrOneDay.FromBytes(data));
                    }

                    //WrTimes.Add(list);
                }
            }

            {
                var size = bytes.ToUInt16(offset);
                offset += 2;
                var holidaySize = HolidayPoint.GetSize(FileVersion);
                for (var j = 0; j < size; j += holidaySize)
                {
                    //var data = bytes.ToBytes(offset, holidaySize);
                    offset += holidaySize;
                    //ArDates.Add(data);
                }
            }

            {
                //var size =
                bytes.ToUInt16(offset);
                offset += 2;
            }

            for (var i = 0; i < maxGrp; ++i)
            {
                var size = bytes.ToUInt16(offset);
                offset += 2;
                //var data = bytes.ToBytes(offset, size);
                offset += size;

                //GrpDatas.Add(data);
            }

            {
                //var size = bytes.ToUInt16(offset);
                offset += 2;

                //for (var j = 0; j < MaxConstants.MAX_ICON_NAME_TABLE; ++j)
                {
                    //var data = bytes.ToBytes(offset, SizeConstants.ICON_NAME_TABLE_SIZE);
                    //offset += SizeConstants.ICON_NAME_TABLE_SIZE;
                    //prg.IconNameTable.Add(data);
                }
            }

            RawData = bytes;
        }
Ejemplo n.º 2
0
        private void FromCurrentFormat(byte[] bytes, int offset = 0)
        {
            Signature = bytes.GetString(0, 2);
            Version   = bytes.ToByte(2);
            Length    = bytes.Length;

            offset += 3;
            int parts = 1;

            this.parentClass?.PassMessage(parts, $"PRG Header 1 - Offset {offset}");


            //Get all inputs
            Inputs.AddRange(GetArray(bytes,
                                     InputPoint.GetCount(FileVersion),
                                     InputPoint.GetSize(FileVersion), ref offset)
                            .Select(i => new InputPoint(i, 0, FileVersion)));

            parts += Inputs.Count;
            this.parentClass?.PassMessage(parts, $"InputPoints {Inputs.Count} - Offset {offset}");


            //Get all outputs
            Outputs.AddRange(GetArray(bytes,
                                      OutputPoint.GetCount(FileVersion),
                                      OutputPoint.GetSize(FileVersion), ref offset)
                             .Select(i => new OutputPoint(i, 0, FileVersion)));

            parts += Outputs.Count;
            this.parentClass?.PassMessage(parts, $"OutputPoints {Outputs.Count} - Offset {offset}");


            //Get all variables
            Variables.AddRange(GetArray(bytes,
                                        VariablePoint.GetCount(FileVersion),
                                        VariablePoint.GetSize(FileVersion), ref offset)
                               .Select(i => new VariablePoint(i, 0, FileVersion)));
            parts += Variables.Count;
            this.parentClass?.PassMessage(parts, $"VariablePoints {Variables.Count} - Offset {offset}");

            //Get all programs
            Programs.AddRange(GetArray(bytes,
                                       ProgramPoint.GetCount(FileVersion),
                                       ProgramPoint.GetSize(FileVersion), ref offset)
                              .Select(i => new ProgramPoint(i, 0, FileVersion)));

            parts += Programs.Count;
            this.parentClass?.PassMessage(parts, $"ProgramPoints {Programs.Count} - Offset {offset}");

            //Get all controllers
            Controllers.AddRange(GetArray(bytes,
                                          ControllerPoint.GetCount(FileVersion),
                                          ControllerPoint.GetSize(FileVersion), ref offset)
                                 .Select(i => new ControllerPoint(i, 0, FileVersion)));

            parts += Controllers.Count;
            this.parentClass?.PassMessage(parts, $"ControllerPoints {Controllers.Count} - Offset {offset}");

            //Get all screens
            Screens.AddRange(GetArray(bytes,
                                      ScreenPoint.GetCount(FileVersion),
                                      ScreenPoint.GetSize(FileVersion), ref offset)
                             .Select(i => new ScreenPoint(i, 0, FileVersion)));

            parts += Screens.Count;
            this.parentClass?.PassMessage(parts, $"ScreenPoints {Screens.Count} - Offset {offset}");

            //Get all graphics

            //TODO: NOT MINE: Constants to object static Size(FileVersion) Count(FileVersion)

            Graphics.AddRange(GetArray(bytes,
                                       GraphicPoint.GetCount(FileVersion),
                                       GraphicPoint.GetSize(FileVersion), ref offset)
                              .Select(i => new GraphicPoint(i, 0, FileVersion)));

            parts += Graphics.Count;
            this.parentClass?.PassMessage(parts, $"GraphicPoints {Graphics.Count} - Offset {offset}");

            Users.AddRange(GetArray(bytes,
                                    UserPoint.GetCount(FileVersion),
                                    UserPoint.GetSize(FileVersion), ref offset)
                           .Select(i => new UserPoint(i, 0, FileVersion)));

            parts += Users.Count;
            this.parentClass?.PassMessage(parts, $"UserPoints {Users.Count} - Offset {offset}");

            CustomUnits.Digital.AddRange(GetArray(bytes,
                                                  CustomDigitalUnitsPoint.GetCount(FileVersion),
                                                  CustomDigitalUnitsPoint.GetSize(FileVersion), ref offset)
                                         .Select(i => new CustomDigitalUnitsPoint(i, 0, FileVersion)));

            parts += CustomUnits.Digital.Count;
            this.parentClass?.PassMessage(parts, $"CustomUnits.DigitalPoints {CustomUnits.Digital.Count} - Offset {offset}");

            Tables.AddRange(GetArray(bytes,
                                     TablePoint.GetCount(FileVersion),
                                     TablePoint.GetSize(FileVersion), ref offset)
                            .Select(i => new TablePoint(i, 0, FileVersion)));

            parts += Tables.Count;
            this.parentClass?.PassMessage(parts, $"TablePoints {Tables.Count} - Offset {offset}");

            Settings = new Settings(
                GetObject(bytes, Settings.GetSize(FileVersion), ref offset), 0, FileVersion);

            parts += 1;
            this.parentClass?.PassMessage(parts, $"Settings 1 - Offset {offset}");

            Schedules.AddRange(GetArray(bytes,
                                        SchedulePoint.GetCount(FileVersion),
                                        SchedulePoint.GetSize(FileVersion), ref offset)
                               .Select(i => new SchedulePoint(i, 0, FileVersion)));

            parts += Schedules.Count;
            this.parentClass?.PassMessage(parts, $"SchedulePoints {Schedules.Count} - Offset {offset}");

            Holidays.AddRange(GetArray(bytes,
                                       HolidayPoint.GetCount(FileVersion),
                                       HolidayPoint.GetSize(FileVersion), ref offset)
                              .Select(i => new HolidayPoint(i, 0, FileVersion)));

            parts += Holidays.Count;
            this.parentClass?.PassMessage(parts, $"HolidayPoints {Holidays.Count} - Offset {offset}");

            Monitors.AddRange(GetArray(bytes,
                                       MonitorPoint.GetCount(FileVersion),
                                       MonitorPoint.GetSize(FileVersion), ref offset)
                              .Select(i => new MonitorPoint(i, 0, FileVersion)));

            parts += Monitors.Count;
            this.parentClass?.PassMessage(parts, $"MonitorPoints {Monitors.Count} - Offset {offset}");

            ScheduleCodes.AddRange(GetArray(bytes,
                                            ScheduleCode.GetCount(FileVersion),
                                            ScheduleCode.GetSize(FileVersion), ref offset)
                                   .Select(i => new ScheduleCode(i, 0, FileVersion)));

            parts += ScheduleCodes.Count;
            this.parentClass?.PassMessage(parts, $"ScheduleCodes {ScheduleCodes.Count} - Offset {offset}");

            HolidayCodes.AddRange(GetArray(bytes,
                                           HolidayCode.GetCount(FileVersion),
                                           HolidayCode.GetSize(FileVersion), ref offset)
                                  .Select(i => new HolidayCode(i, 0, FileVersion)));

            parts += HolidayCodes.Count;
            this.parentClass?.PassMessage(parts, $"HolidayCodes {HolidayCodes.Count} - Offset {offset}");


            int pcode_offset     = offset;
            var ProgramCodeBytes = bytes.ToBytes(offset, ProgramCode.GetSize(FileVersion));

            ProgramCodes.AddRange(GetArray(bytes,
                                           ProgramCode.GetCount(FileVersion),
                                           ProgramCode.GetSize(FileVersion), ref offset)
                                  //.Select(i => new ProgramCode(i, this, 0, FileVersion)));
                                  .Select(i => new ProgramCode()));

            ProgramCodes[0] = new ProgramCode(ProgramCodeBytes, this, 0, FileVersion);

            parts += 1;
            this.parentClass?.PassMessage(parts, $"ProgramCodes 1 - Offset {pcode_offset+2000}");


            for (int i = 1; i < ProgramCode.GetCount(FileVersion); i++)
            {
                pcode_offset    += ProgramCode.GetSize(FileVersion);
                ProgramCodeBytes = bytes.ToBytes(pcode_offset, ProgramCode.GetSize(FileVersion));
                ProgramCodes[i]  = new ProgramCode(ProgramCodeBytes, this, 0, FileVersion);

                parts += 1;
                this.parentClass?.PassMessage(parts, $"ProgramCodes {i+1} - Offset {pcode_offset+2000}");

                //Debug.WriteLine($"Leído ProgramCode[{i}]");
            }



            CustomUnits.Analog.AddRange(GetArray(bytes,
                                                 CustomAnalogUnitsPoint.GetCount(FileVersion),
                                                 CustomAnalogUnitsPoint.GetSize(FileVersion), ref offset)
                                        .Select(i => new CustomAnalogUnitsPoint(i, 0, FileVersion)));

            parts += CustomUnits.Analog.Count;
            this.parentClass?.PassMessage(parts, $"CustomUnits.AnalogPoints {CustomUnits.Analog.Count} - Offset {offset}");

            CheckOffset(offset, Length);

            UpdateCustomUnits();
        }
Ejemplo n.º 3
0
        private void FromCurrentFormat(byte[] bytes, int offset = 0)
        {
            Signature = bytes.GetString(0, 2);
            Version   = bytes.ToByte(2);
            Length    = bytes.Length;

            offset += 3;

            //Get all inputs
            Inputs.AddRange(GetArray(bytes,
                                     InputPoint.GetCount(FileVersion),
                                     InputPoint.GetSize(FileVersion), ref offset)
                            .Select(i => new InputPoint(i, 0, FileVersion)));

            //Get all outputs
            Outputs.AddRange(GetArray(bytes,
                                      OutputPoint.GetCount(FileVersion),
                                      OutputPoint.GetSize(FileVersion), ref offset)
                             .Select(i => new OutputPoint(i, 0, FileVersion)));

            //Get all variables
            Variables.AddRange(GetArray(bytes,
                                        VariablePoint.GetCount(FileVersion),
                                        VariablePoint.GetSize(FileVersion), ref offset)
                               .Select(i => new VariablePoint(i, 0, FileVersion)));

            //Get all programs
            Programs.AddRange(GetArray(bytes,
                                       ProgramPoint.GetCount(FileVersion),
                                       ProgramPoint.GetSize(FileVersion), ref offset)
                              .Select(i => new ProgramPoint(i, 0, FileVersion)));

            //Get all controllers
            Controllers.AddRange(GetArray(bytes,
                                          ControllerPoint.GetCount(FileVersion),
                                          ControllerPoint.GetSize(FileVersion), ref offset)
                                 .Select(i => new ControllerPoint(i, 0, FileVersion)));

            //Get all screens
            Screens.AddRange(GetArray(bytes,
                                      ScreenPoint.GetCount(FileVersion),
                                      ScreenPoint.GetSize(FileVersion), ref offset)
                             .Select(i => new ScreenPoint(i, 0, FileVersion)));

            //Get all graphics

            //TODO: Constants to object static Size(FileVersion) Count(FileVersion)

            Graphics.AddRange(GetArray(bytes,
                                       GraphicPoint.GetCount(FileVersion),
                                       GraphicPoint.GetSize(FileVersion), ref offset)
                              .Select(i => new GraphicPoint(i, 0, FileVersion)));

            Users.AddRange(GetArray(bytes,
                                    UserPoint.GetCount(FileVersion),
                                    UserPoint.GetSize(FileVersion), ref offset)
                           .Select(i => new UserPoint(i, 0, FileVersion)));

            CustomUnits.Digital.AddRange(GetArray(bytes,
                                                  CustomDigitalUnitsPoint.GetCount(FileVersion),
                                                  CustomDigitalUnitsPoint.GetSize(FileVersion), ref offset)
                                         .Select(i => new CustomDigitalUnitsPoint(i, 0, FileVersion)));

            Tables.AddRange(GetArray(bytes,
                                     TablePoint.GetCount(FileVersion),
                                     TablePoint.GetSize(FileVersion), ref offset)
                            .Select(i => new TablePoint(i, 0, FileVersion)));

            Settings = new Settings(
                GetObject(bytes, Settings.GetSize(FileVersion), ref offset), 0, FileVersion);

            Schedules.AddRange(GetArray(bytes,
                                        SchedulePoint.GetCount(FileVersion),
                                        SchedulePoint.GetSize(FileVersion), ref offset)
                               .Select(i => new SchedulePoint(i, 0, FileVersion)));

            Holidays.AddRange(GetArray(bytes,
                                       HolidayPoint.GetCount(FileVersion),
                                       HolidayPoint.GetSize(FileVersion), ref offset)
                              .Select(i => new HolidayPoint(i, 0, FileVersion)));

            Monitors.AddRange(GetArray(bytes,
                                       MonitorPoint.GetCount(FileVersion),
                                       MonitorPoint.GetSize(FileVersion), ref offset)
                              .Select(i => new MonitorPoint(i, 0, FileVersion)));

            ScheduleCodes.AddRange(GetArray(bytes,
                                            ScheduleCode.GetCount(FileVersion),
                                            ScheduleCode.GetSize(FileVersion), ref offset)
                                   .Select(i => new ScheduleCode(i, 0, FileVersion)));

            HolidayCodes.AddRange(GetArray(bytes,
                                           HolidayCode.GetCount(FileVersion),
                                           HolidayCode.GetSize(FileVersion), ref offset)
                                  .Select(i => new HolidayCode(i, 0, FileVersion)));


            int pcode_offset     = offset;
            var ProgramCodeBytes = bytes.ToBytes(offset, ProgramCode.GetSize(FileVersion));

            ProgramCodes.AddRange(GetArray(bytes,
                                           ProgramCode.GetCount(FileVersion),
                                           ProgramCode.GetSize(FileVersion), ref offset)
                                  //.Select(i => new ProgramCode(i, this, 0, FileVersion)));
                                  .Select(i => new ProgramCode()));

            ProgramCodes[0] = new ProgramCode(ProgramCodeBytes, this, 0, FileVersion);


            for (int i = 1; i < ProgramCode.GetCount(FileVersion); i++)
            {
                pcode_offset    += ProgramCode.GetSize(FileVersion);
                ProgramCodeBytes = bytes.ToBytes(pcode_offset, ProgramCode.GetSize(FileVersion));
                ProgramCodes[i]  = new ProgramCode(ProgramCodeBytes, this, 0, FileVersion);
                Debug.WriteLine($"Leído ProgramCode[{i}]");
            }



            CustomUnits.Analog.AddRange(GetArray(bytes,
                                                 CustomAnalogUnitsPoint.GetCount(FileVersion),
                                                 CustomAnalogUnitsPoint.GetSize(FileVersion), ref offset)
                                        .Select(i => new CustomAnalogUnitsPoint(i, 0, FileVersion)));

            CheckOffset(offset, Length);

            UpdateCustomUnits();
        }