Discussion :

[zohra051]

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]

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 ?

[tourlourou]

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

[zohra051]

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]

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]

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;
}

[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

[zohra051]

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.

[aladin95]

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.