Delphi-PRAXiS - Welche Sprache und wie in Delphi implementieren?

Delphi-PRAXiS (https://www.delphipraxis.net/forum.php)

- Programmieren allgemein (https://www.delphipraxis.net/40-programmieren-allgemein/)

- - Welche Sprache und wie in Delphi implementieren? (https://www.delphipraxis.net/154064-welche-sprache-und-wie-delphi-implementieren.html)

Welche Sprache und wie in Delphi implementieren?

Hi. Habe mir ein Interface gekauft, welches über serielle Schnittstelle 64 LEDs ansteuern soll.
Die kurze Anleitung zum Interface ist im Anhang.
Das mitgelieferte Programm ist lediglich für einfache Prozesse angelegt(LEDs in einer Konstellation an, eine nach der anderen, ...). Ich suche jetzt eine Möglichkeit mir ein Delphiprogramm zu schreiben, welches einen von mir definierten Ablauf simuliert.
Leider kann ich mit der verwendeten Programmiersprache nix anfangen, da ich lediglich mit Delphi herumexperimentiere.

Das Programm ist eine exe-Datei und in einem Ordner sind mehrere Dateien, die wie Quellcode aussehen.

RSCOM.BAS (vermutlich der Quellcode zur DLL - enthält Deklarationen)
RSCOM.DLL

WR64.frm (Oberfläche und Funktionen)
WR64.frx (nicht lesbar mit Texteditor)
WR64.vbp (allgemeine Programmparameter)
WR64.vbw (kA)
WR64.EXE

Die Quelltext-Dateien lassen sich durch einen einfachen Texteditor öffnen.
Ich vermute stark, dass es sich um Visual Basic handelt. Die Funktionen und schreibweise sind teilweise auch ähnlich wie bei Delphi und könnten (hoffentlich) einfach implementiert werden.
Die Dateien sind alle angehängt.
Ich hoffe jemand hat Zeit mal die Dateien anzuschauen und mir meine Vermutungen zu bestätigen oder zu wiederlegen.

Gibt es irgendwelche Anmerkungen, was ich bei der Implementierung in ein eigenes Delphiprogramm (D7pro auf Win7) beachten sollten?

Vielen Dank.

AW: Welche Sprache und wie in Delphi implementieren?

Du hast recht mit deiner Vermutung, dass es sich um Visual Basic handelt.

Aber die Anhänge fehlen.

AW: Welche Sprache und wie in Delphi implementieren?

Zitat:

RSCOM.BAS (vermutlich der Quellcode zur DLL - enthält Deklarationen)

Das werden wohl eher die Header-Deklarationen der DLL sein, also die Schnittstele zur DLL.

Diese müßtest du dir also "nur" nach Delphi übersetzen und könntest sie dann dort verwenden, natürlich zusammen mit der DLL.

AW: Welche Sprache und wie in Delphi implementieren?

Das Interface hat eine RS232 - Schnittstelle.
Daher würde ich auf die DLL komplett verzichten.

Code:

			Die Übertragungsparameter sind 9600,N,8,1. Beim Start des Controllers

sind alle Ausgabedaten Null. Für die Steuerung durch den PC wurde ein einfaches Protokoll

mit drei Bytes definiert: Geräteadresse, Gruppenadresse, Datenbyte zur Ansteuerung von

jeweils acht Ausgängen.

Stattdessen brauchst du eine RS232-Komponente und steuerst damit das Interface direkt an.

AW: Welche Sprache und wie in Delphi implementieren?

OK, und wenn die Standardparameter des gewünschten COM-Ports seitens Windows schon auf 9600,N,8,1 stehen, dann reicht auch ein

Delphi-Quellcode:

AssignFile(f, 'COM1')

:stupid:

AW: Welche Sprache und wie in Delphi implementieren?

Zitat:

Zitat von himitsu (Beitrag 1045219)

OK, und wenn die Standardparameter des gewünschten COM-Ports seitens Windows schon auf 9600,N,8,1 stehen, dann reicht auch ein

Delphi-Quellcode:

AssignFile(f, 'COM1')

:stupid:

Aber nur wenn im Protokoll ausschließlich ASCII/ANSI-Zeichen und keine Steuerzeichen auftreten, was bei "drei Bytes: Geräteadresse, Gruppenadresse, Datenbyte" eventuell nicht der Fall ist. Und wahrscheinlich gibt's auch Probleme wenn gleichzeitig gelesen und geschrieben werden soll.

AW: Welche Sprache und wie in Delphi implementieren?

Nee.

PS: Die sogenannten RS232-Komponenten nutzen oftmals auch nur den Weg über CreateFile (welches im AssignFile gekapselt ist). :stupid:

AW: Welche Sprache und wie in Delphi implementieren?

Zitat:

Zitat von himitsu (Beitrag 1045219)

OK, und wenn die Standardparameter des gewünschten COM-Ports seitens Windows schon auf 9600,N,8,1 stehen, dann reicht auch ein

Delphi-Quellcode:

AssignFile(f, 'COM1')

Nach meiner Erfahrung werden diese Parameter nur beim Start von Windows so in der Hardware eingestellt.

Wenn danach ein Programm die Schnittstelleneinstellungen verstellt hat, bleiben sie so stehen, wie das Programm sie hinterlassen hat.

Bin nicht sicher, ob das allgemein so ist, konnte es aber schon auf diversen PCs reproduzieren. Deswegen sollte man besser immer alle Schnittstelleneinstellungen zuweisen, entweder über BuildCommDCB oder einen selbst erstellten DCB.

AW: Welche Sprache und wie in Delphi implementieren?

Zitat:

Zitat von himitsu (Beitrag 1045224)

Nee.

PS: Die sogenannten RS232-Komponenten nutzen oftmals auch nur den Weg über CreateFile (welches im AssignFile gekapselt ist). :stupid:

Ach ja?
Welchen Typ soll denn f haben? Und wie liest und schreibst Du gleichzeitig? Und vor allem: wie setzt und liest Du Steuerleitungen (DTR, RTS etc), wie behandelst Du CTS/DSR?

AW: Welche Sprache und wie in Delphi implementieren?

Zitat:

Zitat von himitsu (Beitrag 1045224)

Die sogenannten RS232-Komponenten nutzen oftmals auch nur den Weg über CreateFile

Natürlich. Man braucht ja den von CreateFile zurückgegebenen Handle in allen anderen APIs die etwas mit der seriellen Schnittstelle tun.

http://www.delphipraxis.net/126702-k...erialport.html

AW: Welche Sprache und wie in Delphi implementieren?

Erstmal vielen dank für die zahlreichen antworten.
werd mich gleich mal dransetzen und schauen, was ich feines zusammenbasteln kann ;)

AW: Welche Sprache und wie in Delphi implementieren?

so ich hab mal etwas zeit zu basteln ;)
hab mich zunächst an der DLL versucht, da ich nicht so viel zum orginalprogramm verändern möchte.
die vb deklarationen sahen so aus

Code:

			Attribute VB_Name = "Module1"

Declare Function OPENCOM Lib "RSCOM" (ByVal OpenString$) As Integer

Declare Sub TIMEOUTS Lib "RSCOM" (ByVal b%)

Declare Sub BUFFERSIZE Lib "RSCOM" (ByVal b%)

Declare Sub CLOSECOM Lib "RSCOM" ()

Declare Sub SENDBYTE Lib "RSCOM" (ByVal Dat%)

Declare Function READBYTE Lib "RSCOM" () As Integer

Declare Sub SENDSTRING Lib "RSCOM" (ByVal Dat$)

Declare Function READSTRING Lib "RSCOM" () As String

Declare Sub CLEARBUFFER Lib "RSCOM" ()

Declare Function INBUFFER Lib "RSCOM" () As Integer

Declare Function OUTBUFFER Lib "RSCOM" () As Integer

Declare Sub DTR Lib "RSCOM" (ByVal b%)

Declare Sub RTS Lib "RSCOM" (ByVal b%)

Declare Sub TXD Lib "RSCOM" (ByVal b%)

Declare Function CTS Lib "RSCOM" () As Integer

Declare Function DSR Lib "RSCOM" () As Integer

Declare Function RI Lib "RSCOM" () As Integer

Declare Function DCD Lib "RSCOM" () As Integer

Declare Function INPUTS Lib "RSCOM" () As Integer

Declare Sub TIMEINIT Lib "RSCOM" ()

Declare Function TIMEREAD Lib "RSCOM" () As Double

Declare Sub DELAY Lib "RSCOM" (ByVal ms As Double)

Declare Sub REALTIME Lib "RSCOM" ()

Declare Sub NORMALTIME Lib "RSCOM" ()

Declare Function ShellExecuteA Lib "shell32.dll" ( _

    ByVal hwnd As Long, ByVal lpOperation As String, _

    ByVal lpFile As String, ByVal lpParameters As String, _

    ByVal lpDirectory As String, ByVal nShowCmd As Long _

  ) As Long

bisher sieht meine unit so aus

Delphi-Quellcode:

			unit Controller;

interface

{$L 'RSCOM.dll'}

procedure OPENCOM (OpenString:string); stdcall; external 'RSCOM.dll';

procedure TIMEOUTS (b:integer); stdcall; external 'RSCOM.dll';

procedure BUFFERSIZE (b:integer); stdcall; external 'RSCOM.dll';

procedure CLOSECOM (); stdcall; external 'RSCOM.dll';

procedure SENDBYTE (Dat:string); stdcall; external 'RSCOM.dll';

function READBYTE (): Integer; stdcall; external 'RSCOM.dll';

procedure SENDSTRING (Dat:string); stdcall; external 'RSCOM.dll';

function READSTRING (): String; stdcall; external 'RSCOM.dll';

procedure CLEARBUFFER (); stdcall; external 'RSCOM.dll';

function INBUFFER (): Integer; stdcall; external 'RSCOM.dll';

function OUTBUFFER (): Integer; stdcall; external 'RSCOM.dll';

procedure DTR (b:integer); stdcall; external 'RSCOM.dll';

procedure RTS (b:integer); stdcall; external 'RSCOM.dll';

procedure TXD (b:integer); stdcall; external 'RSCOM.dll';

function CTS (): Integer; stdcall; external 'RSCOM.dll';

function DSR (): Integer; stdcall; external 'RSCOM.dll';

function RI (): Integer; stdcall; external 'RSCOM.dll';

function DCD (): Integer; stdcall; external 'RSCOM.dll';

function INPUTS (): Integer; stdcall; external 'RSCOM.dll';

procedure TIMEINIT (); stdcall; external 'RSCOM.dll';

function TIMEREAD (): Double; stdcall; external 'RSCOM.dll';

procedure DELAY (ms: Double); stdcall; external 'RSCOM.dll';

procedure REALTIME (); stdcall; external 'RSCOM.dll';

procedure NORMALTIME (); stdcall; external 'RSCOM.dll';

function ShellExecuteA (hwnd: Longint; lpOperation: String; lpFile: String;

         lpParameters: String; lpDirectory: String; nShowCmd: Longint): Longint;

         stdcall; external 'shell32.dll';

uses

  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

  Dialogs, StdCtrls;

type

  TForm1 = class(TForm)

    Button1: TButton;

    procedure Button1Click(Sender: TObject);

  private

    { Private-Deklarationen }

  public

    { Public-Deklarationen }

  end;

var

  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);

begin

function INBUFFER (): Integer; stdcall;

end;

end.

jetzt mekert mein delphi natürlich herum, dass noch eine deklaration erwartet wird ( vor uses)
hat jemand eine ahnung, wie ich das handhaben kann?