Bonjour,
Je suis arrivé à résoudre les problèmes de compilation d'un programme qui fait la communication port rs232 mais j'ai un autre problème c'est que les boutons créer dans l'interface ne sont pas actifs c'est à dire lorsque je clic sur le bouton « clear » par exemple rien ce que j’écris ne s’efface pas.
S’il vous plait aidez moi à résoudre ce problème cette partie est la premier étape dans mon projet de fin d'étude et je dois avance vite.
Merci en avance.

voici le code du programme:

#region Namespace Inclusions
using System;
using System.Linq;
using System.Data;
using System.Text;
using System.Drawing;
using System.IO.Ports;
using System.Windows.Forms;
using System.ComponentModel;
using System.Collections.Generic;

using SerialPortTerminal.Properties;
using System.Threading;
using System.IO;
#endregion

namespace SerialPortTerminal
{
#region Public Enumerations
public enum DataMode { Text, Hex }
public enum LogMsgType { Incoming, Outgoing, Normal, Warning, Error };
#endregion

public partial class frmTerminal : Form
{
#region Local Variables

// The main control for communicating through the RS-232 port
private SerialPort comport = new SerialPort();

// Various colors for logging info
private Color[] LogMsgTypeColor = { Color.Blue, Color.Green, Color.Black, Color.Orange, Color.Red };

// Temp holder for whether a key was pressed
private bool KeyHandled = false;

private Settings settings = Settings.Default;
#endregion

#region Constructor
public frmTerminal()
{
// Load user settings
settings.Reload();

// Build the form
InitializeComponent();

// Restore the users settings
InitializeControlValues();

// Enable/disable controls based on the current state
EnableControls();

// When data is recieved through the port, call this method
comport.DataReceived += new SerialDataReceivedEventHandler (port_DataReceived);
comport.PinChanged += new SerialPinChangedEventHandler(c omport_PinChanged);
}

void comport_PinChanged(object sender, SerialPinChangedEventArgs e)
{
// Show the state of the pins
UpdatePinState();
}

private void UpdatePinState()
{
this.Invoke(new ThreadStart(() =>
{
// Show the state of the pins
chkCD.Checked = comport.CDHolding;
chkCTS.Checked = comport.CtsHolding;
chkDSR.Checked = comport.DsrHolding;
}));
}
#endregion

#region Local Methods

/// <summary> Save the user's settings. </summary>
private void SaveSettings()
{
settings.BaudRate = int.Parse(cmbBaudRate.Text);
settings.DataBits = int.Parse(cmbDataBits.Text);
settings.DataMode = CurrentDataMode;
settings.Parity = (Parity)Enum.Parse(typeof(Pari ty), cmbParity.Text);
settings.StopBits = (StopBits)Enum.Parse(typeof(St opBits), cmbStopBits.Text);
settings.PortName = cmbPortName.Text;
settings.ClearOnOpen = chkClearOnOpen.Checked;
settings.ClearWithDTR = chkClearWithDTR.Checked;

settings.Save();
}

/// <summary> Populate the form's controls with default settings. </summary>
private void InitializeControlValues()
{
cmbParity.Items.Clear(); cmbParity.Items.AddRange(Enum. GetNames(typeof(Parity)));
cmbStopBits.Items.Clear(); cmbStopBits.Items.AddRange(Enu m.GetNames(typeof(StopBits)));

cmbParity.Text = settings.Parity.ToString();
cmbStopBits.Text = settings.StopBits.ToString();
cmbDataBits.Text = settings.DataBits.ToString();
cmbParity.Text = settings.Parity.ToString();
cmbBaudRate.Text = settings.BaudRate.ToString();
CurrentDataMode = settings.DataMode;

RefreshComPortList();

chkClearOnOpen.Checked = settings.ClearOnOpen;
chkClearWithDTR.Checked = settings.ClearWithDTR;

// If it is still avalible, select the last com port used
if (cmbPortName.Items.Contains(se ttings.PortName)) cmbPortName.Text = settings.PortName;
else if (cmbPortName.Items.Count > 0) cmbPortName.SelectedIndex = cmbPortName.Items.Count - 1;
else
{
MessageBox.Show(this, "There are no COM Ports detected on this computer.\nPlease install a COM Port and restart this app.", "No COM Ports Installed", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.Close();
}
}

/// <summary> Enable/disable controls based on the app's current state. </summary>
private void EnableControls()
{
// Enable/disable controls based on whether the port is open or not
gbPortSettings.Enabled = !comport.IsOpen;
txtSendData.Enabled = btnSend.Enabled = comport.IsOpen;
//chkDTR.Enabled = chkRTS.Enabled = comport.IsOpen;

if (comport.IsOpen) btnOpenPort.Text = "&Close Port";
else btnOpenPort.Text = "&Open Port";
}

/// <summary> Send the user's data currently entered in the 'send' box.</summary>
private void SendData()
{
if (CurrentDataMode == DataMode.Text)
{
// Send the user's text straight out the port
comport.Write(txtSendData.Text );

// Show in the terminal window the user's text
Log(LogMsgType.Outgoing, txtSendData.Text + "\n");
}
else
{
try
{
// Convert the user's string of hex digits (ex: B4 CA E2) to a byte array
byte[] data = HexStringToByteArray(txtSendDa ta.Text);

// Send the binary data out the port
comport.Write(data, 0, data.Length);

// Show the hex digits on in the terminal window
Log(LogMsgType.Outgoing, ByteArrayToHexString(data) + "\n");
}
catch (FormatException)
{
// Inform the user if the hex string was not properly formatted
Log(LogMsgType.Error, "Not properly formatted hex string: " + txtSendData.Text + "\n");
}
}
txtSendData.SelectAll();
}

/// <summary> Log data to the terminal window. </summary>
/// <param name="msgtype"> The type of message to be written. </param>
/// <param name="msg"> The string containing the message to be shown. </param>
private void Log(LogMsgType msgtype, string msg)
{
rtfTerminal.Invoke(new EventHandler(delegate
{
rtfTerminal.SelectedText = string.Empty;
rtfTerminal.SelectionFont = new Font(rtfTerminal.SelectionFont , FontStyle.Bold);
rtfTerminal.SelectionColor = LogMsgTypeColor[(int)msgtype];
rtfTerminal.AppendText(msg);
rtfTerminal.ScrollToCaret();
}));
}

/// <summary> Convert a string of hex digits (ex: E4 CA B2) to a byte array. </summary>
/// <param name="s"> The string containing the hex digits (with or without spaces). </param>
/// <returns> Returns an array of bytes. </returns>
private byte[] HexStringToByteArray(string s)
{
s = s.Replace(" ", "");
byte[] buffer = new byte[s.Length / 2];
for (int i = 0; i < s.Length; i += 2)
buffer[i / 2] = (byte)Convert.ToByte(s.Substri ng(i, 2), 16);
return buffer;
}

/// <summary> Converts an array of bytes into a formatted string of hex digits (ex: E4 CA B2)</summary>
/// <param name="data"> The array of bytes to be translated into a string of hex digits. </param>
/// <returns> Returns a well formatted string of hex digits with spacing. </returns>
private string ByteArrayToHexString(byte[] data)
{
StringBuilder sb = new StringBuilder(data.Length * 3);
foreach (byte b in data)
sb.Append(Convert.ToString(b, 16).PadLeft(2, '0').PadRight(3, ' '));
return sb.ToString().ToUpper();
}
#endregion

#region Local Properties
private DataMode CurrentDataMode
{
get
{
if (rbHex.Checked) return DataMode.Hex;
else return DataMode.Text;
}
set
{
if (value == DataMode.Text) rbText.Checked = true;
else rbHex.Checked = true;
}
}
#endregion

#region Event Handlers
private void lnkAbout_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
// Show the user the about dialog
(new frmAbout()).ShowDialog(this);
}

private void frmTerminal_Shown(object sender, EventArgs e)
{
Log(LogMsgType.Normal, String.Format("Application Started at {0}\n", DateTime.Now));
}
private void frmTerminal_FormClosing(object sender, FormClosingEventArgs e)
{
// The form is closing, save the user's preferences
SaveSettings();
}

private void rbText_CheckedChanged(object sender, EventArgs e)
{ if (rbText.Checked) CurrentDataMode = DataMode.Text; }
private void rbHex_CheckedChanged(object sender, EventArgs e)
{ if (rbHex.Checked) CurrentDataMode = DataMode.Hex; }

private void cmbBaudRate_Validating(object sender, CancelEventArgs e)
{ int x; e.Cancel = !int.TryParse(cmbBaudRate.Text , out x); }
private void cmbDataBits_Validating(object sender, CancelEventArgs e)
{ int x; e.Cancel = !int.TryParse(cmbDataBits.Text , out x); }

private void btnOpenPort_Click(object sender, EventArgs e)
{
bool error = false;

// If the port is open, close it.
if (comport.IsOpen) comport.Close();
else
{
// Set the port's settings
comport.BaudRate = int.Parse(cmbBaudRate.Text);
comport.DataBits = int.Parse(cmbDataBits.Text);
comport.StopBits = (StopBits)Enum.Parse(typeof(St opBits), cmbStopBits.Text);
comport.Parity = (Parity)Enum.Parse(typeof(Pari ty), cmbParity.Text);
comport.PortName = cmbPortName.Text;

try
{
// Open the port
comport.Open();
}
catch (UnauthorizedAccessException) { error = true; }
catch (IOException) { error = true; }
catch (ArgumentException) { error = true; }

if (error) MessageBox.Show(this, "Could not open the COM port. Most likely it is already in use, has been removed, or is unavailable.", "COM Port Unavalible", MessageBoxButtons.OK, MessageBoxIcon.Stop);
else
{
// Show the initial pin states
UpdatePinState();
chkDTR.Checked = comport.DtrEnable;
chkRTS.Checked = comport.RtsEnable;
}
}

// Change the state of the form's controls
EnableControls();

// If the port is open, send focus to the send data box
if (comport.IsOpen)
{
txtSendData.Focus();
if (chkClearOnOpen.Checked) ClearTerminal();
}
}
private void btnSend_Click(object sender, EventArgs e)
{ SendData(); }

private void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
// If the com port has been closed, do nothing
if (!comport.IsOpen) return;

// This method will be called when there is data waiting in the port's buffer

// Determain which mode (string or binary) the user is in
if (CurrentDataMode == DataMode.Text)
{
// Read all the data waiting in the buffer
string data = comport.ReadExisting();

// Display the text to the user in the terminal
Log(LogMsgType.Incoming, data);
}
else
{
// Obtain the number of bytes waiting in the port's buffer
int bytes = comport.BytesToRead;

// Create a byte array buffer to hold the incoming data
byte[] buffer = new byte[bytes];

// Read the data from the port and store it in our buffer
comport.Read(buffer, 0, bytes);

// Show the user the incoming data in hex format
Log(LogMsgType.Incoming, ByteArrayToHexString(buffer));
}
}

private void txtSendData_KeyDown(object sender, KeyEventArgs e)
{
// If the user presses [ENTER], send the data now
if (KeyHandled = e.KeyCode == Keys.Enter) { e.Handled = true; SendData(); }
}
private void txtSendData_KeyPress(object sender, KeyPressEventArgs e)
{ e.Handled = KeyHandled; }
#endregion

private void chkDTR_CheckedChanged(object sender, EventArgs e)
{
comport.DtrEnable = chkDTR.Checked;
if (chkDTR.Checked && chkClearWithDTR.Checked) ClearTerminal();
}

private void chkRTS_CheckedChanged(object sender, EventArgs e)
{
comport.RtsEnable = chkRTS.Checked;
}

private void btnClear_Click(object sender, EventArgs e)
{
ClearTerminal();
}

private void ClearTerminal()
{
rtfTerminal.Clear();
}

private void tmrCheckComPorts_Tick(object sender, EventArgs e)
{
// checks to see if COM ports have been added or removed
// since it is quite common now with USB-to-Serial adapters
RefreshComPortList();
}

private void RefreshComPortList()
{
// Determain if the list of com port names has changed since last checked
string selected = RefreshComPortList(cmbPortName .Items.Cast<string>(), cmbPortName.SelectedItem as string, comport.IsOpen);

// If there was an update, then update the control showing the user the list of port names
if (!String.IsNullOrEmpty(selecte d))
{
cmbPortName.Items.Clear();
cmbPortName.Items.AddRange(Ord eredPortNames());
cmbPortName.SelectedItem = selected;
}
}

private string[] OrderedPortNames()
{
// Just a placeholder for a successful parsing of a string to an integer
int num;

// Order the serial port names in numberic order (if possible)
return SerialPort.GetPortNames().Orde rBy(a => a.Length > 3 && int.TryParse(a.Substring(3), out num) ? num : 0).ToArray();
}

private string RefreshComPortList(IEnumerable <string> PreviousPortNames, string CurrentSelection, bool PortOpen)
{
// Create a new return report to populate
string selected = null;

// Retrieve the list of ports currently mounted by the operating system (sorted by name)
string[] ports = SerialPort.GetPortNames();

// First determain if there was a change (any additions or removals)
bool updated = PreviousPortNames.Except(ports ).Count() > 0 || ports.Except(PreviousPortNames ).Count() > 0;

// If there was a change, then select an appropriate default port
if (updated)
{
// Use the correctly ordered set of port names
ports = OrderedPortNames();

// Find newest port if one or more were added
string newest = SerialPort.GetPortNames().Exce pt(PreviousPortNames).OrderBy( a => a).LastOrDefault();

// If the port was already open... (see logic notes and reasoning in Notes.txt)
if (PortOpen)
{
if (ports.Contains(CurrentSelecti on)) selected = CurrentSelection;
else if (!String.IsNullOrEmpty(newest) ) selected = newest;
else selected = ports.LastOrDefault();
}
else
{
if (!String.IsNullOrEmpty(newest) ) selected = newest;
else if (ports.Contains(CurrentSelecti on)) selected = CurrentSelection;
else selected = ports.LastOrDefault();
}
}

// If there was a change to the port list, return the recommended default selection
return selected;
}
}
}