Fonctionnalités principales

Cet outil de commmunication série propose la configuration des ports, l'échange bidirectionnel de données, la conversion HEX/ASCII, le calcul de CRC et le suivi en temps réel du débit réseau avec journalisation des échanges.

Composant central de l'application

// PortMonitor.cs
using System;
using System.IO.Ports;
using System.Windows.Forms;
using System.Timers;
using System.Text;

namespace PortMonitor
{
    public partial class PortMonitor : Form
    {
        private SerialPort _portLink = new SerialPort();
        private System.Timers.Timer _tickClock = new System.Timers.Timer(1000);
        private StringBuilder _inputStore = new StringBuilder();
        private long _bytesIn = 0;
        private long _bytesOut = 0;

        public PortMonitor()
        {
            InitializeComponent();
            SetupUI();
            DetectAvailablePorts();
            _tickClock.Elapsed += OnTickRefresh;
        }

        private void SetupUI()
        {
            this.Size = new Size(800, 600);
            grpPortCfg.Text = "Paramètres port";
            grpDataExchange.Text = "Échange de données";
            grpMonitor.Text = "Surveillance";

            cmbPortList.Items.AddRange(SerialPort.GetPortNames());
            cmbSpeed.Items.AddRange(new object[] { 9600, 19200, 38400, 57600, 115200 });
            cmbBits.Items.AddRange(new object[] { 8 });
            cmbCheck.Items.AddRange(Enum.GetNames(typeof(Parity)));
            cmbEndMark.Items.AddRange(Enum.GetNames(typeof(StopBits)));

            txtPayload.AcceptsReturn = true;
            txtLogBox.Multiline = true;
            txtLogBox.ScrollBars = ScrollBars.Both;
            lblState.Text = "Prêt";
        }

        private void DetectAvailablePorts()
        {
            cmbPortList.Items.Clear();
            cmbPortList.Items.AddRange(SerialPort.GetPortNames());
            if (cmbPortList.Items.Count > 0)
                cmbPortList.SelectedIndex = 0;
        }

        private void ToggleConnection(object sender, EventArgs e)
        {
            try
            {
                if (!_portLink.IsOpen)
                {
                    _portLink.PortName = cmbPortList.Text;
                    _portLink.BaudRate = int.Parse(cmbSpeed.Text);
                    _portLink.DataBits = 8;
                    _portLink.StopBits = (StopBits)Enum.Parse(typeof(StopBits), cmbEndMark.Text);
                    _portLink.Parity = (Parity)Enum.Parse(typeof(Parity), cmbCheck.Text);
                    _portLink.DataReceived += OnDataArrival;
                    _portLink.Open();
                    btnConnect.Text = "Déconnecter";
                    lblState.Text = $"Connecté: {_portLink.PortName}";
                }
                else
                {
                    _portLink.Close();
                    btnConnect.Text = "Connecter";
                    lblState.Text = "Prêt";
                }
            }
            catch (Exception err)
            {
                MessageBox.Show($"Erreur: {err.Message}");
            }
        }

        private void OnDataArrival(object sender, SerialDataReceivedEventArgs e)
        {
            string payload = _portLink.ReadExisting();
            _inputStore.Append($"[{DateTime.Now:HH:mm:ss.fff}] RX: {payload}\r\n");
            _bytesIn += payload.Length;
            RefreshView();
        }

        private void TransmitHex(object sender, EventArgs e)
        {
            try
            {
                byte[] raw = ParseHexString(txtPayload.Text);
                _portLink.Write(raw, 0, raw.Length);
                _bytesOut += raw.Length;
                txtLogBox.AppendText($"TX HEX: {txtPayload.Text}\r\n");
                RefreshView();
            }
            catch
            {
                MessageBox.Show("Format HEX invalide");
            }
        }

        private void TransmitAscii(object sender, EventArgs e)
        {
            string msg = txtPayload.Text;
            _portLink.Write(msg);
            _bytesOut += msg.Length;
            txtLogBox.AppendText($"TX ASCII: {msg}\r\n");
            RefreshView();
        }

        private void RefreshView()
        {
            if (InvokeRequired)
            {
                Invoke(new Action(() =>
                {
                    txtLogBox.Text = _inputStore.ToString();
                    lblRxBytes.Text = $"{_bytesIn} octets";
                    lblTxBytes.Text = $"{_bytesOut} octets";
                }));
            }
        }

        private byte[] ParseHexString(string hexStr)
        {
            int len = hexStr.Length;
            byte[] result = new byte[len / 2];
            for (int idx = 0; idx < len; idx += 2)
            {
                result[idx / 2] = Convert.ToByte(hexStr.Substring(idx, 2), 16);
            }
            return result;
        }

        private void OnTickRefresh(object sender, ElapsedEventArgs e)
        {
            DetectAvailablePorts();
        }
    }
}

Définition de l'interface graphique

// PortMonitor.Designer.cs
partial class PortMonitor
{
    private System.ComponentModel.IContainer components = null;
    private GroupBox grpPortCfg;
    private ComboBox cmbPortList;
    private ComboBox cmbSpeed;
    private ComboBox cmbBits;
    private ComboBox cmbCheck;
    private ComboBox cmbEndMark;
    private Button btnConnect;
    private GroupBox grpDataExchange;
    private TextBox txtPayload;
    private Button btnHexSend;
    private Button btnAsciiSend;
    private GroupBox grpMonitor;
    private TextBox txtLogBox;
    private Label lblRxBytes;
    private Label lblTxBytes;
    private Label lblState;

    protected override void Dispose(bool disposing)
    {
        if (disposing && (components != null))
            components.Dispose();
        base.Dispose(disposing);
    }

    private void InitializeComponent()
    {
        grpPortCfg = new GroupBox();
        cmbEndMark = new ComboBox();
        cmbCheck = new ComboBox();
        cmbBits = new ComboBox();
        cmbSpeed = new ComboBox();
        cmbPortList = new ComboBox();
        btnConnect = new Button();
        grpDataExchange = new GroupBox();
        btnHexSend = new Button();
        btnAsciiSend = new Button();
        txtPayload = new TextBox();
        grpMonitor = new GroupBox();
        txtLogBox = new TextBox();
        lblRxBytes = new Label();
        lblTxBytes = new Label();
        lblState = new Label();

        grpPortCfg.Controls.AddRange(new Control[] {
            cmbEndMark, cmbCheck, cmbBits, cmbSpeed, cmbPortList, btnConnect
        });
        grpPortCfg.Dock = DockStyle.Top;
        grpPortCfg.Location = new Point(0, 0);
        grpPortCfg.Size = new Size(784, 100);
        grpPortCfg.Text = "Paramètres port";

        grpDataExchange.Controls.AddRange(new Control[] {
            btnHexSend, btnAsciiSend, txtPayload
        });
        grpDataExchange.Dock = DockStyle.Top;
        grpDataExchange.Location = new Point(0, 100);
        grpDataExchange.Size = new Size(784, 100);
        grpDataExchange.Text = "Échange de données";

        grpMonitor.Controls.AddRange(new Control[] {
            txtLogBox, lblRxBytes, lblTxBytes, lblState
        });
        grpMonitor.Dock = DockStyle.Fill;
        grpMonitor.Location = new Point(0, 200);
        grpMonitor.Size = new Size(784, 400);
        grpMonitor.Text = "Surveillance";

        Controls.AddRange(new Control[] { grpMonitor, grpDataExchange, grpPortCfg });
        Text = "Moniteur Série";
    }
}

Module de calcul CRC16

public static class CrcCalculator
{
    public static ushort Compute(byte[] input)
    {
        ushort accumulator = 0xFFFF;
        foreach (byte current in input)
        {
            accumulator ^= (ushort)(current << 8);
            for (int bit = 0; bit < 8; bit++)
            {
                bool highBit = (accumulator & 0x8000) != 0;
                accumulator <<= 1;
                if (highBit)
                    accumulator ^= 0xA001;
            }
        }
        return accumulator;
    }
}

Suivi du débit réseau

private void OnTickRefresh(object sender, ElapsedEventArgs e)
{
    double interval = _tickClock.Interval;
    lblRxRate.Text = $"{(_bytesIn / interval):F2} o/s";
    lblTxRate.Text = $"{(_bytesOut / interval):F2} o/s";
    _tickClock.Stop();
    _tickClock.Start();
}

Journalisation des événements

private void AppendToLog(string entry)
{
    string filePath = "session_trace.log";
    string timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
    File.AppendAllText(filePath, $"{timestamp} - {entry}{Environment.NewLine}");
}

Gestion des erreurs de communication

try
{
    _portLink.Write(data);
}
catch (TimeoutException timeoutErr)
{
    AppendToLog($"Délai dépassé: {timeoutErr.Message}");
}
catch (IOException ioErr)
{
    AppendToLog($"Lien interrompu: {ioErr.Message}");
}

Optimisation mémoire du tampon de réception

_portLink.ReceivedBytesThreshold = 4096;

Surveillance de la mémoire applicative

var procCounter = new PerformanceCounter("Process", "Working Set", Process.GetCurrentProcess().ProcessName);
lblMemory.Text = $"{procCounter.NextValue() / 1024 / 1024:F2} Mo";

Extension vers le protocole Modbus RTU

public class ModbusFrameBuilder
{
    public static byte[] BuildReadHoldingRegisters(byte unitAddress, ushort registerStart, ushort quantity)
    {
        byte[] frame = new byte[8];
        frame[0] = unitAddress;
        frame[1] = 0x03;
        frame[2] = (byte)(registerStart >> 8);
        frame[3] = (byte)registerStart;
        frame[4] = (byte)(quantity >> 8);
        frame[5] = (byte)quantity;
        ushort checksum = CrcCalculator.Compute(frame);
        frame[6] = (byte)checksum;
        frame[7] = (byte)(checksum >> 8);
        return frame;
    }
}

Traitement asynchrone de l'envoi

private BackgroundWorker _asyncSender = new BackgroundWorker();

// Dans le constructeur :
_asyncSender.DoWork += (s, ev) =>
{
    _portLink.Write((byte[])ev.Argument);
};

// Lors de l'envoi :
_asyncSender.RunWorkerAsync(rawData);

Structure du projet

PortMonitor/
├── PortMonitor.cs              # Logique principale du formulaire
├── PortMonitor.Designer.cs     # Disposition de l'interface
├── CrcCalculator.cs            # Utilitaire CRC
├── SerialSettings.cs           # Gestion de la configuration
├── Resources/
│   ├── app_icon.ico
│   └── theme.css
└── Output/
    └── Debug/
        └── PortMonitor.exe

Cas de test fonctionnels