[C#] Conectarse a un puerto serie (RS232)

Pubicado en11 comentariosCategoríasProgramación

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.

11 comentarios en “[C#] Conectarse a un puerto serie (RS232)”

  1. Hola, el tema se llama Newscast y no recuerdo donde lo compré, creo que en themeforest.com.

    A mí me encanta, es bastante estructurado y elegante.

    Gracias por tu comentario 🙂

  2. Alguna vez has tenido necesidad de saber que es lo que esta conectado en cada puerto?
    es decir tengo 5 puertos com y en ellos tengo conectado
    gps, modem, bascula, leer de huellas, en otro nada

    yo quiero saber en que puerto esta conectado cada uno
    es decir gps esta en el com1 o en el com3 o tal vez este en com5
    el modem puede estar en culquier tambien quiero saber en dondee esta cada cosa

    1. Uf, perdón por tardar tantísimo en responder. He estado un tiempo sin tocar el blog.

      La verdad es que no he tenido esa necesidad. De hecho como podrás ver se le pasa el nombre del puerto a la clase.

      No sería mala mejora, un método para listar los puertos y en cuales hay algo conectado.

      Gracias por el comentario 🙂

  3. Hola Gonzalo… que interesante aporte.
    Estaba buscando por todos lados como hacer una interfase de conexion con un equipo por puerto serial.
    He adaptado tu codigo a mi programa.
    Solo me falta probarlo en ese equipo.

    Gracias

    1. Hola Ernesto.

      Lo más frecuente es que algún parámetro de la conexión serie esté mal, porque en sí, una vez está establecida la conexión no es más que una lectura del buffer que ya está implementada en la clase System.IO.Ports.SerialPort.

      ¿Puedes revisar los parámetros de conexión a ver si te funciona?

Responder a nutricion pesas Cancelar respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *