Beispiel #1
0
        public static LEDDisplaysDictionary Load(XmlNode xml)
        {
            LEDDisplaysDictionary result = new LEDDisplaysDictionary();

            result._default = (byte)(int.Parse(xml.Attributes["default"].Value) & 0xff);
            result._dot     = (byte)(int.Parse(xml.Attributes["dot"].Value) & 0xff);
            XmlNodeList nodes = xml.SelectNodes("dotChars/char");

            foreach (XmlNode node in nodes)
            {
                char c = node.Attributes["chr"].Value[0];
                if (!result._charsForDots.Contains(c))
                {
                    result._charsForDots.Add(c);
                }
            }
            nodes = xml.SelectNodes("char");
            foreach (XmlNode node in nodes)
            {
                byte v = (byte)(int.Parse(node.Attributes["value"].Value) & 0xff);
                char c = node.Attributes["chr"].Value[0];
                if (!result._charDictionary.ContainsKey(c))
                {
                    result._charDictionary.Add(c, v);
                }
            }
            return(result);
        }
        public static string FormatText(LEDDisplaysDictionary dictionary, Align align, Trim trim, Append append, string appendString, int characters, string text, out int start)
        {
            if (text == null || text.Length == 0)
            {
                text = "";
            }

            int dotsCount = 0;

            for (int i = 0; i < text.Length; i++)
            {
                if (dictionary.IsDotChar(text[i]))
                {
                    dotsCount++;
                }
            }

            int textLength = text.Length - dotsCount;

            if (append != Append.None)
            {
                while (appendString.Length < characters)
                {
                    appendString += appendString;
                }
            }

            start = 0;

            if (textLength > characters)
            {
                if (trim == Trim.Right)
                {
                    text = text.Substring(0, characters);
                }
                else
                {
                    text = text.Substring(textLength - characters, characters);
                }
            }
            else
            {
                if (textLength < characters)
                {
                    int dif = characters - textLength;
                    if (append == Append.Left)
                    {
                        text = appendString.Substring(0, dif) + text;
                    }
                    else if (append == Append.Right)
                    {
                        text = text + appendString.Substring(appendString.Length - dif, dif);
                    }
                    else if (align != Align.Left)
                    {
                        if (align == Align.Center)
                        {
                            start = characters / 2 - textLength / 2;
                        }
                        else if (align == Align.Right)
                        {
                            start = characters - textLength;
                        }
                    }
                }
            }
            return(text);
        }
        public static XMLConfiguration Load()
        {
            if (__instance != null)
            {
                return(__instance);
            }

            if (!File.Exists(ConfigurationFilePath))
            {
                throw new FileNotFoundException(ConfigurationFilePath);
            }
            XMLConfiguration c   = new XMLConfiguration();
            XmlDocument      xml = new XmlDocument();

            xml.Load(ConfigurationFilePath);

            // wczytanie interfejsów
            List <RS232Configuration> interfaces = new List <RS232Configuration>();
            XmlNodeList nodes = xml.SelectNodes("/configuration/interfaces/interface");

            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    RS232Configuration interf = RS232Configuration.Load(node);
                    interfaces.Add(interf);
                }
            }
            c.Interfaces = interfaces.ToArray();

            // wczytanie urządzeń z LCD
            List <LCDDevice> lcdDevices = new List <LCDDevice>();

            nodes = xml.SelectNodes("/configuration/lcdDevices/lcdDevice");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    LCDDevice lcdDevice = LCDDevice.Load(node, interfaces);
                    if (lcdDevice != null)
                    {
                        lcdDevices.Add(lcdDevice);
                    }
                }
            }
            c.LCDDevices = lcdDevices.ToArray();

            // wczytanie LCD
            List <RS232LCD> lcds = new List <RS232LCD>();

            nodes = xml.SelectNodes("/configuration/lcds/lcd");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    RS232LCD lcd = RS232LCD.Load(lcdDevices, node);
                    if (lcd != null)
                    {
                        lcds.Add(lcd);
                    }
                }
            }
            c.LCDs = lcds.ToArray();

            // wczytanie obszarów LCD
            List <LCDArea> areas = new List <LCDArea>();

            nodes = xml.SelectNodes("/configuration/lcdAreas/area");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    LCDArea area = new LCDArea(node, new LCDSet(lcds));
                    areas.Add(area);
                }
            }
            c.Areas = areas.ToArray();

            // wczytanie urządzeń z LED
            List <LEDDevice> ledDevices = new List <LEDDevice>();

            nodes = xml.SelectNodes("/configuration/ledDevices/ledDevice");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    LEDDevice ledDevice = LEDDevice.Load(node, interfaces);
                    if (ledDevice != null)
                    {
                        ledDevices.Add(ledDevice);
                    }
                }
            }
            c.LEDDevices = ledDevices.ToArray();

            // wczytanie LED
            List <LED> leds = new List <LED>();

            nodes = xml.SelectNodes("/configuration/leds/led");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    LED led = LED.Load(node, ledDevices);
                    if (led != null)
                    {
                        leds.Add(led);
                    }
                }
            }
            c.LEDs = leds.ToArray();

            // wczytanie obszarów LED
            List <LEDGroup> ledGroups = new List <LEDGroup>();

            nodes = xml.SelectNodes("/configuration/leds/leds");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    LEDGroup ledGroup = LEDGroup.Load(node, leds);
                    if (ledGroup != null)
                    {
                        ledGroups.Add(ledGroup);
                    }
                }
            }
            c.LEDGroups = ledGroups.ToArray();

            // wczytanie urządzeń z 7-LED
            List <LEDDisplayDevice> ledDisplayDevices = new List <LEDDisplayDevice>();

            nodes = xml.SelectNodes("/configuration/ledDisplayDevices/ledDisplayDevice");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    LEDDisplayDevice ledDisplayDevice = LEDDisplayDevice.Load(node, interfaces);
                    if (ledDisplayDevice != null)
                    {
                        ledDisplayDevices.Add(ledDisplayDevice);
                    }
                }
            }
            c.LEDDisplayDevices = ledDisplayDevices.ToArray();

            // wczytanie 7-LED
            List <LEDDisplay> ledDisplays = new List <LEDDisplay>();

            nodes = xml.SelectNodes("/configuration/ledDisplays/ledDisplay");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    LEDDisplay ledDisplay = LEDDisplay.Load(node, ledDisplayDevices);
                    if (ledDisplay != null)
                    {
                        ledDisplays.Add(ledDisplay);
                    }
                }
            }
            c.LEDDisplays = ledDisplays.ToArray();

            // wczytanie obszarów 7-LED
            List <LEDDisplayGroup> ledDisplayGroups = new List <LEDDisplayGroup>();

            nodes = xml.SelectNodes("/configuration/ledDisplays/ledDisplays");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    LEDDisplayGroup ledDisplayGroup = LEDDisplayGroup.Load(node, ledDisplays);
                    if (ledDisplayGroup != null)
                    {
                        ledDisplayGroups.Add(ledDisplayGroup);
                    }
                }
            }
            c.LEDDisplayGroups = ledDisplayGroups.ToArray();

            // wczytanie słownika dla wyświetlaczy 7-segmentowych
            XmlNode dictionaryNode = xml.SelectSingleNode("/configuration/ledDisplaysDictionary");

            c.LEDDisplaysDictionary = LEDDisplaysDictionary.Load(dictionaryNode);

            // wczytanie urządzeń Keys
            List <KeysDevice> keysDevices = new List <KeysDevice>();

            nodes = xml.SelectNodes("/configuration/keysDevices/keysDevice");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    KeysDevice keysDevice = KeysDevice.Load(node, interfaces);
                    if (keysDevice != null)
                    {
                        keysDevices.Add(keysDevice);
                    }
                }
            }
            c.KeysDevices = keysDevices.ToArray();

            // wczytanie keys
            List <Key> keys = new List <Key>();

            nodes = xml.SelectNodes("/configuration/keys/key");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    Key key = Key.Load(node, keysDevices);
                    if (key != null)
                    {
                        keys.Add(key);
                    }
                }
            }
            c.Keys = keys.ToArray();

            // wczytanie encoders
            List <Encoder> encoders = new List <Encoder>();

            nodes = xml.SelectNodes("/configuration/encoders/encoder");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    Encoder encoder = Encoder.Load(node, keysDevices);
                    if (encoder != null)
                    {
                        encoders.Add(encoder);

                        // przypisanie enkoderów do wejść (wykrywanie szybkiego kręcenia)
                        foreach (Key key in c.Keys)
                        {
                            if (key.KeysDevice == encoder.KeysDevice)
                            {
                                if (key.Index == encoder.LeftIndex || key.Index == encoder.RightIndex)
                                {
                                    key.Encoder = encoder;
                                }
                            }
                        }
                    }
                }
            }
            c.Encoders = encoders.ToArray();

            // wczytanie stepper motors
            List <StepperDevice> stepperDevices = new List <StepperDevice>();

            nodes = xml.SelectNodes("/configuration/stepperDevices/stepperDevice");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    StepperDevice stepperDevice = StepperDevice.Load(node, interfaces);
                    if (stepperDevice != null)
                    {
                        stepperDevices.Add(stepperDevice);
                    }
                }
            }
            c.StepperDevices = stepperDevices.ToArray();

            // wczytanie servo devices
            List <ServoDevice> servoDevices = new List <ServoDevice>();

            nodes = xml.SelectNodes("/configuration/servoDevices/servoDevice");
            if (nodes != null && nodes.Count > 0)
            {
                foreach (XmlNode node in nodes)
                {
                    ServoDevice servoDevice = ServoDevice.Load(node, interfaces);
                    if (servoDevice != null)
                    {
                        servoDevices.Add(servoDevice);
                    }
                }
            }
            c.ServoDevices = servoDevices.ToArray();


            __instance = c;

            return(__instance);
        }
        public void Save(string fileName)
        {
            using (XmlTextWriter xml = new XmlTextWriter(fileName, Encoding.UTF8))
            {
                xml.Formatting = System.Xml.Formatting.Indented;
                xml.WriteStartDocument(true);
                xml.WriteStartElement("configuration");

                xml.WriteStartElement("interfaces");
                foreach (RS232Configuration interf in Interfaces)
                {
                    interf.Save(xml);
                }
                xml.WriteEndElement();

                xml.WriteStartElement("lcdDevices");
                foreach (LCDDevice lcdDevice in LCDDevices)
                {
                    lcdDevice.SaveToXml(xml);
                }
                xml.WriteEndElement();

                xml.WriteStartElement("lcds");
                foreach (LCD lcd in LCDs)
                {
                    lcd.SaveToXml(xml);
                }
                xml.WriteEndElement();

                xml.WriteStartElement("lcdAreas");
                foreach (LCDArea area in Areas)
                {
                    area.SaveToXml(xml);
                }
                xml.WriteEndElement();

                xml.WriteStartElement("ledDevices");
                foreach (LEDDevice ledDevice in LEDDevices)
                {
                    ledDevice.SaveToXml(xml);
                }
                xml.WriteEndElement();

                xml.WriteStartElement("leds");
                foreach (LED led in LEDs)
                {
                    led.SaveToXml(xml);
                }
                foreach (LEDGroup ledGroup in LEDGroups)
                {
                    ledGroup.SaveToXml(xml);
                }
                xml.WriteEndElement();

                xml.WriteStartElement("ledDisplayDevices");
                foreach (LEDDisplayDevice ledDisplayDevice in LEDDisplayDevices)
                {
                    ledDisplayDevice.SaveToXml(xml);
                }
                xml.WriteEndElement();

                xml.WriteStartElement("ledDisplays");
                foreach (LEDDisplay ledDisplay in LEDDisplays)
                {
                    ledDisplay.SaveToXml(xml);
                }
                foreach (LEDDisplayGroup ledDisplayGroup in LEDDisplayGroups)
                {
                    ledDisplayGroup.SaveToXml(xml);
                }
                xml.WriteEndElement();

                LEDDisplaysDictionary.Save(xml);

                xml.WriteStartElement("keysDevices");
                foreach (KeysDevice keyDevice in KeysDevices)
                {
                    keyDevice.SaveToXml(xml);
                }
                xml.WriteEndElement();

                xml.WriteStartElement("keys");
                foreach (Key key in Keys)
                {
                    key.SaveToXml(xml);
                }
                xml.WriteEndElement();

                xml.WriteStartElement("encoders");
                foreach (Encoder encoder in Encoders)
                {
                    encoder.SaveToXml(xml);
                }
                xml.WriteEndElement();

                xml.WriteStartElement("stepperDevices");
                foreach (StepperDevice stepperDevice in StepperDevices)
                {
                    stepperDevice.SaveToXml(xml);
                }
                xml.WriteEndElement();

                xml.WriteStartElement("servoDevices");
                foreach (ServoDevice servoDevice in ServoDevices)
                {
                    servoDevice.SaveToXml(xml);
                }
                xml.WriteEndElement();

                xml.WriteEndElement();
                xml.WriteEndDocument();
            }
        }