[Z]etaweb

Hola a todos.

Hace ya algún tiempo tuve que hacer una aplicación que se conectaba por puerto serie a una maquinilla que hacía lecturas. Ahora me ha surgido otra que tiene que leer de una centralita telefónica, así que he tenido que desempolvar el cómo lo hacía y os lo dejo aquí para que no tengáis que rebuscar tanto como tuve que hacer yo en su momento.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.IO.Ports;

namespace EspiaCentralita
{
    /// <summary>
    /// Capa de acceso a datos de la centralita
    /// </summary>
    public class DatosCentralita
    {
        SerialPort spPuerto = null;

        string puerto;
        string velocidad;
        string bitsDatos;
        string bitsParada;
        string paridad;
        string handShake;
        bool dtr;
        bool rts;

        /// <summary>Constructor</summary>
        /// <param name="Puerto">Nombre del puerto al que nos vamos a conectar</param>
        /// <param name="Velocidad">Velocidad del puerto</param>
        /// <param name="BitsDatos">Bits de datos</param>
        /// <param name="BitsParada">Bits de parada</param>
        /// <param name="Paridad">Bits de paridad</param>
        /// <param name="HandShake">...</param>
        /// <param name="DTR">...</param>
        /// <param name="RTS">...</param>
        public DatosCentralita(string Puerto, string Velocidad, string BitsDatos, string BitsParada, string Paridad, string HandShake, bool DTR, bool RTS)
        {
            //almacenamos los valores de conexion
            this.puerto = Puerto;
            this.velocidad = Velocidad;
            this.bitsDatos = BitsDatos;
            this.bitsParada = BitsParada;
            this.paridad = Paridad;
            this.handShake = HandShake;
            this.dtr = DTR;
            this.rts = RTS;

            //lanzamos la conexion
            this.Conectar();
        }

        /// <summary>
        /// Dispose
        /// </summary>
        public void Dispose()
        {
            if (spPuerto != null)
                if (spPuerto.IsOpen) this.Desconectar();
            this.Dispose();
        }

        /// <summary>
        /// Establece la conexion al puerto serie
        /// </summary>
        private void Conectar()
        {
            try
            {
                spPuerto = new SerialPort();

                //configuramos valores
                spPuerto.PortName = puerto;
                spPuerto.BaudRate = Convert.ToInt32(velocidad);
                spPuerto.DataBits = Convert.ToInt32(bitsDatos);

                switch (paridad.ToLower())
                {
                    case "ninguno": spPuerto.Parity = Parity.None; break;
                    case "par": spPuerto.Parity = Parity.Even; break;
                    case "impar": spPuerto.Parity = Parity.Odd; break;
                    case "espacio": spPuerto.Parity = Parity.Space; break;
                    case "marca": spPuerto.Parity = Parity.Mark; break;
                }

                switch (handShake.ToLower())
                {
                    case "ninguno": spPuerto.Handshake = Handshake.None; break;
                    case "rts/cts": spPuerto.Handshake = Handshake.RequestToSend; break;
                    case "dsr/dts": spPuerto.Handshake = Handshake.RequestToSendXOnXOff; break;
                    case "xon/xoff": spPuerto.Handshake = Handshake.XOnXOff; break;
                }

                switch (bitsParada.ToLower())
                {
                    case "1": spPuerto.StopBits = StopBits.One; break;
                    case "1.5": spPuerto.StopBits = StopBits.OnePointFive; break;
                    case "2": spPuerto.StopBits = StopBits.Two; break;
                    case "ninguno": spPuerto.StopBits = StopBits.None; break;
                }

                spPuerto.ReadTimeout = 500;

                spPuerto.DtrEnable = dtr;
                spPuerto.RtsEnable = rts;

                //abrimos el puerto
                spPuerto.Open();
            }
            catch (Exception ex)
            {
                throw new Exception("Capa datos. Error estableciendo la conexion.", ex);
            }
        }

        /// <summary>
        /// Desconecta el puerto serie
        /// </summary>
        /// <param name="spPuerto"></param>
        /// <returns></returns>
        private bool Desconectar()
        {
            try
            {
                if(spPuerto.IsOpen) spPuerto.Close();

                return true;
            }
            catch (Exception ex)
            {
                throw new Exception("Capa datos. Error cerrando la conexión de puerto serie.", ex);
            }
        }

        /// <summary>
        /// Obtiene los datos de la centralita
        /// </summary>
        /// <returns>Cadena leida del puerto serie</returns>
        public string ObtenerDatos()
        {
            try
            {
                string buffer = String.Empty;

                if (spPuerto == null) throw new Exception("Capa datos. Error en funcion ObtenerDatos. No existe el objeto de conexion.");
                buffer = spPuerto.ReadExisting();

                return buffer;
            }
            catch (Exception ex)
            {
                throw new Exception("Capa datos. Error al obtener los datos de la centralita.", ex);
            }
        }
    }
}

Bueno, como podéis ver el código de arriba es ya una clase completa para poder obtener datos de un puerto serie.

Tenemos que pasar los parámetros de la conexión en el constructor y despues llamar al método ObtenerDatos() para obtener los datos del puerto. Nos devolverá un String que, por supuesto, tendremos que parsear en función de lo que estemos leyendo.

En cuanto al control de errores, bueno, no está muy currado (no compruebo que los parámetros sean correctos en el constructor, por ejemplo) pero al menos lanzo excepciones hacia arriba en caso de que exista algún problema…

En fin, espero que os sea útil.

Un saludo.