Datalogic Waage an Comport


werner_sg

Erfahrenes Mitglied
#1
Hallo ich würde gerne folgenden Code

Code:
/*


package uk.chromis.pos.scale;

import gnu.io.*;
import java.awt.Component;
import java.awt.Dimension;
import java.io.*;
import java.util.TooManyListenersException;
import uk.chromis.pos.forms.AppLocal;
import java.util.logging.Logger;

import java.awt.Font;
import java.util.logging.Level;
import javax.swing.plaf.FontUIResource;
import javax.swing.JOptionPane;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.UIManager;

/**
*
*  
*/
public class ScaleAdam implements Scale, SerialPortEventListener {
   
    private static final Logger logger = Logger.getLogger("uk.chromis.pos.scale.ScaleAdam");

    private CommPortIdentifier m_PortId;
    private NRSerialPort m_CommPort;
   
    private String m_sPortScale;
    private OutputStream m_out;
    private InputStream m_in;

    private static final int SCALE_READY = 0;
    private static final int SCALE_READING = 1;
    private static final int SCALE_USERPRESSEDOK = 2;
    private static final int SCALE_USERPRESSEDCANCEL = 3;
    private static int SCALE_ERROR = -1;
   
    private String m_WeightBuffer;
    private int m_iStatusScale;
    private Component mParent;
    private Font m_OriginalFont;
    private JDialog m_Dialog;
   
    /** Creates a new instance of ScaleComm
     * @param sPortPrinter */
    public ScaleAdam(String sPortPrinter, Component parent ) {
        m_sPortScale = sPortPrinter;
        m_out = null;
        m_in = null;
       
        m_iStatusScale = SCALE_READY;
        m_WeightBuffer = "";
       
         mParent = parent;
    }
   
    private void showDialog() {

        // Get details of the original font before we change it otherwise all dialogboxes will use new settings
        JOptionPane pane = new JOptionPane();
        Font originalFont=pane.getFont();

        UIManager.put("OptionPane.buttonFont", new FontUIResource(new Font("ARIAL",Font.PLAIN,20)));
        String message =  AppLocal.getIntString("scale.weighitem");
        JLabel FontText = new JLabel(message);
        FontText.setFont (new Font ( "Arial", Font.BOLD, 36) );

        JOptionPane newpane = new JOptionPane( FontText, JOptionPane.PLAIN_MESSAGE, JOptionPane.CANCEL_OPTION, null, new Object[]{"Cancel"} );
        newpane.setPreferredSize( new Dimension(450,150));
        m_Dialog = newpane.createDialog("Use Scales");
       
        m_Dialog.setVisible( true );
       
        // Return to default settings
        UIManager.put("OptionPane.buttonFont", new FontUIResource(new Font(originalFont.getName(),originalFont.getStyle(),originalFont.getSize())));

        if( m_iStatusScale ==  SCALE_READING ) {
            // User must have pressed cancel
            changeStatus( SCALE_USERPRESSEDCANCEL );
        }

    }
   
    private void backgroundReadInput( final int nTimeout ) {
        Thread readThread = new Thread() {
            public void run() {
                readInput(nTimeout);
            }
        };
        readThread.start();
    }
       
    private void readInput( int nTimeout ) {

        while( --nTimeout > 0 && m_iStatusScale ==  SCALE_READING ) {
            try {
                synchronized (this) {
                    wait(1000);
                }
            } catch (InterruptedException ex) {
               changeStatus( SCALE_ERROR );
            }
        }

        if( m_iStatusScale ==  SCALE_READING ) {
            // must have timed out
            changeStatus( SCALE_ERROR );
        }
           
    }

    private void changeStatus( int status ) {
   
        m_iStatusScale = status;
       
        if( status != SCALE_READING ) {
            if( m_Dialog != null )
                m_Dialog.setVisible(false);
        }
    }
   
    /**
     *
     * @return
     */
    @Override
    public Double readWeight() {
       
        synchronized(this) {
            m_iStatusScale =  SCALE_READING;
            m_WeightBuffer = "";
           
            try {
                if (m_out == null) {
                    m_CommPort = new NRSerialPort(m_sPortScale, 4800);
                    m_CommPort.connect();
                    m_CommPort.addEventListener(this);
                    m_CommPort.notifyOnDataAvailable(true);

                    m_out = m_CommPort.getOutputStream();
                    m_in = m_CommPort.getInputStream();
                }
            } catch ( TooManyListenersException e ) {
                logger.log(Level.SEVERE, "Port exception", e );
                changeStatus( SCALE_ERROR );
            }
           
            backgroundReadInput( 60 );
        }
       
        showDialog();
           
        synchronized(this) {
            try {
                if (m_out != null)
                    m_out.close();
                if (m_in != null)
                    m_in.close();
                if (m_CommPort != null) {
                    m_CommPort.removeEventListener();
                    m_CommPort.disconnect();
                }
            } catch ( IOException e ) {
            }
            m_out = null;
            m_in = null;
            m_CommPort = null;
            m_PortId = null;

            if( m_Dialog != null )
                m_Dialog.setVisible(false);
            m_Dialog = null;
           
            if (m_iStatusScale == SCALE_READY && m_WeightBuffer != null && m_WeightBuffer.isEmpty() == false ) {
               
                logger.log(Level.INFO, "Scale ready", m_WeightBuffer );
               
                double dWeight = Double.parseDouble( m_WeightBuffer );
               
                return dWeight;
            } else {

                logger.log(Level.WARNING, "Scale no data", m_WeightBuffer );
               
                // Timed out looking for weight or error
                return null;
            }
        }
    }

    private void write(byte[] data) {
        synchronized (this) {
            try {
                m_out.write(data);
            } catch ( IOException e) {
                assert( false );
            }      
        }
    }
   
    /**
     *
     * @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:
                synchronized (this) {

                    try {
                        while (m_in.available() > 0) {
                            int b = m_in.read();

                            logger.log(Level.WARNING, "Scale sent", Character.toString ((char) b) );

                            if (b == 0x000D) { // CR ASCII
                                // End of Line
                                synchronized (this) {
                                    changeStatus( SCALE_READY );
                                    notifyAll();
                                }
                            } else {
                                if( b == 0x2e || (b >= 0x30  && b <= 0x39 ) ) {  // Ascii for period or 0-9
                                    m_WeightBuffer = m_WeightBuffer + Character.toString ((char) b);
                                }
                            }
                        }
                    } catch (IOException eIO) {
                        logger.log(Level.SEVERE, "Scale io error", eIO );
                        changeStatus( SCALE_ERROR );
                    }
                }
                break;
        }
    }
}
für eine Waagen Anbindung am COM so ändern das er dafür die folgende DLL nutzt

Code:
// 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
in Delphi sah das so aus

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.
wer kann mir da erklärend weiterhelfen

eventuell besteht ja auch die Möglichkeit die Delphie Datei anzupassen das Sie Java tauglich ist :)

Danke