Envoyer un fichier binaire depuis le Tcomport

**zohra051** · 10/12/2020, 09h30

Bonjour à tous et à toutes,

Actuellement, je travaille avec ce nouveau langage, donc je ne le métrise pas encore totalement.
Je cherche à envoyer un fichier exemple.bin via le TComport et ainsi réceptionner la réponse.
Comment puis-je faire s'il vous plaît ?
Si vous avez besoin de plus de détails n'hésitez pas.

Merci à tout ceux qui m'aideront.

Bonne journée,

Zohra

**zohra051** · 10/12/2020, 10h04

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
 
var
    myFile : TFileStream;
    length : integer;
    buffer : Array of pchar ;
    serialBuffer : Array of pchar;
    i : integer;
 
begin
 
          myFile := TFileStream.Create('..\spectabl.bin', fmOpenRead);
 
          // Taille du fichier
          myFile.Seek(0, soEnd);
          length :=   myFIle.Position;
 
          //copy file into buffer
          myFile.Seek(0,soBeginning);
          setLength(buffer,length);
          myfile.ReadData(buffer,length);
 
          if (myFile.Size = length) then
            begin
              showmessage('read success');
            end
          else
            begin
              showmessage('error');
            end;
 
          for i := 0 to sizeof(SerialBuffer) do
            begin
              SerialBuffer[i] := buffer[i];
            end;
 
          //jenvoie
          Comport2.Write(buffer,count);
          //je vide
          Comport2.ClearBuffer(true,false);
end;

J'ai testé ce code qui ne fonctionne pas. Donc là je ne fais que l'écriture mais si je fais Comport2.Read() derrière cela ne m'affiche pas le message attendu. Donc ça peut provenir soit de l'envoie soit de la réception. Peut être aussi un problème de Timer ?

**ShaiLeTroll** · 10/12/2020, 10h06

Utilisation de TComPort sous Delphi 2005 (Win 32)
Que donne déjà la démo en suivant le tutoriel (si il n'y a pas déjà un démo incluse)

La première chose à faire c'est d'envoyer quelques caractères et valider Port,Vitesse,Parité ...

En suite, Delphi a un peu changé, assimiler un binaire à un texte devient plus périlleux

**zohra051** · 10/12/2020, 10h09

Envoyé par ShaiLeTroll

Utilisation de TComPort sous Delphi 2005 (Win 32)
Que donne déjà la démo en suivant le tutoriel (si il n'y a pas déjà un démo incluse)

La première chose à faire c'est d'envoyer quelques caractères et valider Port,Vitesse,Parité ...

En suite, Delphi a un peu changé, assimiler un binaire à un texte devient plus périlleux

Bonjour ShaiLeTroll, merci de m'avoir répondu.
Alors avant cette étape d'envoie, il y a une étape de réception du premier message de la machine qui se déroule parfaitement. Donc cela veut dire que les paramètres sont bon, c'est bien ça ?

1er etape : Réception du message de la machine.
2eme etape : envoyer mon fichier.bin
3eme etape : receptionner le message de retour.

**tourlourou** · 10/12/2020, 10h10

Bonjour, les déclarations des tampons buffer : Array of pchar ; ne devraient-elles pas plutôt être buffer : Array of AnsiChar ; ?

**zohra051** · 10/12/2020, 10h13

Envoyé par tourlourou

Bonjour, les déclarations des tampons buffer : Array of pchar ; ne devraient-elles pas plutôt être buffer : Array of AnsiChar ; ?

A vrai dire je ne sais pas. Je sais qu'en c++ j'envoie un char *. Quel est sont équivalant avec delphi ? AnsiChar ?

**tourlourou** · 10/12/2020, 10h17

AnsiChar pour un caractère d'un octet ; Byte pour un octet (le C ne différencie pas, ce qui n'est utile qu'au programmeur) ; le char* signifiant juste tableau de char (ou byte)

**ShaiLeTroll** · 10/12/2020, 10h29

Autant utiliser un TFileStream et un TMemoryStream

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
 
 
 
var
   myFile : TFileStream;
   myStream: TMemoryStream;
begin
  myFile := TFileStream.Create('..\spectabl.bin', fmOpenRead);
  try
    myStream := TMemoryStream.Create();
    try
      myStream.CopyFrom(myFile, 0); // cela cache une boucle qui bufferise la copie, gestion automatique de la taille
 
      // j'ai pas le .PAS juste le .HPP // 	int __fastcall Write(const void *Buffer, int Count); 
      // Comport2.Write(myStream.Memory), myStream.Size);
 
      // si c'est la version de https://sourceforge.net/projects/comport/files/comport/4.11/ // function Write(const Buffer; Count: Integer): Integer;
      Comport2.Write(PByte(myStream.Memory)^), myStream.Size);
    finally
      myStream.Free();
    end;
  finally
    myFile.Free();
  end;
end;

Si tu connais le C++, TComport fonctionne très bien en C++Builder XE2
Même sujet : envoyer un fichier .bin sur le port serie

Ci-dessus, c'est un envoi plus classique d'un struct/record
BYTE* en Delphi c'est soit un "Array of Byte" (SetLength) ou un "PByte" (GetMem/FreeMem)
pour une question de lisibilité c'est le BYTE de l'unité Window.h typedef unsigned char BYTE;En Delphi, le Byte est un type natif idéal pour le binaire

Code cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/---------------------------------------------------------------------------
/*static*/ bool CxxxSwitchCOMToolHelp::SendxxxSwitchCOMMessage(TComPort* AComPort, const TxxxSwitchCOMMessage &AMsg, /*out*/String &AHexaMsg)
{
  bool Result = false;
  int BufferCount = sizeof(AMsg.Header) + AMsg.Data.DataLength + sizeof(AMsg.Footer);
 
  BYTE* Buffer = new BYTE[BufferCount];
  try
  {
    BYTE* BufferPtr = Buffer;
 
    CopyMemory(BufferPtr, &AMsg.Header, sizeof(AMsg.Header));
    BufferPtr += sizeof(AMsg.Header);
 
    if ((AMsg.Data.DataLength > 0) && AMsg.Data.Value)
    {
      CopyMemory(BufferPtr, AMsg.Data.Value, AMsg.Data.DataLength);
      BufferPtr += AMsg.Data.DataLength;
    }
 
    CopyMemory(BufferPtr, &AMsg.Footer, sizeof(AMsg.Footer));
 
    char* HexaBuf = new char[BufferCount * 2 + 1];
    try
    {
      ZeroMemory(HexaBuf, BufferCount * 2 + 1);
      BinToHex(Buffer, HexaBuf, BufferCount);
      AHexaMsg = HexaBuf;
    }
    __finally
    {
      delete [] HexaBuf;
    }
 
    try
    {
      Result = AComPort->Write(Buffer, BufferCount) == BufferCount;
    }
    catch (const EComPort &e)
    {
      AHexaMsg = AHexaMsg + " : " + e.Message;
    }
  }
  __finally
  {
    delete [] Buffer;
  }
 
  return Result;
}

**zohra051** · 10/12/2020, 10h45

Enfaite, voici mon code en c++ que j'aimerais convertir en delphi.
Merci pour votre patience et votre aide.

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
	std::ifstream specTable("./spectabl.bin",std::ifstream::binary);
	int length;
	char * buffer;
	if(specTable.is_open()){
 
		//lenght of file
		specTable.seekg(0,specTable.end);
		length = specTable.tellg();	
 
		//copy file into buffer
		specTable.seekg(0,specTable.beg);
		buffer = new char [length];
		specTable.read(buffer,length);
 
 
		cout<<"BUFFER : "<<buffer<<endl;
			cout<<"LENGTH : "<<length<<endl;
		if(specTable.gcount() == length){
			cout<<"spectable.bin read successfully."<<endl;
		}
		else{
			cout<<"error: only "<<specTable.gcount()<<" could be read" <<endl;
		}
		specTable.close();
	}
	for(int i = 0; i < sizeof(SerialBuffer); i++){
		SerialBuffer[i] = buffer[i];
	}
 
	Status = WriteFile(hComPhilips, SerialBuffer, sizeof(SerialBuffer), &BytesWritten,NULL);                  
	writeFile_success(Status);
	vider_buffer( SerialBuffer);

Certaine partie du code son en grisé mais elles ne sont pas en commentaire.

**ShaiLeTroll** · 10/12/2020, 10h51

Oublie ce code C++, essaye la variante TMemoryStream proposé ci-dessus ... rien que la gestion de la taille du fichier est géré, pas de besoin de faire le seek de controle
rien que la boucle de copie de SerialBuffer depuis Buffer ... qu'est-ce que c'est inefficace, CopyMemory, Move, il y a tellement mieux pour copier entre deux pointeurs ... sans compter que cela semble inutile, pire ça peut tronquer la donnée si SerialBuffer est trop petit

Ajoute juste un controle que Write retourne le nombre d'octet prévu sur la variante TMemoryStream proposé ci-dessus

**SergioMaster** · 10/12/2020, 10h54

Envoyé par zohra051

Certaine partie du code sont en grisé mais elles ne sont pas en commentaire.

en fait c'est un problème d'analyse de syntaxe (par défaut pascal pour ce forum) . Pour ne pas avoir de "grisé" il faut indiquer dans ma balise de code le langage donc mettre CODE=C++ , j'ai fait la correction

**zohra051** · 10/12/2020, 10h55

Envoyé par SergioMaster

en fait c'est un problème d'analyse de syntaxe (par défaut pascal pour ce forum) . Pour ne pas avoir de "grisé" il faut indiquer dans ma balise de code le langage donc mettre CODE=C++ , j'ai fait la correction

Merci

**zohra051** · 10/12/2020, 10h58

Envoyé par ShaiLeTroll

Oublie ce code C++, essaye la variante TMemoryStream proposé ci-dessus ... rien que la gestion de la taille du fichier est géré, pas de besoin de faire le seek de controle
rien que la boucle de copie de SerialBuffer depuis Buffer ... qu'est-ce que c'est inefficace, CopyMemory, Move, il y a tellement mieux pour copier entre deux pointeurs

Ajoute juste un controle que Write retourne le nombre d'octet prévu

Je viens d'essayer avec TMemoryStream comme tu me l'a conseillé.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
procedure TForm1.ComPort2RxChar(Sender: TObject; Count: Integer);
  var
   ecoute : string;
   hexa : string;
   myFile : TFileStream;
   myStream: TMemoryStream;
 
  begin
    Memo13.ScrollBars := ssVertical;
    Memo16.ScrollBars := ssVertical;
    Memo12.ScrollBars := ssVertical;
 
    // Lecture du message
    Comport2.ReadStr(ecoute,32);
    hexa :=  String2Hex(ecoute);
    Memo13.Text := Memo13.Text + hexa + sLineBreak;
 
    if hexa = ('....') then
      begin
        myFile := TFileStream.Create('..\spectabl.bin', fmOpenRead);
        try
            myStream := TMemoryStream.Create();
            try
              myStream.CopyFrom(myFile, 0); // cela cache une boucle qui bufferise la copie, gestion automatique de la taille
              Comport2.Write(PByte(myStream.Memory)^, myStream.Size);
            FINALLY
              myStream.Free();
            END;
 
        finally
          myFile.Free();
        end;
      end;
 
   if hexa.Contains('E298BB206662') then
   showmessage('CA MARCHE !!');
 
  end;

Sachant que ComPort2RxChar est appelé à chaque fois qu'il y a une donnée qui est envoyé, est ce que je dois rajouter un Comport2.Read() après mon Write ?

**ShaiLeTroll** · 10/12/2020, 11h09

Je n'ai pas utilisé OnRxChar, je préfère un TComDataPacket, j'ai toujours eu des STX et ETX dans les protocoles machines que j'ai du à gérer ... et souvent un LRC/CRC
mais voit le de façon asynchrone
Tu reçois une commande, tu envois un retour, fini juste un flag pour savoir que tu attends la confirmation
Tu reçois une confirmation, tu reset le flag
En tout cas, j'avais des ACK/NAK a gérer et je le faisais ainsi

Ton Read risque d'être prématuré, existe-t-il un WaitForData dans le TComPort ?

**zohra051** · 10/12/2020, 11h13

Envoyé par ShaiLeTroll

Je n'ai pas utilisé OnRxChar, je préfère un TComDataPacket, j'ai toujours eu des STX et ETX dans les protocoles machines que j'ai du à gérer ...
mais voit le de façon asynchrone
Tu reçois une commande, tu envois un retour, fini juste un flag pour savoir que tu attends la confirmation
Tu reçois une confirmation, tu reset le flag

Ton Read risque d'être prématuré, existe-t-il un WaitForData dans le TComPort ?

J'utilisais OnRxChar car c'est la seul que je connais, TcomData est aussi une procédure existante ? Peux tu me détailler STX et ETX s'il te plaît ? Je vais tout de même faire des recherches de mon côté.

Je vais regarder pour le WaitForData.

**ShaiLeTroll** · 10/12/2020, 11h34

Comme je le disais voit cela en deux temps

Premier ComPort2RxChar
1er etape : Réception du message de la machine.
2eme etape : envoyer mon fichier.bin

Second ComPort2RxChar
3eme etape : receptionner le message de retour.

C'est le plus simple, juste que ton ACK/NAK est géré comme n'importe quel autre signal d'entrée ... c'est ta variable hexa

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Comport2.ReadStr(ecoute,32); // faudra utiliser le paramètre Count du ComPort2RxChar

**zohra051** · 10/12/2020, 11h34

Envoyé par zohra051

J'utilisais OnRxChar car c'est la seul que je connais, TcomData est aussi une procédure existante ? Peux tu me détailler STX et ETX s'il te plaît ? Je vais tout de même faire des recherches de mon côté.

Je vais regarder pour le WaitForData.

On me conseil d'utiliser le TComport, donc je ne sais plus trop quoi utiliser. Je trouve que c'est assez compliqué finalement d'envoyer juste un fichier avec delphi. Et que pensez vous de AssignFile, puis Reset et Read ? J'ai aussi testé mais sans succès.

**zohra051** · 10/12/2020, 11h36

Envoyé par ShaiLeTroll

Comme je le disais voit cela en deux temps

Premier ComPort2RxChar
1er etape : Réception du message de la machine.
2eme etape : envoyer mon fichier.bin

Second ComPort2RxChar
3eme etape : receptionner le message de retour.

C'est le plus simple, juste que ton ACK/NAK est géré comme n'importe quel autre signal d'entrée ... c'est ta variable hexa

Comment je pourrais découper ces étapes ? En créant deux fonction ComportRxChar ? Comment savoir celle qui s'exécutera en premier ?

**ShaiLeTroll** · 10/12/2020, 11h45

Envoyé par zohra051

J'utilisais OnRxChar car c'est la seul que je connais, TcomData est aussi une procédure existante ? Peux tu me détailler STX et ETX s'il te plaît ? Je vais tout de même faire des recherches de mon côté.

Je vais regarder pour le WaitForData.

TcomDataPacket est composant de la suite TComport

Après faut un peu de culture des protocoles, STX = Start of Text / ETX = End of Text
Faut lire la documentation de votre protocole, voir si il y a un header, un footer, ...
Vous ne semblez pas procéder un découpage correct de votre donnée, fonctionner par égalité de valeur hexa me semble très douteux
utliser Read au lieu de ReadStr pour recevoir un binaire semble plus prudent, cependant vous devrez maitriser un peu plus les array of byte ou les pointeurs comme PByte, voire même les record/struct

Envoyé par zohra051

On "m'impose" d'utiliser le TComport, donc je ne sais plus trop quoi utiliser. Je trouve que c'est assez compliqué finalement d'envoyer juste un fichier avec delphi. Et que pensez vous de AssignFile, puis Reset et Read ? J'ai aussi testé mais sans succès.

TComport est le sujet que nous avons depuis le début, rien d'autres n'a été évoqué, de quoi parlez-vous ?
AssignFile, puis Reset et Read ... c'est juste une autre façon de lire et charger en mémoire un fichier, TFileStream et TMemoryStream ont l'avantage d'encapsuler tout cela pour une utilisation aisée
Tout cela me semble me semble extrêmement simple, je ne vois pas ce qui est compliqué

Vous êtes l'auteur du code C++ fourni ?
Si oui, autant le fournir en entier, que l'on puisse voir le projet dans sa globalité si c'est juste une réécriture de C++ vers Delphi
Déjà le port COM, ça s'utilise aussi comme un fichier

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

CreateFile(PChar(Format('\\.\COM%d', PortNum)), GENERIC_READ or GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);

et GetCommState/SetCommState et WaitCommEvent
Mais si vous avez du mal avec le simplissime TComPort, les API Windows brutes, vous n'êtes pas prête, faut maitriser les pointeurs à la perfection

Envoyé par zohra051

Comment je pourrais découper ces étapes ? En créant deux fonction ComportRxChar ? Comment savoir celle qui s'exécutera en premier ?

Non, c'est des évènements, lorsque le TComport voit de la donnée à lire, il déclenche un OnRxChar pour indiquer qu'il faut lire, c'est très simple
Vous devez comprendre la notion d'évènement et évidemment que la chronologie sera le miroir de l'interaction entre le PC et le périphérique connecté

**aladin95** · 28/12/2020, 17h07

Bonjour,

J'utilise ces composants TCom de Turbopower depuis pas mal de temps.
ils sont maintenant disponibles en Getit dans les versions 10.x de Delphi
Je pourrais t'aider si tu me donne quelques renseignements sur les échanges.

a) les messages sont des chaines de caractères ou des blocs de bytes ?

c'est notoirement le cas de bloc de bytes pour un fichier .BIN
mais pas obligatoirement pour les messages a recevoir.

b) y a t-il des éléments de distinction dans, et entre, 1ere réception et 2eme réception

soit des suites de caractères soit des suites d'octets bien spécifiques que l'on peut considérer
comme marqueurs de début ou de fin de message ?

c) quelle sont les tailles des message a échanger

sont elles connues ?
si oui : quelles sont les tailles
Sont-ils supérieur ou non, a 4096 octets ?

d) est ce que tous les paramètres d'échange sont connus ?

soit : vitesse (Bauds), nb de bits par octet (Databits), parité (Parity), nb de bits de stop (Stopbits).
une erreur peut faire que cela marche a moitié voir pas du tout.

e) est-il fait mention d'un contrôle de flux (caractères Xon, Xoff)
f) est-ce un échange sur 2, 3 ou plus de fils ?

(si 2 fils c'est du type rs4xx en courant ou tension différentielle, si 3 fils c'est du Rs232 tension simple)
(si plus de fils c'est qu'il y a peut-être un contrôle de flux câblé)

Voila toutes les questions a se poser lors d'échanges en RS232 ou RS422 ou RS485 en dehors de la conversion C vers Pascal qui t'es demandée.

Envoyer un fichier binaire depuis le Tcomport

Delphi

Discussions similaires

Partager

Partager