Bizerba Waage ansprechen

Hallo zusammen
Nachdem ich nun seit geraumer Zeit weder bei Google noch anderen Quellen fündig geworden bin und auch Bizerba nicht in der Lage oder besser nicht gewillt ist mit passender Antwort zu helfen, versuche ich es mal hier.

Zum Problem:
Ich habe eine Bizerba CS300 Wägezelle über einen Profilec USB Adapter auf COM 3 und würde diese gerne in Chromis Pos JAVA einbinden.
Ich habe einen passenden und funktionierenen Windows Treiber BDD6.dll über die App dazu kann ich der Waage auch Daten senden und lesen.
Desweiteren habe ich eine Delphi Schnittstelle aber keine Ahnung von Delphi :)

C:
// Hier stehen die Funktionen, die die Dll bereitstellt

/*
*  author        Gerd Alber
*  version        1.0
*  date        01.09.2005
*  bug            -keine-
*  warning        -keine-
*  todo        -keine-
*  
*    Kurzbeschreibung:
*
*    In dieser Header-Datei sind die Funktionen beschrieben, die der Treiber BDD6 zu verfügung stellt.
*                      
*/

#ifndef __bdd6_c__
#define __bdd6_c__

#ifdef __cplusplus
extern "C" {
#endif

#define MYCONST                const

typedef unsigned int        MYUINT;
typedef unsigned long        MYDWORD;
typedef bool                MYBOOL;

#ifdef _UNICODE
    typedef unsigned short            MYTCHAR;
    typedef const unsigned short    *MYLPCTSTR;
#else
    typedef char            MYTCHAR;
    typedef const char        *MYLPCTSTR;
#endif



// Offnet einen ComPort über den der Datenaustausch mit der Waage statt findet
// Sollte als erstes von der Anwendung aufgerfufen werden
// 1. Parameter:    Portnummer
// Return:            Errorcode
#if _USRDLL
MYDWORD __declspec(dllexport)OpenComPort(MYUINT);
#else
MYDWORD __declspec(dllimport)OpenComPort(MYUINT);
#endif

// Schliesst den ComPort
// Sollte bevor sich die Anwendung schliesst, aufgerufen werden
// Return:            Errorcode  
#if _USRDLL
MYDWORD __declspec(dllexport)CloseComPort();
#else
MYDWORD __declspec(dllimport)CloseComPort();
#endif

// Sendet Daten an die Waage (Grundpreis, Tara, Text)
// Ein Grundpreis muss immer angegeben werden. Die anderen Parameter sind optional
// 1. Parameter:    Grundpreis
// 2. Parameter:    Tara-Wert
// 3. Parameter:    Text
// Retrun:            Errorcode
#if _USRDLL
MYDWORD __declspec(dllexport)SendData(MYCONST MYTCHAR*, MYCONST MYTCHAR*, MYCONST MYTCHAR*);
#else
MYDWORD __declspec(dllimport)SendData(MYCONST MYTCHAR*, MYCONST MYTCHAR*, MYCONST MYTCHAR*);
#endif

// Ruft Daten von der Waage ab (Gewichtswert, Grundpreis, Verkaufspreis)
// 1. Parameter:    Grundpreis
// 2. Parameter:    Tara-Wert
// 3. Parameter:    Text
// Retrun:            Errorcode
#if _USRDLL
MYDWORD __declspec(dllexport)ReceiveData(MYTCHAR*, MYTCHAR*, MYTCHAR*);
#else
MYDWORD __declspec(dllimport)ReceiveData(MYTCHAR*, MYTCHAR*, MYTCHAR*);
#endif

// Schaltet die Logische Versionsnummer der Waage an oder aus
// Wenn TRUE als Übergabeparameter wird die Logische Versionsnummer angeschaltet und bleibt solange
// aktiv bis die Funktion mit dem Übergabeparameter FALSE aufgerufen wird
// 1. Parameter:    TRUE = On; FALSE = Off
// Retrun:            Errorcode
#if _USRDLL
MYDWORD __declspec(dllexport)LogicalVersN(MYBOOL);
#else
MYDWORD __declspec(dllimport)LogicalVersN(MYBOOL);
#endif

// Setzt die Checksumme und den Korrekturwert der Anwendung im Treiber
// Diese Funktion sollte zyklisch aufgerufen werden, so dass immer eine sinvolle Checksummenprüfung gewährleistet ist
// 1. Parameter:    Checksumme
// 2. Parameter:    Korrekturwert
// Retrun:            Errorcode
#if _USRDLL
void __declspec(dllexport)SetCSKW(MYDWORD, MYDWORD);
#else
void __declspec(dllimport)SetCSKW(MYDWORD, MYDWORD);
#endif

// Die Funktion kann zur Checksummenbildung über eine Datei benutzt werden.
// 1. Parameter:    Vollständiger Pfad der Datei über die die Checksumme gebildet werden soll
// Return:            Checksumme
#if _USRDLL
MYDWORD __declspec(dllexport)CalcCS(MYTCHAR*);
#else
MYDWORD __declspec(dllimport)CalcCS(MYTCHAR*);
#endif

// Gibt den Korrekturwert zurück
// Der Korrekturwert (Hexwert z.B. F83G) wird in eine mit Zufallszahlen generierte Datei mit einem Byteoffset geschrieben.
// Der KW wird dann mit Hilfe dieser Funktion wieder aus dieser Datei ausgelesen. Wichtig ist hierbei die richtige Angabe
// des ByteOffsets, damit der KW gefunden werden kann
// 1. Parameter        Vollständiger Name der Datei, die den KW beinhaltet
// 2. Parameter        Gibt an nach wievielen Bytes der KW zu lesen ist, gesehen vom Anfang der Datei
// Return:            Gelesener Korrekturwert
#if _USRDLL
MYDWORD __declspec(dllexport)GetKW(MYTCHAR*, MYUINT);
#else
MYDWORD __declspec(dllimport)GetKW(MYTCHAR*, MYUINT);
#endif

// Mit Hilfe dieser Funktion kann ein Fehlercode im Klartext beschrieben werden
// 1. Parameter:    Errorcode
// Return:            Constanter Zeiger auf Fehlernachricht
#if _USRDLL
MYLPCTSTR __declspec(dllexport)GetErrorString(MYDWORD);
#else
MYLPCTSTR __declspec(dllimport)GetErrorString(MYDWORD);
#endif


#ifdef __cplusplus
}
#endif

#endif
Ich würde gerne dazu gerne folgenden Code umarbeiten bzw. ergänzen
Java:
package uk.chromis.pos.scale;

import gnu.io.CommPortIdentifier;
import gnu.io.NoSuchPortException;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import gnu.io.UnsupportedCommOperationException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.TooManyListenersException;

/**
*
*  
*/
public class ScaleComm implements Scale, SerialPortEventListener {
   
    private String m_sPortScale;
    private CommPortIdentifier m_PortIdPrinter;
    private SerialPort m_CommPortPrinter;    
    private OutputStream m_out;
    private InputStream m_in;

    private static final int SCALE_READY = 0;
    private static final int SCALE_READING = 1;
   
    private double m_dWeightBuffer;
    private int m_iStatusScale;
       
    /** Creates a new instance of ScaleComm
     * @param sPortPrinter */
    public ScaleComm(String sPortPrinter) {
        m_sPortScale = sPortPrinter;
        m_out = null;
        m_in = null;
       
        m_iStatusScale = SCALE_READY;
        m_dWeightBuffer = 0.0;
    }
   
    /**
     *
     * @return
     */
    @Override
    public Double readWeight() {
       
        synchronized(this) {

            if (m_iStatusScale != SCALE_READY) {
                try {
                    wait(1000);
                } catch (InterruptedException e) {
                }
                if (m_iStatusScale != SCALE_READY) {
                    // bascula tonta.
                    m_iStatusScale = SCALE_READY;
                }
            }
           
            // Ya estamos en SCALE_READY
            m_dWeightBuffer = 0.0;
            write(new byte[] {0x05});
            flush();            
           
            // Esperamos un ratito
            try {
                wait(1000);
            } catch (InterruptedException e) {
            }
           
            if (m_iStatusScale == SCALE_READY) {
                // a value as been readed.
                double dWeight = m_dWeightBuffer / 1000.0;
                m_dWeightBuffer = 0.0;
                return new Double(dWeight);
            } else {
                m_iStatusScale = SCALE_READY;
                m_dWeightBuffer = 0.0;
                return new Double(0.0);
            }
        }
    }
   
    private void flush() {
        try {
            m_out.flush();
        } catch (IOException e) {
        }      
    }
   
    private void write(byte[] data) {
        try {
            if (m_out == null) {
                m_PortIdPrinter = CommPortIdentifier.getPortIdentifier(m_sPortScale); // Tomamos el puerto                  
                m_CommPortPrinter = (SerialPort) m_PortIdPrinter.open("PORTID", 2000); // Abrimos el puerto      

                m_out = m_CommPortPrinter.getOutputStream(); // Tomamos el chorro de escritura  
                m_in = m_CommPortPrinter.getInputStream();
               
                m_CommPortPrinter.addEventListener(this);
                m_CommPortPrinter.notifyOnDataAvailable(true);
               
                m_CommPortPrinter.setSerialPortParams(4800, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_ODD); // Configuramos el puerto
            }
            m_out.write(data);
        } catch (NoSuchPortException | PortInUseException | UnsupportedCommOperationException | TooManyListenersException | IOException e) {
        }      
    }
   
    /**
     *
     * @param e
     */
    @Override
    public void serialEvent(SerialPortEvent e) {

    // Determine type of event.
    switch (e.getEventType()) {
            case SerialPortEvent.BI:
            case SerialPortEvent.OE:
            case SerialPortEvent.FE:
            case SerialPortEvent.PE:
            case SerialPortEvent.CD:
            case SerialPortEvent.CTS:
            case SerialPortEvent.DSR:
            case SerialPortEvent.RI:
            case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
                break;
            case SerialPortEvent.DATA_AVAILABLE:
                try {
                    while (m_in.available() > 0) {
                        int b = m_in.read();

                        if (b == 0x001E) { // RS ASCII
                            // Fin de lectura
                            synchronized (this) {
                                m_iStatusScale = SCALE_READY;
                                notifyAll();
                            }
                        } else if (b > 0x002F && b < 0x003A){
                            synchronized(this) {
                                if (m_iStatusScale == SCALE_READY) {
                                    m_dWeightBuffer = 0.0; // se supone que esto debe estar ya garantizado
                                    m_iStatusScale = SCALE_READING;
                                }
                                m_dWeightBuffer = m_dWeightBuffer * 10.0 + b - 0x0030;
                            }
                        } else {
                            // caracteres invalidos, reseteamos.
                            m_dWeightBuffer = 0.0; // se supone que esto debe estar ya garantizado
                            m_iStatusScale = SCALE_READY;
                        }
                    }

                } catch (IOException eIO) {}
                break;
        }

    }      
}
Nur wo fange ich da an bzw. wie kombiniere ich den Treiber mit dem Scriptteil

Danke für alle Hilfestellungen
 
Ich glaube am schnellsten ist es sich die Grundlagen von Delphy anzueigenen und eben winen Wrapper zu schreiben...
 
Ich glaube am schnellsten ist es sich die Grundlagen von Delphy anzueigenen und eben winen Wrapper zu schreiben...
Fein und wie bekomme ich dann den Wrapper (keine Ahnung was du damit gerade meinst) in die Java Kasse eingebunden?

fertigen Delphi Quellcode dazu hätte ich sogar schon

Code:
unit unt_scale;

interface

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

type
  TFrm_Scale = class(TForm)
    Panel1: TPanel;
    Label2: TLabel;
    GroupBox1: TGroupBox;
    Label1: TLabel;
    GroupBox2: TGroupBox;
    GroupBox3: TGroupBox;
    GroupBox4: TGroupBox;
    Label3: TLabel;
    Label4: TLabel;
    Label5: TLabel;
    Label6: TLabel;
    Label7: TLabel;
    SpeedButton1: TSpeedButton;
    Button1: TButton;
    Button2: TButton;
    Label8: TLabel;
    Label9: TLabel;
    Label10: TLabel;
    Button3: TButton;
    Button4: TButton;
    Edit5: TEdit;
    Edit3: TEdit;
    Edit4: TEdit;
    procedure SpeedButton1Click(Sender: TObject);
    procedure FormShow(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure Button4Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }

    Comport_Number:integer;
    Artikel_Name:String;
    Tara:String;
    VK_Preis:String;
  end;

var
  Frm_Scale: TFrm_Scale;

implementation

Function OpenComPort(x:integer):integer; cdecl; external 'BDD6.dll'
function CloseComPort:integer;  cdecl; external 'BDD6.dll'
function SendData(Grund_Preis:Pchar; Tara_Wert :Pchar; Artikel_Name:pchar) :     LongInt;   cdecl; external  'BDD6.dll'

function LogicalVersN(x:boolean):cardinal; cdecl; external 'BDD6.dll'

function ReceiveData(xx1:string; xx2:string; xx3:string):LongInt;   external 'BDD6.dll'

function GetErrorString(x:longint):pchar;cdecl; external 'BDD6.dll'

{$R *.dfm}

procedure TFrm_Scale.SpeedButton1Click(Sender: TObject);
begin
  Close;
   CloseComPort;
end;

procedure TFrm_Scale.FormShow(Sender: TObject);
begin
  if Comport_Number > 0 then
  begin
      if OpenComPort(Comport_Number) = 0 then
      begin
        
      end
      else
        Label2.Caption := GetErrorString(OpenComPort(Comport_Number));
  end
  else
    showmessage('Comport nummer ist ungültig...');
end;

procedure TFrm_Scale.FormCreate(Sender: TObject);
begin
  Comport_Number := 1;
end;

procedure TFrm_Scale.Button1Click(Sender: TObject);
begin
{  Artikel_Name := pchar(trim(Edit3.Text));
  Tara:= Pchar(trim(Edit2.Text));
  VK_Preis := pchar(trim(Edit1.Text));

  SendData(    pchar(trim(Edit3.Text)) ,Pchar(trim(Edit2.Text)), pchar(trim(Edit1.Text))   );

  //Label2.Caption := GetErrorString(   SendData(    pchar(trim(Edit3.Text)) ,Pchar(trim(Edit2.Text)), pchar(trim(Edit1.Text))   )    );
}

  SendData(Pchar(trim(Edit3.Text)),'0',Pchar(Trim(Edit5.Text)));

end;

procedure TFrm_Scale.Button3Click(Sender: TObject);
begin
 LogicalVersN(True);

end;

procedure TFrm_Scale.Button4Click(Sender: TObject);
begin
 LogicalVersN(False);

end;

end.
Aber ich denke es ist einfacher einfach den Funktionierenden Windows Treiber zu integrieren, nur die Frage wo anfangen
 
Aber ich denke es ist einfacher einfach den Funktionierenden Windows Treiber zu integrieren, nur die Frage wo anfangen
Das ginge via JNI bzw. einfacher via JNA.

Aber ich glaube, Deine Waage spricht https://www.sbzsystems.com/download/pdf/Check-D-06-eng.pdf - das scheint so das Standardprotokoll zu sein und wird hier https://www.pos-kassensysteme.de/component/bdthemes_shortcodes/?view=download&id=50bb9c1f107659a05b875754f013ad auch im Zusammenhang mit Deiner Waage genannt.
 
Das ginge via JNI bzw. einfacher via JNA.

Aber ich glaube, Deine Waage spricht https://www.sbzsystems.com/download/pdf/Check-D-06-eng.pdf - das scheint so das Standardprotokoll zu sein und wird hier https://www.pos-kassensysteme.de/component/bdthemes_shortcodes/?view=download&id=50bb9c1f107659a05b875754f013ad auch im Zusammenhang mit Deiner Waage genannt.
Ja es ist Dialog 6, daher ja auch der Windowstreiber BDD6 nur jetzt halt meine Frage das ganze einbinden JNA ist glaube ich auch der beste Weg, lese mir das nachher noch in Ruhe durch.

Habe einfach viel zu lange nicht mehr mit Java gearbeitet (so 15 Jahre sind das locker her) und muss mich mühsam wieder da rein denken
 
Ich würde den Spaß (Dialog 6) einfach ohne JNA in den Java-Treiber einbauen.
Wenn du mir einen kleinen Schubs in die richtige Richtung geben könntest wäre das lieb.
Ich habe die ganze Treiber Datei gezippt und in das lib Verzeichnis gestellt und in die Bibliothek eingelesen, mit folgender Strucktur:

BDD6.zip
- <Standartpaket>
-- BDD6.dll
--BDD6.h
--BDD6.lib
--Dialog6App.exe

Hier sollte es wohl reichen die BDD6.dll zu importieren oder nur die Zip Datei?

Code:
import lib.BDD6;
nur was benötige ich alles zum senden und empfangen, die Dokumente dazu sind gut versteckt ich habe zwei Java Bücher hier und habe nichts passendes dazu finden können, eventuell übersehen oder falsch gesucht
 
Wenn du mir einen kleinen Schubs in die richtige Richtung geben könntest wäre das lieb.
Wenn Du die DLL verwenden willst, kannst Du Dir hier anschauen, wie das funktioniert. Ganz am Ende ist ein Link für ein Tool, das Dir das Interface ggf. anhand der Headerdatei generiert.

Ich würde trotzdem einfach das Protokoll implementieren, so wie es auf Page 6 in dem PDF zum Protokoll angegeben ist. Macht mehr Spaß als irgendeine Lib des Herstellers einzubinden :)
 
Wenn Du die DLL verwenden willst, kannst Du Dir hier anschauen, wie das funktioniert. Ganz am Ende ist ein Link für ein Tool, das Dir das Interface ggf. anhand der Headerdatei generiert.

Ich würde trotzdem einfach das Protokoll implementieren, so wie es auf Page 6 in dem PDF zum Protokoll angegeben ist. Macht mehr Spaß als irgendeine Lib des Herstellers einzubinden :)
Das Protokol ist sicher besser, wo bekomme ich aber dazu nähere Informationen eine Übersicht der Steuerzeichen,

oder wie sollte der output stream aussehen
 
Das sind Standardcodes: https://de.wikipedia.org/wiki/Steuerzeichen

Viel interessanter wäre: weißt Du, wie die Prüfsumme berechnet wird? Also, welche Werte Du bei SetCSKW(MYDWORD, MYDWORD); (die Funktion aus der DLL) einsetzen musst?
Sorry Übersicht der Steuerzeichen habe ich sollte es heißen, ist geschluckt worden.

Bei den Prüfsummen hängt es ja hauptsächlich,

der vorhandene Code liest ja nur aus

Code:
           m_dWeightBuffer = 0.0;
            write(new byte[] {0x05});
            flush();             
            
            // Esperamos un ratito
            try {
                wait(1000);
            } catch (InterruptedException e) {
            }
            
            if (m_iStatusScale == SCALE_READY) {
                // a value as been readed.
                double dWeight = m_dWeightBuffer / 1000.0;
                m_dWeightBuffer = 0.0;
                return new Double(dWeight);
            } else {
                m_iStatusScale = SCALE_READY;
                m_dWeightBuffer = 0.0;
                return new Double(0.0);
            }
        }
    }
ich müsste aber erst mal den Wert PriceSell an die Waage übergeben
 
Die Übertragung ist das geringste Problem. Du müsstest erst einmal wissen, wie die Prüfsummen berechnet werden. Ansonsten sieht das schlecht aus - egal, ob mit DLL oder Java.
 
Die Übertragung ist das geringste Problem. Du müsstest erst einmal wissen, wie die Prüfsummen berechnet werden. Ansonsten sieht das schlecht aus - egal, ob mit DLL oder Java.
Wo bekomme ich diese her oder kann ich eigene setzen?

ich habe mal den Serial Port ausgelesen wärend der Nutzung der App für den treiber

Code:
Initialisierung der Waage an COM 3
#######################################################################################################################
[08/08/2019 20:55:39]
1 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_BAUD_RATE - Returns the baud rate that is currently set for a COM port
            BaudRate - 9600
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
3 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_LINE_CONTROL - Request returns information about the line control set for a COM port
            StopBits   - 0 (1 stop bit)
            Parity     - 1 (ODD_PARITY)
            WordLength - 7
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
5 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_CHARS - Request returns the special characters that Serial uses with handshake flow control
            EofChar   - 0
            ErrorChar - 0
            BreakChar - 0
            EventChar - 0
            XonChar   - 17
            XoffChar  - 19
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
7 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_HANDFLOW - Request returns information about the configuration of the handshake flow control set for a COM port
            ControlHandShake - 0x00 
            FlowReplace      - 0x40 (SERIAL_RTS_CONTROL)
            XonLimit         - 2048
            XoffLimit        - 512
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
9 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_BAUD_RATE - Returns the baud rate that is currently set for a COM port
            BaudRate - 9600
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
11 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_LINE_CONTROL - Request returns information about the line control set for a COM port
            StopBits   - 0 (1 stop bit)
            Parity     - 1 (ODD_PARITY)
            WordLength - 7
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
13 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_CHARS - Request returns the special characters that Serial uses with handshake flow control
            EofChar   - 0
            ErrorChar - 0
            BreakChar - 0
            EventChar - 0
            XonChar   - 17
            XoffChar  - 19
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
15 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_HANDFLOW - Request returns information about the configuration of the handshake flow control set for a COM port
            ControlHandShake - 0x00 
            FlowReplace      - 0x40 (SERIAL_RTS_CONTROL)
            XonLimit         - 2048
            XoffLimit        - 512
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
17 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_SET_BAUD_RATE - Request sets the baud rate on a COM port. Serial verifies the specified baud rate
            BaudRate - 9600
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
19 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_CLR_RTS - Request clears the RTS control signal 
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
21 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_CLR_DTR - Request clears the DTR control signal. 
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
23 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_SET_LINE_CONTROL - Request sets the line control register
            StopBits   - 0 (1 stop bit)
            Parity     - 1 (ODD_PARITY)
            WordLength - 7
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
25 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_SET_CHARS - Request sets the special characters that Serial uses for handshake flow control
            EofChar   - 0
            ErrorChar - 0
            BreakChar - 0
            EventChar - 0
            XonChar   - 17
            XoffChar  - 19
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
27 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_SET_HANDFLOW - Request sets the configuration of handshake flow control
            ControlHandShake - 0x00 
            FlowReplace      - 0x00 
            XonLimit         - 2048
            XoffLimit        - 512
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
29 IRP_MJ_CLOSE - Close a COM port (COM3)
    STATUS_SUCCESS
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
31 IRP_MJ_CREATE - Opens a COM port (COM3)
    STATUS_SUCCESS
        Opened by:
            C:\Users\Werner\Desktop\SCALE\Dialog6App.exe
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
33 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_SET_WAIT_MASK - Request configures Serial to notify a client after the occurrence of any one of a specified set of wait events
            Mask - 0x00000000 
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
35 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_SET_QUEUE_SIZE - Request sets the size of the internal receive buffer
            InSize  - 4096
            OutSize - 4096
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
37 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_PURGE - Request cancels the specified requests and deletes data from the specified buffers
            Flags - 0x0000000f
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
39 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_SET_TIMEOUTS - Request sets the timeout value's that the driver uses with read and write requests
            ReadIntervalTimeout         - -1
            ReadTotalTimeoutMultiplier  - 5
            ReadTotalTimeoutConstant    - 10
            WriteTotalTimeoutMultiplier - 5
            WriteTotalTimeoutConstant   - 10
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
41 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_BAUD_RATE - Returns the baud rate that is currently set for a COM port
            BaudRate - 9600
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
43 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_LINE_CONTROL - Request returns information about the line control set for a COM port
            StopBits   - 0 (1 stop bit)
            Parity     - 1 (ODD_PARITY)
            WordLength - 7
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
45 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_CHARS - Request returns the special characters that Serial uses with handshake flow control
            EofChar   - 0
            ErrorChar - 0
            BreakChar - 0
            EventChar - 0
            XonChar   - 17
            XoffChar  - 19
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
47 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_HANDFLOW - Request returns information about the configuration of the handshake flow control set for a COM port
            ControlHandShake - 0x00 
            FlowReplace      - 0x00 
            XonLimit         - 2048
            XoffLimit        - 512
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
49 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_BAUD_RATE - Returns the baud rate that is currently set for a COM port
            BaudRate - 9600
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
51 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_LINE_CONTROL - Request returns information about the line control set for a COM port
            StopBits   - 0 (1 stop bit)
            Parity     - 1 (ODD_PARITY)
            WordLength - 7
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
53 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_CHARS - Request returns the special characters that Serial uses with handshake flow control
            EofChar   - 0
            ErrorChar - 0
            BreakChar - 0
            EventChar - 0
            XonChar   - 17
            XoffChar  - 19
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
55 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_GET_HANDFLOW - Request returns information about the configuration of the handshake flow control set for a COM port
            ControlHandShake - 0x00 
            FlowReplace      - 0x00 
            XonLimit         - 2048
            XoffLimit        - 512
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
57 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_SET_BAUD_RATE - Request sets the baud rate on a COM port. Serial verifies the specified baud rate
            BaudRate - 9600
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
59 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_SET_RTS - Request sets RTS
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
61 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_CLR_DTR - Request clears the DTR control signal. 
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
63 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_SET_LINE_CONTROL - Request sets the line control register
            StopBits   - 0 (1 stop bit)
            Parity     - 1 (ODD_PARITY)
            WordLength - 7
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
65 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_SET_CHARS - Request sets the special characters that Serial uses for handshake flow control
            EofChar   - 0
            ErrorChar - 0
            BreakChar - 0
            EventChar - 0
            XonChar   - 17
            XoffChar  - 19
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
67 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_SET_HANDFLOW - Request sets the configuration of handshake flow control
            ControlHandShake - 0x00 
            FlowReplace      - 0x40 (SERIAL_RTS_CONTROL)
            XonLimit         - 2048
            XoffLimit        - 512
----------------------------------------------------------------------------------
[08/08/2019 20:55:39]
69 IRP_MJ_DEVICE_CONTROL - Request operates a serial port (COM3)
    STATUS_SUCCESS
        IOCTL_SERIAL_PURGE - Request cancels the specified requests and deletes data from the specified buffers
            Flags - 0x0000000c
----------------------------------------------------------------------------------

##########################################################################################
senden von 555 als Preis an Waage
###########################################################################################

----------------------------------------------------------------------------------
[08/08/2019 20:57:56]
71 IRP_MJ_WRITE - Request transfers data from a client to a COM port (COM3) - 26 bytes of 26
    STATUS_SUCCESS
            04 02 30 34 1b 30 35 35 35 30 30 1b 20 20 20 20   ..04.055500.     
            20 20 20 20 20 20 20 20 20 03                              .       
----------------------------------------------------------------------------------
[08/08/2019 20:57:57]
73 IRP_MJ_READ - Transfers data from a COM port to a client (COM3) - 1 bytes of 256
    STATUS_SUCCESS
            06                                                .               
----------------------------------------------------------------------------------

##################################################################
von Waage lesen Ergebnis 0,140kg 555€/kg 77,70€
##################################################################

[08/08/2019 20:59:55]
75 IRP_MJ_WRITE - Request transfers data from a client to a COM port (COM3) - 2 bytes of 2
    STATUS_SUCCESS
            04 05                                             ..               
----------------------------------------------------------------------------------
[08/08/2019 20:59:55]
77 IRP_MJ_READ - Transfers data from a COM port to a client (COM3) - 1 bytes of 256
    STATUS_SUCCESS
            15                                                .               
----------------------------------------------------------------------------------
[08/08/2019 20:59:55]
79 IRP_MJ_WRITE - Request transfers data from a client to a COM port (COM3) - 5 bytes of 5
    STATUS_SUCCESS
            04 02 30 38 03                                    ..08.           
----------------------------------------------------------------------------------
[08/08/2019 20:59:55]
81 IRP_MJ_READ - Transfers data from a COM port to a client (COM3) - 7 bytes of 256
    STATUS_SUCCESS
            02 30 39 1b 33 30 03                              .09.30.         
----------------------------------------------------------------------------------
[08/08/2019 21:00:04]
83 IRP_MJ_WRITE - Request transfers data from a client to a COM port (COM3) - 2 bytes of 2
    STATUS_SUCCESS
            04 05                                             ..               
----------------------------------------------------------------------------------
[08/08/2019 21:00:04]
85 IRP_MJ_READ - Transfers data from a COM port to a client (COM3) - 26 bytes of 256
    STATUS_SUCCESS
            02 30 32 1b 33 1b 30 30 31 34 30 1b 30 35 35 35   .02.3.00140.0555
            30 30 1b 30 30 37 37 37 30 03                     00.007770.       
----------------------------------------------------------------------------------
habe die Schritte meiner Handlung immer über die einzelnen Punkte gesetzt, vieleicht hilft das ja
 
habe die Schritte meiner Handlung immer über die einzelnen Punkte gesetzt, vieleicht hilft das ja
Ja, anscheinend verlangt Deine Waage den Spaß gar nicht. Dann ist das Protokoll doch noch viel einfacher umzusetzen.

Du fängst einfach damit an, den Preis rauszuschreiben, also oben:

write(new byte[] {0x04,0x02,0x30,0x34,0x1b,0x30,0x35,0x35,0x35,0x30,0x30,0x1b,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,,0x03});

Unten im switch reagierst Du einfach auf die empfangenen Bytes: wenn das erste Byte ein 0x0f ist, schickst Du 0x04, 0x02, 0x30, 0x38, 0x03 raus. In allen anderen Fällen schickst Du 0x04, 0x05 zurück, ggf. erst, nachdem Du einen Frame gelesen hast. Ein Frame beginnt mit 0x02 und endet mit 0x03. Wenn Du einen Frame erhalten hast, der mit 0x02, 0x30, 0x32, 0x1b beginnt, hast Du das Ergebnis der Waage erhalten und bist fertig.
 
Ja, anscheinend verlangt Deine Waage den Spaß gar nicht. Dann ist das Protokoll doch noch viel einfacher umzusetzen.
Das Protokol wurde von dem Windows Treiber BDD6 abgegriffen kann sein das die Daten intern verarbeitet und nicht gesendet wurden aber probieren schadet nichts.

Du fängst einfach damit an, den Preis rauszuschreiben, also oben:

write(new byte[] {0x04,0x02,0x30,0x34,0x1b,0x30,0x35,0x35,0x35,0x30,0x30,0x1b,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,,0x03});
kannst Du mir den Byte Aufbau genauer erklären?

0x04 = EOT, 0x02 = Frame Start und 0x03 = Frame Ende, dazwischen blicke ich kaum durch nehme aber an das die dazwischen stehenden HEX Daten für Preis und Tara Werte stehen nur wie teilt sich das auf

Unten im switch reagierst Du einfach auf die empfangenen Bytes: wenn das erste Byte ein 0x0f ist, schickst Du 0x04, 0x02, 0x30, 0x38, 0x03 raus. In allen anderen Fällen schickst Du 0x04, 0x05 zurück, ggf. erst, nachdem Du einen Frame gelesen hast. Ein Frame beginnt mit 0x02 und endet mit 0x03. Wenn Du einen Frame erhalten hast, der mit 0x02, 0x30, 0x32, 0x1b beginnt, hast Du das Ergebnis der Waage erhalten und bist fertig.
Das ist schon genauer etwas detailierter würde mir das verstehen einfacher machen

Danke
 
Geht aus dem obige Dokument hervor, direkt auf der ersten Seite: https://www.sbzsystems.com/download/pdf/Check-D-06-eng.pdf :)

Die Werte sind aus deinem Beispiel, dies hier ist das Senden von Preis und Text (Record No. 4):
0x04,0x02,0x30,0x34,0x1b,0x30,0x35,0x35,0x35,0x30,0x30,0x1b,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x03

Der Preis ist dies: 0x30,0x35,0x35,0x35,0x30,0x30, was 055500 entspricht.
Der Text sind die ganzen 0x20, was Leerzeichen sind.
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben