DP44/DataPRO/IService/Classes/Channels/UARTInputDASChannel.cs

using System;
using DTS.Common.Enums.DASFactory;
using System.Xml;
using System.IO.Ports;
using DTS.Common.Enums;
using DTS.Common.Utilities.Logging;

namespace DTS.DASLib.Service
{
    /// <summary>
    /// Class for storing/applying UART settings as a channel
    /// </summary>
    [Serializable]
    public class UARTInputDASChannel : InputDASChannel
    {
        /// <summary>
        /// CTOR to populate a channel's owning module and channel WRT that module.  Calls 
        /// base class CTOR.
        /// </summary>
        /// <param name="owner">Module that contains this channel.</param>
        /// <param name="channelNumber">ChannelNumber of this channel WRT owning module.</param>
        public UARTInputDASChannel(DASModule owner, int channelNumber)
            : base(owner, channelNumber)
        {
        }

        public UARTInputDASChannel()
        {
        }


        /// <summary>
        /// Serial number of the sensor.
        /// </summary>
        public string SerialNumber { get; set; }

        /// <summary>
        /// The name of the hardware channel
        /// </summary>
        public string HardwareChannelName { get; set; }

        public uint BaudRate { get; set; }

        public uint DataBits { get; set; }

        public StopBits StopBits { get; set; }

        public Parity Parity { get; set; }

        public Handshake FlowControl { get; set; }

        public UartDataFormat DataFormat { get; set; }

        /// <summary>
        /// If the channel has a serial number in the SerialNumber field, it is "Configured".
        /// </summary>
        public override bool IsConfigured()
        {
            return !string.IsNullOrEmpty(SerialNumber);
        }

        public override string ToString()
        {
            return $"UART{ModuleChannelNumber}";
        }
        public override void WriteXml(XmlWriter writer)
        {
            base.WriteXml(writer);

            // SerialNumber
            XMLHelper.PutString(writer, "SerialNumber", SerialNumber);
            XMLHelper.PutString(writer, "HardwareChannelName", HardwareChannelName);
            XMLHelper.PutString(writer, "BaudRate", BaudRate.ToString());
            XMLHelper.PutString(writer, "DataBits", DataBits.ToString());
            XMLHelper.PutString(writer, "StopBits", StopBits.ToString());
            XMLHelper.PutString(writer, "Parity", Parity.ToString());
            XMLHelper.PutString(writer, "FlowControl", FlowControl.ToString());
            XMLHelper.PutString(writer, "DataFormat", DataFormat.ToString());

        }
        private const string SERIALNUMBER_TAG = "SerialNumber";
        private const string HARDWARECHANNELNAME_TAG = "HardwareChannelName";
        private const string BAUDRATE_TAG = "BaudRate";
        private const string DATABITS_TAG = "DataBits";
        private const string STOPBITS_TAG = "StopBits";
        private const string PARITY_TAG = "Parity";
        private const string FLOWCONTROL_TAG = "FlowControl";
        private const string DATAFORMAT_TAG = "DataFormat";
        protected override void HandleElement(XmlReader reader)
        {
            base.HandleElement(reader);
            if (reader.NodeType == XmlNodeType.Element)
            {
                var value = string.Empty;
                switch (reader.Name)
                {
                    case SERIALNUMBER_TAG:
                        SerialNumber = XMLHelper.GetString(reader);
                        break;
                    case HARDWARECHANNELNAME_TAG:
                        HardwareChannelName = XMLHelper.GetString(reader);
                        break;
                    case BAUDRATE_TAG:
                        BaudRate = Convert.ToUInt32(XMLHelper.GetString(reader));
                        break;
                    case DATABITS_TAG:
                        DataBits = Convert.ToUInt32(XMLHelper.GetString(reader));
                        break;
                    case STOPBITS_TAG:
                        try
                        {
                            StopBits = (StopBits)Enum.Parse(typeof(StopBits), XMLHelper.GetString(reader));
                        }
                        catch (Exception ex) { APILogger.Log(ex); }
                        break;
                    case PARITY_TAG:
                        try
                        {
                            Parity = (Parity)Enum.Parse(typeof(Parity), XMLHelper.GetString(reader));
                        }
                        catch (Exception ex) { APILogger.Log(ex); }
                        break;
                    case FLOWCONTROL_TAG:
                        try
                        {
                            FlowControl = (Handshake)Enum.Parse(typeof(Handshake), XMLHelper.GetString(reader));
                        }
                        catch (Exception ex) { APILogger.Log(ex); }
                        break;
                    case DATAFORMAT_TAG:
                        try
                        {
                            DataFormat = (UartDataFormat)Enum.Parse(typeof(UartDataFormat), XMLHelper.GetString(reader));
                        }
                        catch (Exception ex) { APILogger.Log(ex); }
                        break;
                    default:
                        // let child handle it
                        return;
                }
            }
        }
    }
}