Ich habe ein problem wo ich schon den ganzen Tag dran hänge . Wie kann ich auf ein Messgerät Hexadezimal werte senden und mit antwort zurückbekommen aus meinen Sendebefehl. Habe es shcon probiert werte eingegeben in ein Edit feld aber so richtig sendet er die Werte nicht gibt es da ein Sendbefehl unter RS 232. Würde mich über eine Antwort freuen .

Gruss Praetorianer

Brauchst halt ne Komponente dafür.

Am besten schau bei www.torry.net nach. Das gibts viele kostenlose Komponenten, die Deinen Zweck erfüllen sollten.

//***************************************************************************
// Header
//***************************************************************************
//---------------------------------------------------------------------------
#ifndef rs232H
#define rs232H
#include "rs232.h"
#include <ComCtrls.hpp>
class rs232
{
private:	// Benutzer-Deklarationen

public:		// Benutzer-Deklarationen

     rs232();   	//Konstruktor
     int baudrate;
     AnsiString comport;
     int timeout;
     bool simulate;
     bool online;
     bool init_rs232(void);
     bool write_rs232(unsigned char data);
     bool read_rs232(unsigned char* data);
     void close_comport(void);
     bool write_check(char data,unsigned char* rs_data);
     bool get_high_low(signed __int16* data);
     bool write_high_low(unsigned int data);
     bool get_modul_values(void);
     void test_comports(TMenuItem* com1,TMenuItem* com2,TMenuItem*        
     com3,TMenuItem* com4);
     bool send_command(char a, char b);
     void controller_error(TStatusBar* obj,char item,TTimer* timer,char* text);
     HANDLE chandle1;
     DCB dcb;
     COMMTIMEOUTS rs232timeout;
};
//---------------------------------------------------------------------------
#endif
//***************************************************************************
// cpp Modul
//***************************************************************************
#include <vcl\vcl.h>
#include <stdio.h>
#include "rs232.h"
//--------------Konstruktor----------------------------------------------------
rs232::rs232()
{
     baudrate = 19200;
     comport  = "com1";
     timeout  = 1000;
     simulate = false;
     online   = false;
}
//------------------------------------------------------------------------------
bool rs232::init_rs232(void)
{
     chandle1 = CreateFile(comport.c_str(),GENERIC_WRITE | GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL);
     if (chandle1 != INVALID_HANDLE_VALUE)
     {
    	GetCommState(chandle1,&dcb);
        GetCommTimeouts(chandle1,&rs232timeout);
      //  dcb.DCBlength = 10;
        dcb.fBinary = true;
        dcb.Parity = false; // no parity bit
        dcb.fOutxCtsFlow = false;
        dcb.fOutxDsrFlow = false;
        dcb.fDtrControl = DTR_CONTROL_DISABLE;
        dcb.fDsrSensitivity = false;
        dcb.fTXContinueOnXoff = false;
    	   dcb.BaudRate = baudrate; // set the baud rate
        dcb.ByteSize = 8; // data size, xmit, and rcv
        dcb.fOutX = false;
        dcb.fInX = false;
        dcb.fErrorChar = false;
        dcb.fNull = false;
        dcb.fRtsControl = RTS_CONTROL_DISABLE;
        dcb.fAbortOnError = false;
        dcb.XonLim;
        dcb.XoffLim;
        dcb.ByteSize;
        dcb.Parity;
        dcb.StopBits = ONESTOPBIT ;
        dcb.XonChar;
        dcb.XoffChar;
        dcb.ErrorChar;
        dcb.EofChar;
        dcb.EvtChar;
        dcb.wReserved1;
        rs232timeout.ReadIntervalTimeout = 1000;
        rs232timeout.ReadTotalTimeoutMultiplier = timeout;
        rs232timeout.ReadTotalTimeoutConstant = 0;
        if(SetCommState(chandle1, &dcb))
        {
            if (SetCommTimeouts(chandle1,&rs232timeout))
            {

               	return 1;
            }
            else
            {
             	CloseHandle(chandle1);
            	return 0;
            }
        }
        else
        {
         	     CloseHandle(chandle1);
               return 0;
        }

    }
    return 0;
}
//------------------------------------------------------------------------------
bool rs232::write_rs232(unsigned char data)
{
	unsigned long y;
 	if (!WriteFile(chandle1,&data,1,&y,0))
     {
    	     return 0;
     }
     return 1;
}
//------------------------------------------------------------------------------
bool rs232::read_rs232(unsigned char* data)
{
	unsigned long b;
 	ReadFile(chandle1,data,1,&b,NULL);
     if (b == 0)
     {
          return 0;
     }
     return 1;
}
//------------------------------------------------------------------------------
void rs232::close_comport(void)
{
     CloseHandle(chandle1);
     return;
}
//------------------------------------------------------------------------------
bool rs232::write_check(char data,unsigned char* rs_data)
{
     if(simulate)
     {
          rs_data = (unsigned char*) 0x55;
          return 1;
     }
     write_rs232(data);
     if (!read_rs232(rs_data))
     {
          return 0;
     }
     return 1;
}
//------------------------------------------------------------------------------
bool rs232::send_command(char a, char b)
{
     unsigned char back;
     if(a != NULL)
     {
          if (write_check(a,&back))              //Prog End
          {
               if (!write_check(b,&back))
    		     {
                    return 0;
    		     }
          }
          else
          {
               return 0;
          }
          return 1;
     }
     else
     {
          if (!write_check(b,&back))
    		{
               return 0;
    		}
          return 1;
     }
     return 0;
}
//------------------------------------------------------------------------------
bool  rs232::get_high_low(signed __int16* data)
{
     unsigned char rs_data;
     signed int temp;
 	if (!write_check(0,&rs_data))
     {
    	     return 0;
     }
     else
     {
       	temp =  rs_data << 8;
     }
     if (!write_check(0,&rs_data))
     {
    	     return 0;
     }
     else
     {
          temp = temp | rs_data;
     }
    *data = temp;
    return 1;
}
//-----------------------------------------------------------------------------
bool  rs232::write_high_low(unsigned int data)
{
     unsigned char rs_data;
 	if (!write_check(data>>8,&rs_data))
     {
    	     return 0;
     }
     else
     {
     	if (!write_check(data,&rs_data))
     	{
    	     	return 0;
     	}
	}
    return 1;
}
//-----------------------------------------------------------------------------
void rs232::test_comports(TMenuItem* com1,TMenuItem* com2,TMenuItem* com3,TMenuItem* com4)
{
 	comport = "com1";
	if(init_rs232())
     {
		com1->Enabled = true;
	}
     close_comport();

	comport = "com2";
	if(init_rs232())
     {
     	com2->Enabled = true;
	}
     close_comport();

    	comport = "com3";
	if(init_rs232())
     {
     	com3->Enabled = true;
	}
     close_comport();

	comport = "com4";
	if(init_rs232())
     {
     	com4->Enabled = true;
	}
     close_comport();
     return;
}
void rs232::controller_error(TStatusBar* obj,char item,TTimer* timer,char* text)
{
     online = false;
     if(obj != NULL)
     {
          if(item != NULL)
          {
               obj->Panels->Items[item]->Text = "Status:Offline";
          }
          else
          {
               obj->SimpleText = "Status:Offline";
          }
     }
     if(timer != NULL)
     {
          timer->Enabled = false;
     }
	Application->MessageBox("Programm is Offline",text,MB_OK | 
         MB_ICONERROR);
     return;
}

Du benötigst zum senden eines Bytes nur die Funktion write_rs232 sowie
zum empfangen eines Bytes die Funktion read_rs232.

//--------------------------------------------------------
// Objekt com erzeugen und Eigenschaften initialisieren
//--------------------------------------------------------
     com = new rs232;
     com->baudrate = 19200;     //Baudrate 19200
     com->comport  = "com1";    //Port Com1 
     com->timeout  = 500;       //Timeout 500ms

//--------------------------------------------------------
// Port initialisieren
//--------------------------------------------------------

     if(!(com->init_rs232()))
     {
          Application->MessageBox("RS232 Port not found"," ",MB_OK | 
          MB_ICONERROR);
     }

//--------------------------------------------------------
// Senden
//--------------------------------------------------------

     if(!com->write_rs232(0xaa))
     {
          //Sende Fehler
     } 
          //Erfolgreich gesendet

//--------------------------------------------------------
// Empfangen
//--------------------------------------------------------

   char data;

     if(!com->read_rs232(&data)) 
     {
         //Fehler        z.B. Timeout 500ms
     }
        //Erfolgreich Byte in data

Beim Starten der Anwendung muss
CommSettings->LoadFromINI();
aufgerufen werden.

beim Beenden kann
CommSettings->SaveToINI();
aufgerufen werden, wenn man die Einstellungen speichen will.

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

   .-------------------------------------------------------------------------.
   |  S I E M E N S   E N G I N E   5.1                                      |
   |  (c) 2004 by ACiD[mrp]                                                  |
   |                                                                         |
   |  GSM Development Crew                                                   |
   |  www.gsm-dev.com                                                        |
   |                                                                         |
   |  COM, USB, AT, BFB, BFC, IrObex, Flash35, Flash45, Flash55, Flash65     |
   |                                                                         |
   '-------------------------------------------------------------------------'

#ifndef CommSettingsH
#define CommSettingsH
//---------------------------------------------------------------------------
#include <SysUtils.hpp>
#include <Classes.hpp>
#include <Controls.hpp>
#include <ExtCtrls.hpp>
#include <registry.hpp>
#include <inifiles.hpp>

//---------------------------------------------------------------------------
class PACKAGE TCommSettings : public TPanel
{
private:
    TLabel * lblComPort;
    TComboBox * selComPort;

    TLabel * lblBaudRate;
    TComboBox * selBaudRate;

    void __fastcall TCommSettings::GetCommPorts(TStrings *strCommPorts);
    void __fastcall TCommSettings::GetPortSpeeds(TStrings *strPortSpeeds);
    void __fastcall TCommSettings::Resize(TObject *Sender);
protected:
public:
    void __fastcall TCommSettings::LoadFromINI(void);
    void __fastcall TCommSettings::SaveToINI(void);
    AnsiString __fastcall TCommSettings::GetPort(void);
    int __fastcall TCommSettings::GetBaudRate(void);

    __fastcall TCommSettings(TComponent* Owner);
__published:
};
//---------------------------------------------------------------------------
#endif

#include <vcl.h>

#pragma hdrstop

#include "CommSettings.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------
// Mit ValidCtrCheck wird sichergestellt, daß die erzeugten Komponenten
// keine rein virtuellen Funktionen besitzen.
//

static inline void ValidCtrCheck(TCommSettings *)
{
    new TCommSettings(NULL);
}

//---------------------------------------------------------------------------
__fastcall TCommSettings::TCommSettings(TComponent* Owner)
    : TPanel(Owner)
{

    lblComPort = new TLabel(this);
    lblComPort->Parent = this;
    lblComPort->Left = 8;
    lblComPort->Top = 8;
    lblComPort->Caption = "COM Port:";

    selComPort = new TComboBox(this);
    selComPort->Parent = this;
    selComPort->Left = 24;
    selComPort->Top = 24;
    selComPort->Style = csDropDownList;

    lblBaudRate = new TLabel(this);
    lblBaudRate->Parent = this;
    lblBaudRate->Left = 8;
    lblBaudRate->Top = 56;
    lblBaudRate->Caption = "Baud Rate:";

    selBaudRate = new TComboBox(this);
    selBaudRate->Parent = this;
    selBaudRate->Left = 24;
    selBaudRate->Top = 72;
    selBaudRate->Style = csDropDownList;

    this->Constraints->MinHeight = 105;
    this->Constraints->MinWidth = 177;
    this->OnResize = Resize;
    this->Height = 105;
    this->Width = 177;
    //LoadFromINI();

}

void __fastcall TCommSettings::Resize(TObject *Sender)
{
    this->Caption = "";
}

void __fastcall TCommSettings::GetPortSpeeds(TStrings *strPortSpeeds)
{
    strPortSpeeds->Clear();
    strPortSpeeds->Add("1200");
    strPortSpeeds->Add("2400");
    strPortSpeeds->Add("4800");
    strPortSpeeds->Add("9600");
    strPortSpeeds->Add("19200");
    strPortSpeeds->Add("38400");
    strPortSpeeds->Add("57600");
    strPortSpeeds->Add("115200");
    strPortSpeeds->Add("230400");
    strPortSpeeds->Add("460800");
    strPortSpeeds->Add("921600");
    strPortSpeeds->Add("1843200");
    strPortSpeeds->Add("3686400");
}

void __fastcall TCommSettings::GetCommPorts(TStrings *strCommPorts)
{
    // Alle verfügbaren COM Ports aus der Registry auslesen
    // und als TStrings zurückgeben
    TStringList *MyStringList = new TStringList;
    TRegistry *MyReg = new TRegistry;
    MyReg->RootKey = HKEY_LOCAL_MACHINE;
    MyReg->OpenKey("\\HARDWARE\\DEVICEMAP\\SERIALCOMM", false);
    MyReg->GetValueNames(MyStringList);
    for (int i=0; i<MyStringList->Count; i++) {
        MyStringList->Strings[i] = MyReg->ReadString(MyStringList->Strings[i])
             + ": "
             + MyStringList->Strings[i].SubString(9,MyStringList->Strings[i].Length())
             + "";
    }
    MyStringList->Sort();

    for (int i=0; i<MyStringList->Count; i++) {
        strCommPorts->Add(MyStringList->Strings[i]);
    }
    if (strCommPorts->Count == 0) {
        // Autodetection failed
        for (int i = 1; i<129; i++) {
            strCommPorts->Add("COM"+IntToStr(i));
        }
    }

    MyReg->CloseKey();
    delete MyReg;
    delete MyStringList;
}

AnsiString __fastcall TCommSettings::GetPort(void)
{
    //return "COM4";
    return selComPort->Text;
    //ShowMessage(selComPort->Items->Strings[selComPort->ItemIndex]);
}

int __fastcall TCommSettings::GetBaudRate(void)
{
    return selBaudRate->Text.ToIntDef(115200);
}

void __fastcall TCommSettings::LoadFromINI(void)
{
    GetCommPorts(selComPort->Items);
    GetPortSpeeds(selBaudRate->Items);

    TIniFile *ini;
    ini = new TIniFile(ChangeFileExt(Application->ExeName, ".ini"));

    AnsiString strTemp=ini->ReadString("COMPort", "COMPortNumber", "COM1");
    for (int i = 0; i<selComPort->Items->Count; i++) {
        if (selComPort->Items->Strings[i].SubString(1,strTemp.Length()) == strTemp) {
            selComPort->ItemIndex = i;
            i=selComPort->Items->Count;  // break
        }
    }

    int iTemp = ini->ReadInteger("COMPort","COMPortSpeed", 115200);
    for (int i = 0; i<selBaudRate->Items->Count; i++) {
        if (selBaudRate->Items->Strings[i].ToIntDef(0) == iTemp) {
            selBaudRate->ItemIndex = i;
            i=selBaudRate->Items->Count;  // break
        }
    }

    delete ini;
}

void __fastcall TCommSettings::SaveToINI(void)
{
    TIniFile *ini;
    ini = new TIniFile(ChangeFileExt(Application->ExeName, ".ini"));

    AnsiString strTemp=selComPort->Text;
    strTemp = strTemp.SubString(1, strTemp.AnsiPos(":")-1);
    ini->WriteString("COMPort", "COMPortNumber", strTemp);
    ini->WriteInteger("COMPort","COMPortSpeed", selBaudRate->Text.ToIntDef(115200));

    delete ini;
}

//---------------------------------------------------------------------------
namespace Commsettings
{
    void __fastcall PACKAGE Register()
    {
         TComponentClass classes[1] = {__classid(TCommSettings)};
         RegisterComponents("gsm-dev", classes, 0);
    }
}
//---------------------------------------------------------------------------

Ich möchte einige Sachen in deinem Code gerne erklärt bekommen.
Wäre es für dich ein Problem einige Fragen zu beantworten?