Hab mir grad ein Programm zusammengebastelt, mit dem ich Daten via serieller Schnittstelle senden & empfangen kann! Nun würde ich gerne das Programm so erweitern das ich mir die Ankommenden Signale wie auf einem Oszilloskop ansehen kann! Doch wie mach ich so was!?

Sollte ungefähr so aussehen:

http://www.hsg-kl.de/faecher/inf/netze/oszi/index.php

Danke schon mal für die Antworten

//--- Bisheriger Code ---

#include <vcl.h>
#include "RS232.h"

// Standart Konstrukter-------------------------------------------------------------------------------------
RS232::RS232()
{
   // Standarteinstellungen
   this->UsedPort = "COM1";
   this->Paritaet = "NONPARITY";
   this->Baudrate = 9600;
   this->Datenbits = 8;
   this->PortOpen = false;
   this->PortSet = false;
   this->EnableErrorBoxes = true;
};
//---------------------------------------------------------------------------------------------------------

// Standart Destruktor-------------------------------------------------------------------------------------
RS232::~RS232(){};
//---------------------------------------------------------------------------------------------------------

// Öffnet den gewählten Port-------------------------------------------------------------------------------
void RS232::OpenSeriell()
{
   this->MyComPort = CreateFile(UsedPort.c_str(), GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
};
//---------------------------------------------------------------------------------------------------------

// Schließt den geöffneten Port----------------------------------------------------------------------------
void RS232::CloseSeriell()
{
   CloseHandle(this->MyComPort);
}
//---------------------------------------------------------------------------------------------------------

// Überprüft ober der Port ferfügbar ist-------------------------------------------------------------------
bool RS232::CheckPort(AnsiString Port)
{
   SetUsedPort(Port);
   OpenSeriell();

   if(IsPortOpen())
   {
      CloseSeriell();
      RS232();
      return true;
   }
   else
   {
      RS232();
      return false;
   }
}
//---------------------------------------------------------------------------------------------------------

// Configuriert den geöffneten Port------------------------------------------------------------------------
void RS232::SetSeriell()
{
   DCB dcb; // Device Control Block

   BOOL fSuccess = GetCommState(this->MyComPort, &dcb);

   if(!fSuccess && this->EnableErrorBoxes)
   {
      MessageBox(NULL, "Fehler beim Öffen der Configuration des Ports!", "Warnung", 0);
   }

   dcb.BaudRate = this->Baudrate;   // Baudrate
   dcb.ByteSize = this->Datenbits;  // 8 Datenbits
   dcb.Parity = //this->Paritaet.c_str(); // keine Parität
   dcb.StopBits = ONESTOPBIT;       // 1 Stopbit

   fSuccess = SetCommState(this->MyComPort, &dcb);

   if (!fSuccess && this->EnableErrorBoxes)
   {
      MessageBox(NULL, "Fehler beim Schreiben der Configuration des Ports!", "Warnung", 0);
   }
};
//---------------------------------------------------------------------------------------------------------

// Setzt den zu öffnenden Port-----------------------------------------------------------------------------
void RS232::SetUsedPort(AnsiString UsedPort)
{
   this->UsedPort = UsedPort;
}
//---------------------------------------------------------------------------------------------------------

// Setzt die zu benüzende Baudrate-------------------------------------------------------------------------
void RS232::SetBaudrate(int Baudrate)
{
   this->Baudrate = Baudrate;
}
//---------------------------------------------------------------------------------------------------------

// Setz die Parität----------------------------------------------------------------------------------------
void RS232::SetParity(AnsiString Paritaet)
{
   //
}
//---------------------------------------------------------------------------------------------------------

// Setzt die anzahl Datenbits------------------------------------------------------------------------------
void RS232::SetDatenbits(int Datenbits)
{
   this->Datenbits = Datenbits;
}
//---------------------------------------------------------------------------------------------------------

AnsiString RS232::GetUsedPort()
{
   return this->UsedPort;
}
//---------------------------------------------------------------------------------------------------------

int RS232::GetBaudrate()
{
   return this->Baudrate;
}
//---------------------------------------------------------------------------------------------------------

int RS232::GetDatenbits()
{
   return this->Datenbits;
}
//---------------------------------------------------------------------------------------------------------

bool RS232::IsPortOpen()
{
   if(this->MyComPort == INVALID_HANDLE_VALUE)
   {
      return false;
   }
   else
   {
      return true;
   }
}
//---------------------------------------------------------------------------------------------------------

// Überprüft ob der geöffnete Port Configuriert wurde------------------------------------------------------
bool RS232::IsPortSet(){return true;};
//---------------------------------------------------------------------------------------------------------

// Methode zum senden von Daten----------------------------------------------------------------------------
int RS232::Send(char Data[], int n)
{
   DWORD NumberOfBytesWritten; //Anzahl der gesendeten Bytes

   bool b = WriteFile(this->MyComPort, // handle des Com-Ports
     Data, // Adresse der Daten
     n, // Anzahl der zu sendenden Bytes
     &NumberOfBytesWritten, // Adresse übergeben
     0); // kein overlapped I/O

   if (!b)
   {
      MessageBox(NULL, "Fehler beim Senden der Daten!", "Warnung", 0);
   }

   return NumberOfBytesWritten;
};
//---------------------------------------------------------------------------------------------------------

// Methode zum empfangen von Daten-------------------------------------------------------------------------
DWORD RS232::Receive(char* Data, int n)
{
   DWORD NumberOfBytesRead; // Anzahl der gelesenen Bytes
   bool b = ReadFile(this->MyComPort, Data, n, &NumberOfBytesRead, 0);

   if(!b)
   {
      MessageBox(NULL, "Fehler beim Empfangen der Daten", "Warnung", 0);
   }

   return NumberOfBytesRead;
};
//---------------------------------------------------------------------------------------------------------

// Setzt die Tiemouts für den Empfang----------------------------------------------------------------------
void RS232::SetReadTimeouts()
{
   // Alle Wert sind in Millisekunden
   COMMTIMEOUTS com_time;

   com_time.ReadIntervalTimeout = 100;            // Zeit zwischen zwei Zeichen
   com_time.ReadTotalTimeoutMultiplier = 0;       // pro Zeichen
   com_time.ReadTotalTimeoutConstant = 1;
   com_time.WriteTotalTimeoutMultiplier = 0;
   com_time.WriteTotalTimeoutConstant = 0;

   if(!SetCommTimeouts(this->MyComPort, &com_time))
   {
      MessageBox(NULL, "Fehler beim Setzen der Timeouts", "Warnung", 0);
   }
}
//---------------------------------------------------------------------------------------------------------

Entsprechende Zeichenfunktionen benutzen. Siehe BCB-Hilfe zu TCanvas.
Eventuell reicht auch das fertige TPerformanceGraph.

bis bald
akari

Und was haben einzelne Bits mit Oszilatoren zu tun?

Jedenfalls kannst du das mit [/url]Bitoperationen[/url] machen.

bis bald
akari

for (i=0; i<8; i++) if (datenbyte & (1 << i)) Ausgabe("1");
                    else Ausgabe("0");

MfG