Exemplo n.º 1
0
 public void StartDrive()
 {
     Console.WriteLine(DiveInfo.CarNum(this));
 }
Exemplo n.º 2
0
        static void Main(string[] args)
        {
            int currTime;

            byte helium, oxygen;

            byte bt;

            bool bFlgExit = false;
            bool bWPOpen;

            Dictionary<string, string> arguments = ParseCommandLine(args);

            if (arguments.Count < 1)
            {
                Console.WriteLine("ERROR: Неверное количество аргументов командной строки!");
                return;
            }
            string binFile;
            string uddfFile;
            if (!arguments.TryGetValue("binfile", out binFile))
            {
                Console.WriteLine("ERROR: Не определен binfile!");
                return;
            }
            if (!arguments.TryGetValue("uddffile", out uddfFile))
            {
                uddfFile = binFile.Replace(".bin", ".uddf");
            }

            List<DiveInfo> dives = new List<DiveInfo>();
            DiveInfo dive = new DiveInfo();
            BinaryReader file;
            try
            {
                 file = new BinaryReader(File.Open(binFile, FileMode.Open));
            }
            catch (Exception e)
            {
                Console.WriteLine(String.Format("Файл {0} не найден или занят.", binFile));
                return;
            }

            for (int i = 0; i < 121; i++)
            {
                dive.DiveNumber = file.ReadUInt32();
                dive.DateTime32 = file.ReadUInt32();
                dive.AirP = file.ReadSingle() * 100000;

                dive.DiveDateTime = ConvertDateTime(dive.DateTime32);

                dive.DivePositionBeg = file.ReadUInt32();
                dive.DivePositionEnd = file.ReadUInt32();
                dive.WarningFlags = file.ReadUInt32();

                dive.piN2 = new Single[16];
                dive.piHe = new Single[16];

                byte[] tmpArray = new byte[64];

                tmpArray = file.ReadBytes(64);
                for (int j = 0; j < 16; j++) dive.piN2[j] = BitConverter.ToSingle(tmpArray, j * 4);
                tmpArray = file.ReadBytes(64);
                for (int j = 0; j < 16; j++) dive.piHe[j] = BitConverter.ToSingle(tmpArray, j * 4);

                dive.CNS = file.ReadSingle();
                dive.DiveDuration = file.ReadInt32();

                dive.MaxDepth = file.ReadUInt16();
                dive.AvgDepth = file.ReadUInt16();
                dive.MinTemp = file.ReadInt32();

                if (dive.DiveDuration > 0)
                    dives.Add(dive);
                else
                    break;
            }

            XmlTextWriter logbook = new XmlTextWriter(uddfFile, Encoding.ASCII);
            logbook.WriteStartElement("uddf");
            logbook.WriteEndElement();
            logbook.Close();

            uddfDoc.Load(uddfFile);

            XmlNode uddf = uddfDoc.DocumentElement;

            XmlAttribute attr = uddfDoc.CreateAttribute("version"); // создаём атрибут
            attr.Value = "3.0.0"; // устанавливаем значение атрибута
            uddf.Attributes.Append(attr); // добавляем атрибут

            XmlNode xGenerator = AddNode(uddf, "generator");

            XmlNode xTmp = AddNodeWithInnerText(xGenerator, "name", "AV1c");

            xTmp = AddNodeWithInnerText(xGenerator, "type", "divecomputer");

            xTmp = AddNode(xGenerator, "manufacturer");

            AddNodeWithInnerText(xTmp, "name", "AV Underwater Technologies");

            xGasdefenition = AddNode(uddf, "gasdefinitions");

            XmlNode profiledata = AddNode(uddf, "profiledata");

            int group = 1;
            dive = dives[0];

            DateTime prevDate = dive.DiveDateTime;

            for (int i = 0; i < dives.Count; i++ )
            {
                dive = dives[i];

                if (i == 0)
                {
                    dive.RepetitionGroup = group;
                }
                else
                {
                    if ((dive.DiveDateTime.Subtract(prevDate)).Days > 2) group++;
                    dive.RepetitionGroup = group;
                    prevDate = dive.DiveDateTime;
                }

                dives[i] = dive;

            }

            dive = dives[0];

            XmlNode repetitiongroup = AddNodeWithAttribute(profiledata, "repetitiongroup", "id", "1");
            group = 1;

            for (int i = 0; i < dives.Count; i++)
            {

                dive = dives[i];

                if (dive.RepetitionGroup != group)
                {
                    repetitiongroup = AddNodeWithAttribute(profiledata, "repetitiongroup", "id", dive.RepetitionGroup.ToString());
                    group = dive.RepetitionGroup;
                }

                XmlNode xDive = AddNodeWithAttribute(repetitiongroup, "dive", "id", dive.DiveDateTime.ToString("s"));

                XmlNode xInfoBefore = AddNode(xDive, "informationbeforedive");

                AddNodeWithInnerText(xInfoBefore, "divenumber", dive.DiveNumber.ToString());

                AddNodeWithInnerText(xInfoBefore, "datetime", dive.DiveDateTime.ToString("s"));

                AddNodeWithInnerText(xInfoBefore, "surfacepressure", dive.AirP.ToString());

                XmlNode xSamples = AddNode(xDive, "samples");

                XmlNode xWaypoint = null;
                XmlNode xWaypointFirst = null;

                file.BaseStream.Position = dive.DivePositionBeg;

                bWPOpen = false;

                xWaypoint = uddfDoc.CreateElement("waypoint");

                byte[] buffer = new byte[dive.DivePositionEnd - dive.DivePositionBeg];
                int length = (int)dive.DivePositionEnd - (int)dive.DivePositionBeg + 2;
                buffer = file.ReadBytes(length);

                currTime = 0;
                for (int j = 0; j < length; j++)
                {

                    bt = buffer[j];

                    switch (bt)
                    {
                        case 0xF1: // Температура
                            bt = buffer[++j];
                            xTmp = AddNodeWithInnerText(xWaypoint, "temperature", String.Format(CultureInfo.InvariantCulture, "{0:F1}", (double)(273 + bt + 0.1)));
                            if (xWaypointFirst.SelectSingleNode("temperature") == null) xWaypointFirst.AppendChild(xTmp);
                            break;
                        case 0xF2:
                            bt = buffer[++j];
                            break;
                        case 0xF3:
                            bt = buffer[++j];
                            break;
                        case 0xF4: //Смена газа
                            bt = buffer[++j];
                            helium = bt;
                            bt = buffer[++j];
                            if (bt == 0xF4)
                            {
                                bt = buffer[++j];
                                oxygen = bt;
                                AddNodeWithAttribute(xWaypoint, "switchmix", "ref", getGas(oxygen, helium));
                            }
                            break;
                        case 0xF5:
                            bt = buffer[++j];
                            break;
                        case 0xF6: //Warning flags
                            bt = buffer[++j];
                            int iTmp1 = bt;
                            if ( (iTmp1 & 0x04) == 04) // PO2!
                            {
                                AddNodeWithInnerText(xWaypoint, "alarm", "error");
                            }
                            if ( (iTmp1 & 0x02) == 02) // Fast!
                            {
                                AddNodeWithInnerText(xWaypoint, "alarm", "ascent");
                            }
                            if ( (iTmp1 & 0x01) == 01) // Deco!
                            {
                                AddNodeWithInnerText(xWaypoint, "alarm", "deco");
                            }
                            break;
                        case 0xF7: //Динамический потолок
                            bt = buffer[++j];

                            XmlNode xDecostop = uddfDoc.CreateElement("decostop");

                            XmlAttribute xAttr = uddfDoc.CreateAttribute("kind"); // создаём атрибут
                            xAttr.Value = "mandatory";
                            xDecostop.Attributes.Append(xAttr);

                            xAttr = uddfDoc.CreateAttribute("decodepth");
                            xAttr.Value = bt.ToString() + ".0";
                            xDecostop.Attributes.Append(xAttr);

                            xAttr = uddfDoc.CreateAttribute("duration");
                            xAttr.Value = "60.0";
                            xDecostop.Attributes.Append(xAttr);

                            xWaypoint.AppendChild(xDecostop);

                            break;
                        case 0xF8:
                            bt = buffer[++j];
                            break;
                        case 0xF9: // NDL/TTS
                            bt = buffer[++j];
                            iTmp1 = bt;
                            iTmp1 = iTmp1 & 0x0F;
                            if (iTmp1 > 0 && bt >= 240)
                            {
                                AddNodeWithInnerText(xWaypoint, "nodecotime", String.Format(CultureInfo.InvariantCulture, "{0:F1}", iTmp1 * 60));
                            }
                            break;
                        case 0xFF:
                            if (bWPOpen)
                            {
                                xSamples.AppendChild(xWaypoint);
                                xWaypoint = uddfDoc.CreateElement("waypoint");
                            }
                            bFlgExit = true;
                            break;
                        default: //Значение глубины
                            if (bWPOpen)
                            {
                                xSamples.AppendChild(xWaypoint);
                                xWaypoint = uddfDoc.CreateElement("waypoint");
                            }

                            if (xWaypointFirst == null) xWaypointFirst = xWaypoint;

                            AddNodeWithInnerText(xWaypoint, "depth", bt.ToString() + ".0");
                            AddNodeWithInnerText(xWaypoint, "divetime", currTime.ToString() + ".0");

                            currTime += 10;
                            bWPOpen = true;
                            break;
                    }

                    if (bFlgExit)
                    {
                        break;
                    }

                }

                XmlNode xInfoAfter = AddNode(xDive, "informationafterdive");

                AddNodeWithInnerText(xInfoAfter, "greatestdepth", dive.MaxDepth.ToString());

                AddNodeWithInnerText(xInfoAfter, "averagedepth", String.Format(CultureInfo.InvariantCulture, "{0:F1}", (double)(dive.AvgDepth / 10.0)));

                AddNodeWithInnerText(xInfoAfter, "lowesttemperature", String.Format(CultureInfo.InvariantCulture, "{0:F1}", (double)(273.0 + (double)dive.MinTemp)));

                AddNodeWithInnerText(xInfoAfter, "diveduration", String.Format(CultureInfo.InvariantCulture, "{0:F1}", dive.DiveDuration * 60));
            }

            uddfDoc.Save(uddfFile);
            Console.WriteLine(String.Format("Переведено в формат UDDF {0} погружений.", dives.Count));
            Console.WriteLine(String.Format("UDDF Файл: {0}.", uddfFile));
        }