OleVariant som VarByte i Delphi 7 Enterprise

Dette er nu Delphi kategorien, men hvordan ser din kode ud?

Uha - ja sådan kan det gå, når man ikke udtrykker sig helt klart.

Jeg har ikke benyttet mig af denne side før, så jeg har vist været MEGET nærig med point; hvad de end kan bruges til.
Men et svar der hjælper mig over mine problemer, er sikkert meget mere værd.

Jeg skriver et program i Delphi 7, dette program skal kommunikere med en ydre enhed via RS232.
Denne ydre enhed skal tilgåes ved hjælp af en OCX (ActiveX), det er af fabrikanten holdt "hemmeligt", hvordan man kommunikerer med enheden, så den eneste vej er over denne OCX.

Det er i manualen beskrevet at der skal benyttes OleVariant.

Jeg har klippet dette stykke ud af den medfølgende "PoiLib_TLB.PAS"
// *********************************************************************//
// DispIntf:  _DPOI
// Flags:    (4112) Hidden Dispatchable
// GUID:      {B9DF0AD4-D5E8-11D6-882D-0050FC262051}
// *********************************************************************//
  _DPOI = dispinterface
    ['{B9DF0AD4-D5E8-11D6-882D-0050FC262051}']
    property MethodVersion: WideString dispid 1;
    function GetSetting(sFamilyAddress: Smallint; sDeviceAddress: Smallint;
                        SettingID: Smallint): OleVariant; dispid 10;
    function SetSetting(sFamilyAddress: Smallint; sDeviceAddress: Smallint; sID:
                        Smallint;
                        vaValue: OleVariant): WordBool; dispid 11;

Jeg har ikke problemer med at benytte funktionen "GetSettings", indholdet fra OleVariant kan læses uden problemer.

Men når jeg i mit kald til funktionen "SetSettings" prøver at sætte Olevariant til en VarByte går det galt,
et efterfølgende kald til VarType, siger at variablen i OleVariant vValue er VarInteger

Her er min kode med kaldet til "SetSettings"
Procedure tPoiForm.sSetBitBtnClick(Sender : tObject);
Var
  sID    : SmallInt;
  iValue  : SmallInt;
  lValue  : Integer;
  bValue  : Boolean;
  sValue  : String;
  sResult : WordBool;
  vValue  : OleVariant;
  cValue  : Byte;

Begin
  // Tell which command You want to execute
  sID := sActionComboBox.ItemIndex;

  // Select the correct variable type, and Execute Command
  Case sTypeRadioGroup.ItemIndex Of
    0 : Begin  // Boolean
          bValue := StrToBool(sValueEdit.Text);
          vValue := bValue;
          sResult := PoiOcx.SetSetting(FamilyAds, DeviceAds, sID, vValue);
        End;
    1 : Begin  // Byte
          cValue := Byte(StrToInt(sValueEdit.Text));
          vValue := cValue;
          // Vis VarType
          VarEdit.Text := IntToStr(VarType(vValue));
          // Send kommando til OCX
          sResult := PoiOcx.SetSetting(FamilyAds, DeviceAds, sID, vValue);
        End;

Dette her er jo ordentlig mundfuld; men kan koges ned til: OleVariant vil ikke
være af VarType VarByte

Bent

Gaar ud fra, du faar fejl i denne linie:
sResult := PoiOcx.SetSetting(FamilyAds, DeviceAds, sID, vValue);

Brokker den sig over, at du med vValue angiver en integer, og ikke en byte?

Hvad med:
sResult := PoiOcx.SetSetting(FamilyAds, DeviceAds, sID, Byte(vValue));


Er det en PLC, du vil kommunikere med?

Hej js

Jeg prøver at kommunikere med en FM demodulator "Profline SFD".

Ja det er rigtigt, det er netop tilskrivning til denne Olevariant, der ikke lykkes.
Ja jeg har prøvet dit forslag; men desværre med samme negative resultat.

Jeg har derfor lavet et lille testprogram der tilskriver en Variant og henholdsvis en Olevariant en række VarTyper.
Variant accepterer de tilskrevne Vartyper uden problemer; men ved tilskrivninger til OleVariant bliever både Byte og SmallInt opfattet som Integer.

Dette program viser hvad der sker:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Memo1  : TMemo;
    Memo2  : TMemo;
    Button1 : TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
Var
  VariantVal    : Variant;
  OleVariantVal : OleVariant;
  SmallIntVal  : SmallInt;
  BooleanVal    : Boolean;
  ByteVal      : Byte;
  IntegerVal    : Integer;
  StringVal    : String;

  Procedure ShowVariant;
  Begin
    Memo1.Lines.Add('Var type: ' + IntToStr(VarType(VariantVal)) +
                    '      Oprindelig VarType: ' + IntToStr(VariantVal));
  End;

  Procedure ShowOleVariant;
  Begin
    Memo1.Lines.Add('Var type: ' + IntToStr(VarType(OleVariantVal)) +
                    '      Oprindelig VarType: ' + IntToStr(OleVariantVal));
  End;

begin
  Memo1.Clear;

  SmallIntVal := 2;
  ByteVal    := 17;
  IntegerVal  := 3;
  BooleanVal  := False;
  StringVal  := '256'; // VarString

  Memo1.Lines.Add('Variant');

  VariantVal := SmallIntVal;
  ShowVariant;

  VariantVal := ByteVal;
  ShowVariant;

  VariantVal := IntegerVal;
  ShowVariant;

  VariantVal := BooleanVal;
  Memo1.Lines.Add('Var type: ' + IntToStr(VarType(VariantVal)) +
                  '      Oprindelig VarType: 11');

  VariantVal := StringVal;
  Memo1.Lines.Add('Var type: ' + IntToStr(VarType(VariantVal)) +
                  '      Oprindelig VarType: ' + VariantVal);

  Memo1.Lines.Add('');
  Memo1.Lines.Add('OleVariant');

  OleVariantVal := SmallIntVal;
  ShoWOleVariant;

  OleVariantVal := ByteVal;
  ShoWOleVariant;

  OleVariantVal := IntegerVal;
  ShoWOleVariant;

  OleVariantVal := BooleanVal;
  Memo1.Lines.Add('Var type: ' + IntToStr(VarType(OleVariantVal)) +
                  '      Oprindelig VarType: 11');

  StringVal  := '8'; // 8 = VarOleStr
  OleVariantVal := StringVal;
  Memo1.Lines.Add('Var type: ' + IntToStr(VarType(OleVariantVal)) +
                  '      Oprindelig VarType: ' + OleVariantVal);

end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  Memo2.Clear;
  Memo2.Lines.Add('Først tilskrives en variant forskellige vartyper,' +
                  ' disse tilskrivninger er ok.');
  Memo2.Lines.Add('');
  Memo2.Lines.Add('Derefter tilskrives en OleVariant de samme vartyper. ' +
                  ' Her ses det at Byte og SmallInt opfattes som Integer' +
                  ' efter tilskrivning til OleVarianten.');
  Memo2.Lines.Add('');
  Memo2.Lines.Add('VarTyper:');
  Memo2.Lines.Add('');
  Memo2.Lines.Add('VarSmallInt = 2');
  Memo2.Lines.Add('VarInteger = 3');
  Memo2.Lines.Add('VarOleStr = 8');
  Memo2.Lines.Add('VarByte = 17');
  Memo2.Lines.Add('VarBoolean = 11');
  Memo2.Lines.Add('VarString = 256');
end;

end.

Jeg har selvfølgelig prøvet at kalde med en Variant i stedet for en Olevariant; men da kaldet jo går til en OleVariant er resultatet det samme.

Problemet må jo ligge  Delphis OleVariant; men jeg kan ikke finde meget om denne type.

Med vh

Bent

Hej js

Efter at have prøvet alle forskellige legale metoder, viste det sig umuligt at tilskrive olevariablen en byte.

Jeg har derfor prøvet at "snyde på vægten"
Jeg opretter en almindelig variant, tilskriver den en byte. Opretter en Olevariant og kopierer indholdet af varianten til olevarianten.
DET VIRKER!

Var
  Xvariant : Variant;
  Yvariant : OleVariant;
  Zvalue  : Byte;
Begin
  Zvalue := 30;
  Xvariant := Zvalue; // Xvariant er nu VarByte
  Move(Xvariant, Yvariant, SizeOf(Yvariant); // Yvariant er nu VarByte
    .... udfør de ønskede kald (er prøvet, og det virker)
End

Med vh

Bent

Hej js

Efter at have prøvet alle forskellige legale metoder, viste det sig umuligt at tilskrive olevariablen en byte.

Jeg har derfor prøvet at "snyde på vægten"
Jeg opretter en almindelig variant, tilskriver den en byte. Opretter en Olevariant og kopierer indholdet af varianten til olevarianten.
DET VIRKER!

Var
  Xvariant : Variant;
  Yvariant : OleVariant;
  Zvalue  : Byte;
Begin
  Zvalue := 30;
  Xvariant := Zvalue; // Xvariant er nu VarByte
  Move(Xvariant, Yvariant, SizeOf(Yvariant); // Yvariant er nu VarByte
    .... udfør de ønskede kald (er prøvet, og det virker)
End

Med vh

Bent