Serial Port With C++ 6

بســم الله الـرحمــن الرحيــم

السلام عليكــم ورحمـة الله وبركاتــه ،،الحمدلله والصلاة والسلام على رسول الله وعلى آله وصحبه أجمعين

Présentation :

Les liaisons séries permettent la communication entre deux systèmes numériques en limitant le nombres de fils de transmission.

La liaison série aux normes RS 232 est utilisée dans tous les domaines de l'informatique (ex : port de communication com1 et com2 des PC, permetant la communication avec des periphériques tels que modem et souris). Elle est de type asynchrone, c'est à dire qu'elle ne transmet pas de signal horloge.

Le schéma fonctionnel est le suivant :

La transmission série nécessite un minimum de 2 fils comportant les trames de données en émission (Tx) et en réception (Rx).

L'adaptation des données se fait à l'aide d'un circuit adaptateur de ligne

(ex : MAX232), qui tranforme les niveaux logiques issus du système numérique en niveaux logiques compatibles avec les normes RS232 et vice versa.

Protocole de transmission :

Afin que les éléments communicants puissent se comprendre, il est nécessaire d'établir un protocole de transmission. Ce protocole devra être le même pour les deux éléments afin que la transmission fonctionne correctement.

Paramètres rentrant en jeu :

· Longueur des mots : 7 bits (ex : caractère ascii) ou 8 bits

· La vitesse de transmission : les différentes vitesses de transmission son réglables à partir de 110 bauds (bits par seconde) de la façon suivante : 110 bds, 150 bds, 300 bds, 600 bds, 1200 bds, 2400 bds, 4800 bds, 9600 bds.

· Parité : le mot transmis peut être suivi ou non d'un bit de parité qui sert à détecter les erreurs éventuelles de transmission. Il existe deux types de parité.

parité paire : le bit ajouté à la donnée est positionné de telle façon que le nombre des états 1 soit paire sur l'ensemble donné + bit de parité

ex : soit la donnée 11001011 contenant 5 état 1, le bit de parité paire est positionné à 1, ramenant ainsi le nombre de 1 à 6.

parité impaire : le bit ajouté à la donnée est positionné de telle façon que le nombre des états 1 soit impaire sur l'ensemble donné + bit de parité

ex : soit la donnée 11001001 contenant 5 état 1, le bit de parité paire est positionné à 0, laissant ainsi un nombre de 1 impaire..

· Bit de start : la ligne au repos est à l'état logique 1 pour indiquer qu'un mot va être transmis la ligne passe à l'état bas avant de commencer le tranfert. Ce bit permet de synchroniser l'horloge du récepteur.

· Bit de stop : après la transmission, la ligne est positionnée au repos pendant 1, 2 ou 1,5 périodes d'horloge selon le nombre de bits de stop.

Format des trames :

Le bit de start apparait en premier dans la trame puis les données (poids faible en premier), la parité éventuelle et le (les) bit(s) de stop.

exemple :

Soit à transmettre en parité paire, avec 2 bits de stop, le caractère B dont le codage ascii est 1000010₍₂₎ la trame sera la suivante :

(d'un point de vue logique)

<H2 style="MARGIN: auto 0cm; TEXT-ALIGN: center" align=center>Introduction</H2>

<H2 style="MARGIN: auto 0cm; TEXT-ALIGN: center" align=center>Géométrie</H2>

<H2 style="MARGIN: auto 0cm; TEXT-ALIGN: center" align=center>Description et attribution des signaux</H2>

<H2 style="MARGIN: auto 0cm; TEXT-ALIGN: center" align=center>Programmation</H2>

Interface RS-232C

Examinons de plus près l'interface série RS-232C. Le terme "RS-232C" se réfère à un ensemble de spécifications relatives à ce type d'interface. La norme RS-232C a été conçue par l'Association des Industries Electroniques (AIE). Les ingénieurs de l'AIE n'étant pas assurés quant aux types d'équipement qui seraient développés dans le futur, ont préféré laisser disponible un grand nombre de lignes afin que la norme RS-232C soit aussi flexible que possible. De nos jours, la plupart de ces lignes ne sont pas utilisées par les micro-ordinateurs.

La figure 4 montre le brochage (affectations des broches) d'un connecteur RS-232C. Celui qui est représenté ici est un connecteur "DB-25" est le type le plus usuel. Le "DB-25" a 25 broches, mais certaines interfaces sérielles utilisent un connecteur plus petit DB-9, possédant 9 broches. Dans les cas les plus fréquents, seulement sept de ces lignes sont utilisées. Toutefois, notons qu'un système RS-232C peut fonctionner en n'utilisant que 3 lignes, comme le montre la figure 5.

Dans une liaison RS-232C, une extrémité est désignée comme "Equipement Terminal de Données" ou ETD, et l'autre est appelée "Equipement de Communication de Données" ou ECD. Les diverses lignes de la liaison sont nommées par rapport à l'ordinateur. Par exemple, la ligne 2 est nommée "TRANSMISSION DE DONNÉES" parce qu'elle transporte le signal qui est émis à partir de l'ordinateur. Dans un système ordinateur/modem, l'ordinateur est le terminal (ETD) ou terminal de données, et le modem est le communicateur ou (ECD).

Dans l'interface la plus simple possible, les trois lignes clés sont reliées aux points 2, 3, et 7 sur le connecteur RS-232C. Cela est illustré par la figure 5. La ligne 2 transporte les "données transmises" du terminal au communicateur. La ligne 3 transporte les "données reçues" du communicateur au terminal. La ligne 7 est une masse pour les deux lignes précitées.

"Poignée de main"

La figure 6 montre une interface RS-232C plus complexe. Ce diagramme est spécifique au type d'interface qui peut être utilisé pour relier l'ordinateur à un modem. Cette interface comporte les trois lignes montrées sur la figure 5 à savoir:

1. - Masse (ligne 7),
   
2. - Transmission de données (ligne 2),
   
3. - Réception de données (ligne 3).
   

La plupart des autres lignes sont utilisées pour le contrôle de la "poignée de main" entre l'ordinateur et le modem.

Les concepteurs ont voulu s'assurer que l'ordinateur n'enverrait pas de caractères tant que le modem n'est pas prêt. Par exemple, la ligne 20 est le "Terminal de Données Prêt" (DTR) et la ligne 6 est le "Prêt à recevoir" (DSR). Au début de la "poignée de main", l'ordinateur met la ligne DTR au niveau haut pour signaler au modem "Je suis prêt à envoyer,. Et vous?" Quand le modem est prêt, il répondra en mettant la ligne DSR au niveau haut. L'ordinateur n'enverra pas de données tant que les deux lignes sont "vrai".

Un autre type de "poignée de main" utilise la ligne 4 qui équivaut à la "Demande d'Emission" (RTS), et la ligne 5 ou "Prêt à envoyer" (CTS). Pour commencer ce cycle de "poignée de main", l'ordinateur met au niveau haut la ligne "Demande d'Emission". Si le modem est prêt, il fera de même pour la ligne "Prêt à Envoyer".

Quelques liaisons RS-232C n'utilisent pas ce contrôle matériel de la "poignée de main"; celle-ci est contrôlée de façon logicielle. Les codes spéciaux de contrôle sont envoyés de long en large sur les lignes de données. (Vous vous rappellerez que, avec le contrôle matériel de la "poignée de main", les signaux de contrôle sont envoyés sur des lignes de contrôle séparées). Un protocole commun de "poignée de main" est appelé "X-ON/X-OFF". L'ordinateur et l'ECD échangent les caractères "DC1" et "DC3". Sur certaines tables ASCII, "DC1" est codé comme CTRL-Q (code hexadécimal 11) et "DC3" est codé comme CTRL-S (code hexadécimal 13). A chaque instant, ces caractères spéciaux apparaissent dans la file des données, l'ordinateur ou le modem détectent les caractères et agissent sur eux.

A n'importe quel moment où les données sont envoyées à travers des lignes téléphoniques, des erreurs de transmission peuvent s'y glisser. Un autre protocole de "poignée de main" appelé "X Modem" utilise les caractères ASCII "ACK" et "NAK" pour surveiller la transmission et le contrôle d'erreur. Dans ce protocole, un long fichier est envoyé comme une série de "blocs". Chaque bloc est précédé d'un caractère de "Début de Texte", et terminé par un caractère de "Fin de Texte". Le caractère de "Début De texte" est abrégé STX, mais il peut aussi être codé comme CRTL-A (code hexadécimale 02). Le caractère de "Fin De texte" est abrégé ETX. Il peut aussi être codé comme CTRL-B (code hexadécimal 03). Au bout de chaque bloc, un code spécial de vérification d'erreur est inclus. Pour chaque bloc, l'ordinateur calcule ce code de vérification d'erreur, basé sur les données à envoyer dans ce bloc. Le code de vérification d'erreur est transmis, avec le reste du bloc. S'il n'y a aucune erreur de transmission, le code de vérification d'erreur s'harmonise avec l'information reçue dans le bloc, et le modem reconnaît que le bloc a été reçu correctement. Si tout s'est bien déroulé, le modem envoie en retour un code de reconnaissance (ACK, CTRL-F, $06). A n'importe quel moment où le code de vérification d'erreur ne s'harmonise pas avec l'information dans le bloc, le modem n'envoie pas le code de reconnaissance (NAK, CTRL-O, $15). Cela indique à l'ordinateur de transmettre à nouveau ce bloc.

Certaines autres lignes RS-232C peuvent être utilisées sur certaines interfaces. La ligne 8 est "Porteuse Détectée". Quand le modem réalise une connexion sur la ligne téléphonique, il devrait détecter la porteuse qui est toujours présente quand la ligne téléphonique est active. En mettant la ligne 8 "vrai", le modem peut indiquer à l'ordinateur qu'il a détecté la porteuse. La ligne 12 peut être employée comme un indicateur de vitesse. Le modem peut mettre cette ligne au niveau haut quand il passe à une vitesse de fonctionnement élevée. La ligne 22 est "Sonnerie Détectée". Certains modems utilisent la ligne 22 pour indiquer qu'ils ont réalisé la connexion intégrale à la ligne téléphonique, et le téléphone sonne à l'autre bout du fil.

Codage des signaux RS-232C

Les signaux des lignes RS-232C ne présentent pas des niveaux de tension TTL (+5 V et 0 V). Les niveaux typiques de tension sont +12 V et -12 V, mais ces lignes sont calibrées pour supporter des signaux de +25 V, et -25V. N'essayez donc pas de contrôler ces lignes avec votre testeur logique - celui-ci sera détruit par les niveaux de tensions élevés. Ayez plutôt recours à un oscilloscope. Un multimètre de faible résolution pourrait détecter l'activité sur les lignes de données, mais vous ne serez pas capables de "lire" les signaux. Les signaux de contrôle évoluent plus lentement que les signaux de données, ainsi vous pouvez mesurer les signaux de contrôle avec un voltmètre.

La figue. 7A illustre le codage des données sur la liaison RS-232C. Remarquez que le système de codage (niveaux de signal) est différent suivant qu'il s'agit des lignes de données ou des lignes de contrôle. Sur les lignes de données, une valeur de tension supérieure à +3V indique un niveau logique "0". Une valeur de tension inférieure à -3V indique un niveau logique "1". Notez que les niveaux de tension sont le même sur les lignes de contrôle, mais la signification est inversée. Une valeur de tension positive indique "vrai", et une valeur de tension négative représente "faux".

La plupart des modems connectés à un micro-ordinateur utilisent une interface asynchrone. Cela signifie que les activités de l'ordinateur d'une part et celles du modem d'autre part ne sont pas synchronisées par des impulsions d'horloge. Le modem est prêt à traiter les données à tout moment. En utilisant une interface asynchrone, les circuits internes du modem voient constamment une chaîne de caractères en entrée ou en sortie. Ainsi, ces circuits doivent avoir un moyen pour identifier le début et la fin de chaque paquet de données. Chaque paquet de données comprend un "bit de début", les bits de données, et un ou deux "bits d'arrêt". De façon usuelle, un paquet complet représente une lettre ou un caractère. Le caractère lui-même est habituellement représenté sur 7 ou 8 bits de données.

En résumé, le caractère est encadré par les bits de début et les bits de fin. Pour une bonne transmission, les deux extrémités de la liaison doivent s'attendre au même type d'encadrement.

La figure 8 montre les signaux qu'une interface pourrait utiliser lors de la transmission de la lettre "C". Pour marquer le début du paquet de données, l'ordinateur envoie un "bit de début" (tension positive, niveau logique "0"). Il envoie ensuite une suite de "1" et de "0" (habituellement sept) pour représenter le caractère lui-même. Comme beaucoup d'autres domaines de l'informatique, la liaison RS-232C utilise le codage ASCII pour la représentation des lettres et caractères.

Les tables ASCII se trouvent dans la plupart des ouvrages d'informatique et d'informatique industrielle.

Le code ASCII de la lettre "C" est "1000011," du bit de poids fort au bit de poids faible. (Si nous considérons le nombre décimal "156", le "1" serait le "bit" de poids fort parce qu'il représente les "centaines." Le "6" est le "bit" de poids faible). Sur la figure 8, nous avons montré la façon dont les circuits RS-232C envoient la lettre "C". La fin du paquet de données est identifiée par un ou deux bits d'arrêt (niveau bas). Ils sont suivis d'un bit de début (niveau haut) pour le paquet de données suivant. Les circuits reconnaissent cette combinaison, et détectent qu'un caractère codé en ASCII va suivre. Ce code ASCII est envoyé effectivement et commence par le bit de poids faible et se termine par le bit de poids fort.

Si le système utilise les codes ASCII sur 7 bits, un huitième bit de données peut servir de bit de parité. Le bit de parité est un dispositif de vérification d'erreur. Ce bit peut être au niveau "haut" ou au niveau "bas," suivant le codage des bits de données. Lors de la transmission du paquet de données, le bit de parité est envoyé avec les bits de données. Le modem utilise le bit de parité pour s'assurer de l'intégrité des données. Si la bit de parité indique une erreur dans les données, le modem peut demander à l'ordinateur de retransmettre le caractère.

Pour calculer la valeur ("0" ou "1") du bit de parité, les circuits d'interface additionnent le nombre total de "1" dans les bits de données, et déterminent si le résultat est pair ou impair. Dans l'exemple au-dessus, il y a trois "1" dans le code ASCII de la lettre "C", ce qui est un nombre impair. Nous supposerons que les circuits sont configurés pour la parité impaire. Le bit de parité sera "vrai" si le nombre total de "1" n'est pas en concordance avec la parité choisie (si nombre pair pour parité impaire, ou si nombre impair pour parité impaire). Dans cet exemple, le nombre total de "1" est impair. Le bit de parité sera au niveau bas pour que le nombre total de "1" reste impair. Cette vérification d'erreur permet à l'ordinateur de contrôler l'intégrité de chaque nouveau caractère.

Notez que le bit de début, les bits d'arrêt, et le bit de parité utilise un système de codage différent de celui des bits de données. Comme nous expliquions, pour les bits de contrôle, un signal positif est "vrai" alors que pour les bits de données, un signal négatif représente un "1".

Une interface sérielle peut être configurée pour fonctionner avec un bit de début, un ou deux bitd d'arrêt, une parité paire, une parité impaire, ou aucun bit de parité. Les deux extrémités de la liaison doivent être configurées avec les mêmes paramètres.

(A) Niveaux des signaux de données

(B) Niveaux des signaux de contrôle

Autres utilisations pour la norme RS-232C

Une liaison RS-232C peut être utilisée entre un ordinateur et une imprimante série, ou entre deux ordinateurs. En fait, à n'importe quel endroit où vous rencontrez une interface série, il est probable qu'elle soit basée sur la norme RS-232C. L'interface série d'une imprimante est assez similaire à l'interface que nous venons d'étudier. Une différence est qu'avec une imprimante série, on dispose d'un large éventail de vitesse de transmission (150 bps, 300bps, 600 bps, ..., 19600 bps, et plus) afin de pouvoir gérer les imprimantes les plus lentes aux plus rapides. D'une façon générale, l'imprimante doit être en mesure de recevoir les informations plus rapidement que l'ordinateur n'en envoie.

Quand une liaison RS-232C est utilisée pour interconnecter deux ordinateurs, lequel est le "terminal" et lequel est le "communicateur" ? Une solution consiste à configurer un des ordinateurs en "communicateur" (DCE). Vous pouvez aussi décider de recourir à un dispositif appelé "nul modem" (voir figure 9). Un "nul modem" permet à l'interface de fonctionner, bien que les deux extrémités de la liaison soient configurées en "terminal" (DTE). Sur la figure, on peut remarquer que les lignes 2 et 3 ("Transmission de données" et "Réception de données") sont croisées. L'information transmise par un ordinateur est envoyée au récepteur de l'autre. Le signal "Terminal de données prêt" d'un ordinateur est utilisé pour gérer quelques lignes de la "poignée de main" sur l'autre ordinateur. Sur un autre type de "nul modem", les lignes 4 et 5 ("Demande d'émission" et "Prêt à envoyer") sont croisées.

Ne confondez pas le "nul modem" avec un autre dispositif appelé un "adaptateur mâle/femelle". Cet adaptateur de connecteurs permet de réaliser des connexions de type mâle-mâle, ou femelle-femelle. Les lignes ne sont pas croisées au niveau de l'adaptateur.

Ces câbles servent la plupart du temps à connecter deux ordinateurs entre eux afin d'échanger des données par le port série. On trouve souvent leur utilité pour des jeux (Starcraft par exemple, je l'ai testé et ça marche impec), pour ceux qui n'ont pas de cartes réseaux. Bien sûr, on peut trouver ces câbles dans le commerce, mais l'éventail des longueurs est très limité : 2m., voire 10m., et c'est tout ! Alors je vous propose sur cette page de réaliser un câble null-modem, dont la longueur ne dépendra que de vous.

NB : si la connection ralentit, passer de 9600 bps à supérieur (19200 par exemple)

Je vous en propose trois types :

• Le câble null-modem DB9 - DB9
  
• Le câble DB25 - DB25
  
• Le câble DB25 - DB9
  

Pour chacun de ces câbles, vous aurez besoin de câble 7 ou 8 conducteurs minimum selon les modèles, et de prises DB25 et/ou DB9 femelles, selon le port série utilisé. Voici les schémas de ces prises, avec les numéros de chaque broche :

et maintenant je vous donne le programme de communication RS232 sous C++ builder borland.

je lais essai et il marche:

//-----------------------------------------------------LE POINT.h----------------------------------------------------------

//---------------------------------------------------------------------------

#ifndef Ucom1H

#define Ucom1H

//---------------------------------------------------------------------------

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include <Menus.hpp>

#include<conio.h>

#include<stdio.h>

#include<stdlib.h>

#include <Buttons.hpp>

//---------------------------------------------------------------------------

class TForm1 : public TForm

{

__published: // Composants gérés par l'EDI

TGroupBox *GroupBox1;

TComboBox *CbCom;

TLabel *Label1;

TLabel *Label2;

TGroupBox *GroupBox2;

TRadioButton *RadioButton1;

TRadioButton *RadioButton2;

TLabel *Label3;

TMemo *M1;

TMemo *M2;

TButton *BtCfile;

TButton *Btwrite;

TButton *BtClose;

TButton *BtRead;

TRadioButton *RS1;

TRadioButton *RS2;

TGroupBox *GroupBox3;

TRadioButton *R5;

TRadioButton *R7;

TRadioButton *R8;

TLabel *Label4;

TBitBtn *BitBtn1;

TGroupBox *GroupBox4;

TRadioButton *RadioButton3;

TRadioButton *RadioButton4;

TRadioButton *RadioButton5;

TRadioButton *RadioButton6;

TRadioButton *RadioButton7;

TRadioButton *RadioButton8;

TRadioButton *RadioButton9;

TMemo *M3;

void __fastcall FormCreate(TObject *Sender);

void __fastcall CbComChange(TObject *Sender);

void __fastcall BtCfileClick(TObject *Sender);

void __fastcall RadioButton1Click(TObject *Sender);

void __fastcall RadioButton2Click(TObject *Sender);

void __fastcall RS1Click(TObject *Sender);

void __fastcall RS2Click(TObject *Sender);

void __fastcall R5Click(TObject *Sender);

void __fastcall R7Click(TObject *Sender);

void __fastcall R8Click(TObject *Sender);

void __fastcall BtwriteClick(TObject *Sender);

void __fastcall BtReadClick(TObject *Sender);

void __fastcall BtCloseClick(TObject *Sender);

void __fastcall RadioButton9Click(TObject *Sender);

void __fastcall RadioButton8Click(TObject *Sender);

void __fastcall RadioButton3Click(TObject *Sender);

void __fastcall RadioButton4Click(TObject *Sender);

void __fastcall RadioButton5Click(TObject *Sender);

void __fastcall RadioButton6Click(TObject *Sender);

void __fastcall RadioButton7Click(TObject *Sender);

private: // Déclarations de l'utilisateur

/*unsigned*/ char port[5];

unsigned char p;

unsigned char RS;

unsigned char b;

unsigned long v;

AnsiString s;

HANDLE Hport;

char buff_out[1024],buff_in[1024];

DCB Dcb1;

public: // Déclarations de l'utilisateur

__fastcall TForm1(TComponent* Owner);

};

//---------------------------------------------------------------------------

extern PACKAGE TForm1 *Form1;

//---------------------------------------------------------------------------

#endif

//---------------------------------------------LE POINT.CCP------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------

#include <vcl.h>

#pragma hdrstop

#include "Ucom1.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

}

//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)

{

strcpy(port,CbCom->Text.c_str());

M1->Lines->Clear();

}

//---------------------------------------------------------------------------

void __fastcall TForm1::CbComChange(TObject *Sender)

{

strcpy(port,CbCom->Text.c_str());

}

//---------------------------------------------------------------------------

void __fastcall TForm1::BtCfileClick(TObject *Sender)

{

COMMTIMEOUTS time_out;

Hport=CreateFile(port,

GENERIC_WRITE|GENERIC_READ,

0,

0,

OPEN_EXISTING,

FILE_ATTRIBUTE_NORMAL,

NULL);

if(Hport==INVALID_HANDLE_VALUE){

Application->MessageBoxA("ERREUR OUVERTURE PORT ","verifier l'existance du port" ,MB_OK);

}

else{

//

//strcpy(s.c_str(),port);

M3->Lines->Add("port" +AnsiString(port)+ "ouvert");

}

GetCommState(Hport,&Dcb1);

Dcb1.ByteSize=b;

Dcb1.BaudRate=v;

Dcb1.Parity=p;

Dcb1.StopBits=RS;

SetCommState(Hport,&Dcb1);

GetCommTimeouts(Hport,&time_out);

time_out.ReadIntervalTimeout=50;

time_out.ReadTotalTimeoutMultiplier=1;

time_out.ReadTotalTimeoutConstant=300;

SetCommTimeouts(Hport,&time_out);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::RadioButton1Click(TObject *Sender)

{

p='1';

}

//---------------------------------------------------------------------------

void __fastcall TForm1::RadioButton2Click(TObject *Sender)

{

p='2';

}

//---------------------------------------------------------------------------

void __fastcall TForm1::RS1Click(TObject *Sender)

{

RS='1';

}

//---------------------------------------------------------------------------

void __fastcall TForm1::RS2Click(TObject *Sender)

{

RS='2';

}

//---------------------------------------------------------------------------

void __fastcall TForm1::R5Click(TObject *Sender)

{

b='5';

}

//---------------------------------------------------------------------------

void __fastcall TForm1::R7Click(TObject *Sender)

{

b='7';

}

//---------------------------------------------------------------------------

void __fastcall TForm1::R8Click(TObject *Sender)

{

b='8';

}

//---------------------------------------------------------------------------

void __fastcall TForm1::BtwriteClick(TObject *Sender)

{

DWORD nbWritten;

strncpy(buff_out,M1->Text.c_str(),1023);

if(!WriteFile(Hport,buff_out,strlen(buff_out),&nbWritten,NULL))

Application->MessageBoxA("ERRREUR D'ECRITURE","IMPOSSIBLE D'ECRIRE SUR LE PORT!!",MB_OK);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::BtReadClick(TObject *Sender)

{

DWORD nblu;

if(!ReadFile(Hport,buff_in,1023,&nblu,NULL))

Application->MessageBoxA("ERRREUR lecture","IMPOSSIBLE de lire SUR LE PORT!!",MB_OK);

else{

buff_in[nblu]=0;

M2->Text=buff_in;

M3->Lines->Add(AnsiString(nblu)+"carater");

}

}

//---------------------------------------------------------------------------

void __fastcall TForm1::BtCloseClick(TObject *Sender)

{

if(CloseHandle(Hport))

M3->Lines->Add("port ferme") ;

else

Application->MessageBoxA("ERRREUR de fermeture","verifie l'existance du port!!",MB_OK);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::RadioButton9Click(TObject *Sender)

{

v=600;

}

//---------------------------------------------------------------------------

void __fastcall TForm1::RadioButton8Click(TObject *Sender)

{

v=1200;

}

//---------------------------------------------------------------------------

void __fastcall TForm1::RadioButton3Click(TObject *Sender)

{

v=2400;

}

//---------------------------------------------------------------------------

void __fastcall TForm1::RadioButton4Click(TObject *Sender)

{

v=4800;

}

//---------------------------------------------------------------------------

void __fastcall TForm1::RadioButton5Click(TObject *Sender)

{

v=CBR_9600;

}

//---------------------------------------------------------------------------

void __fastcall TForm1::RadioButton6Click(TObject *Sender)

{

v=19200;

}

//---------------------------------------------------------------------------

void __fastcall TForm1::RadioButton7Click(TObject *Sender)

{

v=38400;

}

//---------------------------------------------------------------------------

LE PROGRAMME IL MARCHE IL FAUT JUSTE QUE VOUS FAITE UN CHAINTE ENTRE VOTRE PORT RS232 ENTRE TRANSMETERE TX & RX ON OUTRE ENTRE 2 ET 3

Com.rar

Vous n'aurez qu'à relier les broches de cette manière :

Vous n'aurez qu'à relier les broches de cette manière :

Vous n'aurez qu'à relier les broches de cette manière :

هههههههههههههههههههههههههههههههه

يا اخواني أرجوكم من لديه معلومات ولو بسيطة حول المنفد التسلسلي فليضعها للاستفادة :wub:

والسلام عليكم

sonnerie gratuite